import * as NodeURL from "node:url";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { describe, expect, it } from "@effect/vitest";
import {
CommandId,
EnvironmentId,
isProviderNativeSubagentThread,
MessageId,
type ModelSelection,
OrchestratorMcpDelegateTaskResult,
OrchestratorMcpThreadInterruptResult,
OrchestratorMcpThreadSendResult,
ProjectId,
ProviderDriverKind,
ProviderInstanceId,
type ProviderOptionDescriptor,
type ServerProvider,
ThreadId,
} from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import * as Tracer from "effect/Tracer";
import { McpSchema, McpServer } from "effect/ai";
import { CodexOrchestratorReplayHarness } from "../orchestration-v2/Adapters/CodexAdapterV2.testkit.ts";
import * as CommandReceiptStore from "../orchestration-v2/CommandReceiptStore.ts";
import * as Orchestrator from "../orchestration-v2/Orchestrator.ts";
import * as ThreadLaunchService from "../orchestration-v2/ThreadLaunchService.ts";
import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as SqlitePersistence from "../persistence/Sqlite.ts";
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
import * as SecretResolver from "@t3tools/secret-provider-core/server/SecretResolver";
import { checkpointWorkspace } from "@t3tools/provider-testing/replayWorkspace";
import * as ProviderReplayHarness from "../orchestration-v2/testkit/ProviderReplayHarness.ts";
import {
decodeProviderReplayNdjson,
materializeReplayTranscriptWorkspace,
} from "@t3tools/provider-testing/replayTranscript";
import * as ProviderRegistryMock from "../provider/testUtils/providerRegistryMock.ts";
import * as ProjectService from "../project/ProjectService.ts";
import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
import * as SecretRequests from "../secrets/SecretRequests.ts";
import * as RemoteDelegation from "../peer/RemoteDelegation.ts";
import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
import * as McpHttpServer from "./McpHttpServer.ts";
import * as McpInvocationContext from "./McpInvocationContext.ts";
import * as PeerForwarding from "../peer/PeerForwarding.ts";
import * as PeerLinkRequests from "../peer/PeerLinkRequests.ts";
import * as PeerLinks from "../peer/PeerLinks.ts";
const layerOrchestratorToolkit = McpHttpServer.layerOrchestratorToolkit.pipe(
Layer.provide(Layer.mock(ThreadLaunchService.ThreadLaunchService)({})),
Layer.provide(Layer.mock(GitVcsDriver.GitVcsDriver)({})),
);
/** A task delegated here always has a local child thread. */
const localChild = (childThreadId: ThreadId | null): ThreadId => {
if (childThreadId === null) throw new Error("expected a local delegated child");
return childThreadId;
};
// Effect returns a declared tool failure as `isError` with its encoded payload
// as JSON text, never as `structuredContent`.
const parentThreadId = ThreadId.make("thread:mcp-orchestrator-parent");
const projectId = ProjectId.make("project:mcp-orchestrator");
const codexInstanceId = ProviderInstanceId.make("codex");
const codexModel = "gpt-5.4";
const parentPrompt = "Keep this parent turn active while orchestration tools are tested.";
const delegatedPrompt = "Inspect the delegated API boundary and return the result.";
const delegatedResult = "Delegated API boundary inspected.";
const cancellationPrompt = "Remain active until the parent cancels this delegated task.";
const queuedFollowupPrompt = "Complete the queued follow-up and return the final result.";
const queuedFollowupResult = "Queued delegated follow-up completed.";
const decodeDelegateTaskResult = Schema.decodeUnknownEffect(OrchestratorMcpDelegateTaskResult);
const decodeThreadInterruptResult = Schema.decodeUnknownEffect(
OrchestratorMcpThreadInterruptResult,
);
const decodeThreadSendResult = Schema.decodeUnknownEffect(OrchestratorMcpThreadSendResult);
const codexSelection = {
instanceId: codexInstanceId,
model: codexModel,
} satisfies ModelSelection;
const delegatedTaskStatusTranscriptFile = new URL(
"../orchestration-v2/testkit/fixtures/delegated_task_status/codex_transcript.ndjson",
import.meta.url,
);
const readDelegatedTaskStatusTranscript = Effect.fn("readDelegatedTaskStatusTranscript")(
function* (followupResult: string) {
const fs = yield* FileSystem.FileSystem;
const text = yield* fs.readFileString(NodeURL.fileURLToPath(delegatedTaskStatusTranscriptFile));
const transcript = yield* decodeProviderReplayNdjson(
text.replaceAll(queuedFollowupResult, followupResult),
);
// The recording ends when the recorder closes the app-server while the parent
// turn is still open. This test keeps acting as that parent afterwards, and
// replaying the exit would kill the shared process and fail the parent run.
return {
...transcript,
entries: transcript.entries.filter((entry) => entry.type !== "runtime_exit"),
};
},
Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
);
function makeProviderSnapshot(input: {
readonly instanceId: ProviderInstanceId;
readonly driver: ProviderDriverKind;
readonly model: string;
readonly optionDescriptors?: ReadonlyArray<ProviderOptionDescriptor>;
}): ServerProvider {
return {
instanceId: input.instanceId,
driver: input.driver,
enabled: true,
installed: true,
version: "test",
status: "ready",
auth: { status: "authenticated" },
checkedAt: "2026-06-17T00:00:00.000Z",
models: [
{
slug: input.model,
name: input.model,
isCustom: false,
capabilities:
input.optionDescriptors === undefined
? null
: { optionDescriptors: input.optionDescriptors },
},
],
slashCommands: [],
skills: [],
};
}
const client = McpSchema.McpServerClient.of({
clientId: 1,
protocolVersion: "2025-06-18",
clientCapabilities: {},
clientInfo: { name: "orchestrator-mcp-test", version: "1.0.0" },
initializePayload: {
protocolVersion: "2025-06-18",
capabilities: {},
clientInfo: { name: "orchestrator-mcp-test", version: "1.0.0" },
},
getClient: Effect.die("unused"),
});
const layerMemorySecretStore = Layer.sync(ServerSecretStore.ServerSecretStore, () => {
const stored = new Map<string, Uint8Array>();
return ServerSecretStore.ServerSecretStore.of({
get: (name) => Effect.succeed(Option.fromNullishOr(stored.get(name))),
set: (name, value) => Effect.sync(() => void stored.set(name, value)),
create: (name, value) => Effect.sync(() => void stored.set(name, value)),
getOrCreateRandom: (name, bytes) =>
Effect.sync(() => {
const existing = stored.get(name);
if (existing) return existing;
const value = new Uint8Array(bytes).fill(7);
stored.set(name, value);
return value;
}),
remove: (name) => Effect.sync(() => void stored.delete(name)),
});
});
const layerUnusedScheduledTaskStub = Layer.succeed(
ScheduledTaskService.ScheduledTaskService,
ScheduledTaskService.ScheduledTaskService.of({
list: () => Effect.succeed({ tasks: [] }),
subscribeList: () => Stream.succeed({ tasks: [] }),
upsert: () => Effect.die("ScheduledTaskService.upsert is unused in this test"),
setEnabled: () => Effect.die("ScheduledTaskService.setEnabled is unused in this test"),
delete: () => Effect.die("ScheduledTaskService.delete is unused in this test"),
deleteForThread: () => Effect.die("unused in this test"),
moveThreadTasks: () => Effect.die("unused in this test"),
runNow: () => Effect.die("ScheduledTaskService.runNow is unused in this test"),
rotateWebhookToken: () => Effect.die("unused in this test"),
listWebhookDeliveries: () => Effect.die("unused in this test"),
getWebhookDelivery: () => Effect.die("unused in this test"),
triggerWebhook: () => Effect.die("unused in this test"),
}),
);
describe("orchestrator MCP toolkit", () => {
it.live.each([
{ label: "distinct", result: queuedFollowupResult, latestSummary: queuedFollowupResult },
{ label: "identical", result: delegatedResult, latestSummary: null },
{ label: "emoji", result: "😀", latestSummary: "😀" },
])("reports $label child results", ({ result, latestSummary }) =>
Effect.scoped(
Effect.gen(function* () {
const cwd = yield* checkpointWorkspace("delegated-task-status");
const rawTranscript = yield* readDelegatedTaskStatusTranscript(result);
const transcript = yield* CodexOrchestratorReplayHarness.decodeTranscript(
materializeReplayTranscriptWorkspace(rawTranscript, cwd),
);
const layerOrchestrator = ProviderReplayHarness.layerProviderReplay(
{
name: "delegated-task-status/codex",
transcript,
commands: [],
runtimePolicyOverride: { cwd },
},
CodexOrchestratorReplayHarness,
);
const layerOrchestration = Layer.merge(
layerOrchestrator,
ThreadManagementService.layer.pipe(
Layer.provide(layerOrchestrator),
Layer.provide(ServerSettings.layerTest()),
Layer.provide(
CommandReceiptStore.layer.pipe(Layer.provide(SqlitePersistence.layerMemory)),
),
),
);
const layerProviderRegistry = ProviderRegistryMock.layer([
makeProviderSnapshot({
instanceId: codexInstanceId,
driver: ProviderDriverKind.make("codex"),
model: codexModel,
}),
]);
const layerTest = layerOrchestratorToolkit.pipe(
Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
Layer.provideMerge(layerOrchestration),
Layer.provide(
CodexOrchestratorReplayHarness.makeProviderAdapterRegistryLayer(transcript).pipe(
Layer.provide(McpProviderSessions.layer),
),
),
Layer.provide(layerProviderRegistry),
Layer.provide(ServerSettings.layerTest()),
Layer.provide(layerUnusedScheduledTaskStub),
Layer.provide(Layer.mock(PeerForwarding.PeerForwarding)({})),
Layer.provide(Layer.mock(PeerLinkRequests.PeerLinkRequests)({})),
Layer.provide(Layer.mock(PeerLinks.PeerLinks)({})),
Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
Layer.provideMerge(
SecretRequests.layer.pipe(
Layer.provide(layerMemorySecretStore),
Layer.provide(Layer.mock(SecretResolver.SecretResolver)({})),
Layer.provide(layerOrchestration),
),
),
Layer.provide(Layer.mock(RemoteDelegation.RemoteDelegation)({})),
Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
);
yield* Effect.gen(function* () {
const orchestrator = yield* Orchestrator.OrchestratorV2;
const server = yield* McpServer.McpServer;
const parentCreate = yield* orchestrator.dispatch({
type: "thread.create",
createdBy: "user",
creationSource: "web",
commandId: CommandId.make("command:mcp-replay-parent:create"),
threadId: parentThreadId,
projectId,
title: "MCP replay parent",
modelSelection: codexSelection,
runtimeMode: "full-access",
interactionMode: "default",
branch: null,
worktreePath: cwd,
});
yield* orchestrator.dispatch({
type: "message.dispatch",
createdBy: "user",
creationSource: "web",
commandId: CommandId.make("command:mcp-replay-parent:start"),
threadId: parentThreadId,
messageId: MessageId.make("message:mcp-replay-parent:start"),
text: parentPrompt,
attachments: [],
modelSelection: codexSelection,
dispatchMode: { type: "start_immediately" },
});
yield* orchestrator
.streamStoredEventsFrom({
threadId: parentThreadId,
afterSequence: parentCreate.sequence,
})
.pipe(
Stream.filter(
(stored) =>
stored.event.type === "provider-turn.updated" &&
stored.event.payload.status === "running",
),
Stream.runHead,
Effect.flatMap(
Option.match({
onNone: () => Effect.die("Parent provider turn did not start."),
onSome: () => Effect.void,
}),
),
);
const invocation: McpInvocationContext.McpInvocationScope = {
environmentId: EnvironmentId.make("environment:mcp-replay"),
requestNamespace: "mcp-provider-session-replay-parent",
thread: {
threadId: parentThreadId,
providerSessionId: "mcp-provider-session-replay-parent",
providerInstanceId: codexInstanceId,
},
client: undefined,
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
const invoke = (name: string, args: Record<string, unknown>, scope = invocation) =>
server
.callTool({ name, arguments: args })
.pipe(
Effect.provideService(McpInvocationContext.McpInvocationContext, scope),
Effect.provideService(McpSchema.McpServerClient, client),
);
const delegationStartSequence =
yield* orchestrator.getThreadEventSequence(parentThreadId);
const delegatedCall = yield* invoke("delegate_task", {
task: delegatedPrompt,
target: {
providerInstanceId: codexInstanceId,
model: codexModel,
},
mode: "async",
clientRequestId: "delegate-codex-replay-1",
});
const delegatedStart = yield* decodeDelegateTaskResult(
delegatedCall.structuredContent,
).pipe(Effect.orDie);
expect(delegatedStart.childRunId).not.toBeNull();
yield* orchestrator
.streamStoredEventsFrom({
threadId: parentThreadId,
afterSequence: delegationStartSequence,
})
.pipe(
Stream.filter(
(stored) =>
stored.event.type === "context-transfer.created" &&
stored.event.payload.type === "subagent_result" &&
stored.event.payload.sourceThreadId === delegatedStart.childThreadId &&
stored.event.payload.sourcePoint.runId === delegatedStart.childRunId,
),
Stream.runHead,
Effect.flatMap(
Option.match({
onNone: () => Effect.die("Delegated result transfer was not created."),
onSome: () => Effect.void,
}),
),
);
const delegatedStatusCall = yield* invoke("task_status", {
taskId: delegatedStart.taskId,
});
const delegated = yield* decodeDelegateTaskResult(
delegatedStatusCall.structuredContent,
).pipe(Effect.orDie);
expect(delegated).toMatchObject({
status: "completed",
summary: delegatedResult,
providerInstanceId: codexInstanceId,
hasPendingChildRuns: false,
latestTerminalRunId: delegated.childRunId,
latestTerminalStatus: "completed",
latestTerminalSummary: null,
latestTerminalResultContextTransferId: null,
});
expect(delegated.resultContextTransferId).not.toBeNull();
const delegatedChild = yield* orchestrator.getThreadProjection(
localChild(delegated.childThreadId),
);
expect(delegatedChild.thread.lineage.relationshipToParent).toBe("subagent");
expect(isProviderNativeSubagentThread(delegatedChild.thread)).toBe(false);
const followupStartSequence = yield* orchestrator.getThreadEventSequence(
localChild(delegated.childThreadId),
);
const runningFollowupCall = yield* invoke("t3_thread_send", {
threadId: localChild(delegated.childThreadId),
message: cancellationPrompt,
clientRequestId: "delegated-child-replay-running-1",
});
const runningFollowup = yield* decodeThreadSendResult(
runningFollowupCall.structuredContent,
).pipe(Effect.orDie);
yield* orchestrator
.streamStoredEventsFrom({
threadId: localChild(delegated.childThreadId),
afterSequence: followupStartSequence,
})
.pipe(
Stream.filter(
(stored) =>
stored.event.type === "provider-turn.updated" &&
stored.event.payload.status === "running",
),
Stream.runHead,
Effect.flatMap(
Option.match({
onNone: () => Effect.die("Follow-up provider turn did not start."),
onSome: () => Effect.void,
}),
),
);
const queuedFollowupCall = yield* invoke("t3_thread_send", {
threadId: localChild(delegated.childThreadId),
message: queuedFollowupPrompt,
mode: "queue",
clientRequestId: "delegated-child-replay-queued-1",
});
const queuedFollowup = yield* decodeThreadSendResult(
queuedFollowupCall.structuredContent,
).pipe(Effect.orDie);
expect(queuedFollowup).toMatchObject({
status: "queued",
delivery: "queued",
});
const pendingProjection = yield* orchestrator.getThreadProjection(
localChild(delegated.childThreadId),
);
const followupTasks = (yield* orchestrator.getThreadProjection(
parentThreadId,
)).subagents.filter(
(task) =>
task.childThreadId === delegated.childThreadId && task.id !== delegated.taskId,
);
expect(followupTasks).toHaveLength(2);
expect(followupTasks.every((task) => task.result === null)).toBe(true);
expect(followupTasks.map((task) => task.id)).toEqual([
runningFollowup.taskId,
queuedFollowup.taskId,
]);
expect(
pendingProjection.runs.find((run) => run.id === delegated.childRunId)?.status,
).toBe("completed");
expect(
pendingProjection.runs.find((run) => run.id === runningFollowup.runId)?.status,
).toBe("running");
expect(
pendingProjection.runs.find((run) => run.id === queuedFollowup.runId)?.status,
).toBe("queued");
expect(
(yield* orchestrator.getThreadProjection(parentThreadId)).runs.some(
(run) => run.status === "running",
),
).toBe(true);
const pendingStatusCall = yield* invoke("task_status", {
taskId: delegated.taskId,
});
const pendingStatus = yield* decodeDelegateTaskResult(
pendingStatusCall.structuredContent,
).pipe(Effect.orDie);
expect(pendingStatus).toMatchObject({
childRunId: delegated.childRunId,
status: "completed",
summary: delegatedResult,
resultContextTransferId: delegated.resultContextTransferId,
hasPendingChildRuns: true,
latestTerminalRunId: delegated.childRunId,
latestTerminalStatus: "completed",
latestTerminalSummary: null,
latestTerminalResultContextTransferId: null,
});
const finalSequence = yield* orchestrator.getThreadEventSequence(
localChild(delegated.childThreadId),
);
const interruptCall = yield* invoke("t3_thread_interrupt", {
threadId: localChild(delegated.childThreadId),
runId: runningFollowup.runId,
reason: "Allow the queued replay follow-up to run.",
clientRequestId: "interrupt-delegated-child-replay-1",
});
const interrupt = yield* decodeThreadInterruptResult(
interruptCall.structuredContent,
).pipe(Effect.orDie);
expect(interrupt).toMatchObject({
runId: runningFollowup.runId,
status: "interrupt_requested",
});
yield* orchestrator
.streamStoredEventsFrom({
threadId: localChild(delegated.childThreadId),
afterSequence: finalSequence,
})
.pipe(
Stream.filter(
(stored) =>
stored.event.type === "run.updated" &&
stored.event.payload.id === queuedFollowup.runId &&
stored.event.payload.status === "completed",
),
Stream.runHead,
Effect.flatMap(
Option.match({
onNone: () => Effect.die("Queued follow-up did not complete."),
onSome: () => Effect.void,
}),
),
);
const finalProjection = yield* orchestrator.getThreadProjection(
localChild(delegated.childThreadId),
);
expect(finalProjection.runs.find((run) => run.id === runningFollowup.runId)?.status).toBe(
"interrupted",
);
expect(finalProjection.runs.find((run) => run.id === queuedFollowup.runId)?.status).toBe(
"completed",
);
expect(
finalProjection.turnItems.find(
(item) =>
item.runId === runningFollowup.runId && item.type === "run_interrupt_result",
),
).toMatchObject({
message: "Stopped by an agent: Allow the queued replay follow-up to run.",
});
yield* orchestrator
.streamStoredEventsFrom({
threadId: parentThreadId,
afterSequence: finalSequence,
})
.pipe(
Stream.filter(
(stored) =>
stored.event.type === "subagent.updated" &&
stored.event.payload.id === followupTasks[1]!.id &&
stored.event.payload.status === "completed",
),
Stream.runHead,
Effect.flatMap(
Option.match({
onNone: () => Effect.die("Follow-up task did not settle."),
onSome: () => Effect.void,
}),
),
);
const finishedParent = yield* orchestrator.getThreadProjection(parentThreadId);
expect(
finishedParent.subagents.find((task) => task.id === followupTasks[0]!.id)?.status,
).toBe("interrupted");
expect(
finishedParent.subagents.find((task) => task.id === followupTasks[1]!.id),
).toMatchObject({
status: "completed",
result,
});
expect(
finishedParent.contextTransfers.filter(
(transfer) =>
transfer.type === "subagent_result" &&
transfer.sourceThreadId === delegated.childThreadId,
),
).toHaveLength(3);
expect(
finishedParent.subagents.find((task) => task.id === followupTasks[1]!.id)
?.completionDelivery?.state,
).toBe("claimed");
const finalStatusCall = yield* invoke("task_status", {
taskId: delegated.taskId,
});
const finalStatus = yield* decodeDelegateTaskResult(
finalStatusCall.structuredContent,
).pipe(Effect.orDie);
expect(finalStatus).toMatchObject({
childRunId: delegated.childRunId,
status: "completed",
summary: delegatedResult,
resultContextTransferId: delegated.resultContextTransferId,
hasPendingChildRuns: false,
latestTerminalRunId: queuedFollowup.runId,
latestTerminalStatus: "completed",
latestTerminalSummary: latestSummary,
});
const followupTransfer = finishedParent.contextTransfers.find(
(transfer) =>
transfer.type === "subagent_result" &&
transfer.sourcePoint.runId === queuedFollowup.runId,
);
expect(followupTransfer).toBeDefined();
expect(finalStatus.latestTerminalResultContextTransferId).toBe(followupTransfer?.id);
expect(finalStatus.latestTerminalResultContextTransferId).not.toBe(
delegated.resultContextTransferId,
);
const transferReads: Array<string> = [];
const messageReads: Array<string> = [];
const tracer = Tracer.make({
span(options) {
const span = new Tracer.NativeSpan(options);
const end = span.end.bind(span);
span.end = (endTime, exit) => {
end(endTime, exit);
const query = span.attributes.get("db.query.text");
if (typeof query !== "string") return;
if (
/SELECT[\s\S]*FROM orchestration_v2_projection_context_transfers/i.test(query)
) {
transferReads.push(query);
}
if (
/SELECT\s+payload_json\s+FROM orchestration_v2_projection_messages/i.test(query)
) {
messageReads.push(query);
}
};
return span;
},
});
const wait = yield* invoke(
"t3_thread_wait",
{ threadId: delegated.childThreadId, runId: queuedFollowup.runId },
{ ...invocation, thread: undefined },
).pipe(Effect.withTracer(tracer));
expect(wait.isError).not.toBe(true);
const expectedWait = {
threadId: delegated.childThreadId,
runId: queuedFollowup.runId,
status: "completed",
timedOut: false,
};
expect(wait.structuredContent).toEqual(expectedWait);
expect(messageReads).toEqual([]);
expect(transferReads).toHaveLength(0);
const settledWait = yield* invoke(
"t3_thread_wait",
{
threadId: delegated.childThreadId,
runId: queuedFollowup.runId,
untilDelegatedWorkSettled: true,
},
{ ...invocation, thread: undefined },
).pipe(Effect.withTracer(tracer));
expect(settledWait.isError).not.toBe(true);
expect(settledWait.structuredContent).toMatchObject({
...expectedWait,
resultRun: { runId: queuedFollowup.runId, status: "completed" },
});
expect(messageReads.length).toBeGreaterThan(0);
expect(
messageReads.filter((query) => query.includes("$.notification.source.kind")),
).toHaveLength(1);
// The orchestrator's restart-continuation guard still reads its own records.
expect(
messageReads.filter((query) => !query.includes("$.notification.source.kind")),
).toHaveLength(1);
const parentlessRead = yield* invoke(
"t3_thread_read",
{
threadId: delegated.childThreadId,
limit: 100,
maxCharsPerItem: result === "😀" ? 1 : 20_000,
},
{ ...invocation, thread: undefined },
).pipe(Effect.withTracer(tracer));
expect(parentlessRead.isError).not.toBe(true);
expect(transferReads).toHaveLength(0);
const afterParentlessRead = yield* orchestrator.getThreadProjection(parentThreadId);
expect(
afterParentlessRead.subagents.find((task) => task.id === queuedFollowup.taskId)
?.completionDelivery?.state,
).toBe("claimed");
const read = yield* invoke("t3_thread_read", {
threadId: delegated.childThreadId,
limit: 100,
maxCharsPerItem: result === "😀" ? 1 : 20_000,
}).pipe(Effect.withTracer(tracer));
expect(read.isError).not.toBe(true);
expect(transferReads.length).toBeGreaterThan(0);
expect(read.structuredContent).toEqual(parentlessRead.structuredContent);
const afterRead = yield* orchestrator.getThreadProjection(parentThreadId);
expect(
afterRead.subagents.find((task) => task.id === queuedFollowup.taskId)
?.completionDelivery?.state,
).toBe("acknowledged");
const messageReadsBeforeCapabilities = messageReads.length;
const capabilities = yield* invoke("orchestrator_capabilities", {}).pipe(
Effect.withTracer(tracer),
);
expect(capabilities.isError).not.toBe(true);
expect(messageReads).toHaveLength(messageReadsBeforeCapabilities);
}).pipe(Effect.provide(layerTest));
}),
),
);
});