TypeScript
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, describe, it } from "@effect/vitest";
import {
CommandId,
ContextTransferId,
EnvironmentId,
GitCommandError,
MessageId,
NodeId,
ORCHESTRATOR_MCP_RUNNING_TASK_NEXT,
type OrchestratorMcpCapabilitiesResult,
OrchestratorMcpTarget,
type OrchestrationV2ThreadShell,
type ScheduledTask,
type ScheduledTaskUpsertInput,
ScheduledTaskId,
ProjectId,
ProviderDriverKind,
ProviderInstanceId,
ProviderThreadId,
ProviderTurnId,
RunId,
ThreadId,
type OrchestrationV2ServerCommand,
type OrchestrationV2StoredEvent,
type OrchestrationV2ThreadProjection,
type ServerProvider,
} from "@t3tools/contracts";
import { checkpointWorkspace } from "@t3tools/provider-testing/replayWorkspace";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Queue from "effect/Queue";
import * as Ref from "effect/Ref";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import { CodexProviderCapabilitiesV2 } from "../orchestration-v2/Adapters/CodexAdapterV2.ts";
import * as CommandReceiptStore from "../orchestration-v2/CommandReceiptStore.ts";
import * as EffectWorker from "../orchestration-v2/EffectWorker.ts";
import * as LegacyV1ThreadImporter from "../orchestration-v2/legacy/LegacyV1ThreadImporter.ts";
import * as Orchestrator from "../orchestration-v2/Orchestrator.ts";
import * as ProviderReplayHarness from "../orchestration-v2/testkit/ProviderReplayHarness.ts";
import * as SqlitePersistence from "../persistence/Sqlite.ts";
import {
DispatchModeLimit,
type DispatchModeRefusal,
} from "../orchestration-v2/DispatchModeLimit.ts";
import {
OrchestratorProjectionError,
OrchestratorThreadAboveModeLimitError,
} from "../orchestration-v2/Orchestrator.ts";
import * as ProviderAdapterRegistry from "../orchestration-v2/ProviderAdapterRegistry.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 ProviderRegistry from "../provider/ProviderRegistry.ts";
import { buildUnavailableProviderSnapshot } from "../provider/unavailableProviderSnapshot.ts";
import * as ProjectService from "../project/ProjectService.ts";
import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as SecretRequests from "../secrets/SecretRequests.ts";
import * as RemoteDelegation from "../peer/RemoteDelegation.ts";
import type { McpInvocationScope } from "./McpInvocationContext.ts";
import { idleThreadProjection, liveThreadShell } from "./McpToolAccess.testkit.ts";
import * as OrchestratorMcpService from "./OrchestratorMcpService.ts";
import { resolveRuntimeMode } from "./delegatedTaskModes.ts";
import type { ProjectionRecordFilter } from "../orchestration-v2/ProjectionStore.ts";
import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
const decodeTarget = Schema.decodeUnknownEffect(OrchestratorMcpTarget);
const layerOrchestratorService = OrchestratorMcpService.layer.pipe(
Layer.provide(Layer.mock(ThreadLaunchService.ThreadLaunchService)({})),
Layer.provide(Layer.mock(GitVcsDriver.GitVcsDriver)({})),
);
describe("OrchestratorMcpService", () => {
it.effect("retries terminal acknowledgement with a fresh command id", () =>
Effect.gen(function* () {
const parentThreadId = ThreadId.make("thread:mcp-ack-parent");
const childThreadId = ThreadId.make("thread:mcp-ack-child");
const childRunId = RunId.make("run:mcp-ack-child");
const taskId = NodeId.make("node:mcp-ack-task");
const resultTransferId = ContextTransferId.make("transfer:mcp-ack-result");
const acknowledgementCommandIds = yield* Ref.make<ReadonlyArray<string>>([]);
const acknowledgementAttempts = yield* Ref.make(0);
const parentProjection = {
thread: { id: parentThreadId },
runs: [],
contextTransfers: [
{
id: resultTransferId,
type: "subagent_result",
sourceThreadId: childThreadId,
targetThreadId: parentThreadId,
sourcePoint: { runId: childRunId },
},
],
subagents: [
{
id: taskId,
threadId: parentThreadId,
origin: "app_owned",
childThreadId,
driver: "codex",
model: "gpt-5.6-terra",
result: "terminal result",
completionDelivery: { state: "pending" },
},
],
} as unknown as OrchestrationV2ThreadProjection;
const childProjection = {
thread: { id: childThreadId, title: "Child" },
runs: [
{
id: childRunId,
ordinal: 1,
status: "completed",
startedAt: DateTime.makeUnsafe("2026-10-03T10:00:00Z"),
completedAt: DateTime.makeUnsafe("2026-10-03T10:10:00Z"),
},
{
id: RunId.make("run:mcp-ack-continuation"),
ordinal: 2,
status: "failed",
startedAt: DateTime.makeUnsafe("2026-10-03T10:02:00Z"),
completedAt: DateTime.makeUnsafe("2026-10-03T10:05:00Z"),
},
],
contextTransfers: [],
messages: [
{
id: MessageId.make("message:mcp-ack-result"),
runId: childRunId,
role: "assistant",
text: "terminal result",
createdAt: DateTime.makeUnsafe("2026-10-03T10:10:00Z"),
updatedAt: DateTime.makeUnsafe("2026-10-03T10:10:00Z"),
},
],
turnItems: [],
subagents: [],
providerThreads: [],
runtimeRequests: [],
} as unknown as OrchestrationV2ThreadProjection;
let hasNestedWork = true;
let settleAfterTaskRead = false;
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: (threadId) =>
Effect.sync(() => {
if (threadId !== parentThreadId) {
return hasNestedWork
? {
...childProjection,
subagents: [
{ ...parentProjection.subagents[0]!, status: "running" as const },
],
}
: childProjection;
}
const snapshot = hasNestedWork
? {
...parentProjection,
contextTransfers: [],
subagents: parentProjection.subagents.map((task) => ({
...task,
result: null,
status: "running" as const,
})),
}
: parentProjection;
if (settleAfterTaskRead) {
settleAfterTaskRead = false;
hasNestedWork = false;
}
return snapshot;
}),
delegatedTaskResultPending: () => Effect.succeed(false),
dispatch: (command) =>
Ref.update(acknowledgementCommandIds, (commandIds) => [
...commandIds,
String(command.commandId),
]).pipe(
Effect.andThen(Ref.updateAndGet(acknowledgementAttempts, (count) => count + 1)),
Effect.flatMap((attempt) =>
attempt === 1
? Effect.fail(new Error("simulated acknowledgement failure") as never)
: Effect.succeed({} as never),
),
),
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
const scope: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:mcp-ack"),
requestNamespace: "provider-session:mcp-ack",
thread: {
threadId: parentThreadId,
providerSessionId: "provider-session:mcp-ack",
providerInstanceId: ProviderInstanceId.make("codex"),
},
client: undefined,
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const pending = yield* service.taskStatus(scope, taskId);
assert.equal(pending.status, "running");
assert.equal(pending.workState, "waiting_for_children");
assert.isNull(pending.summary);
assert.isNull(pending.resultContextTransferId);
assert.equal(yield* Ref.get(acknowledgementAttempts), 0);
hasNestedWork = false;
const error = yield* service.taskStatus(scope, taskId).pipe(Effect.flip);
assert.equal(error.code, "orchestration_error");
// Completion lands after task selection, before the remaining parent/child reads.
hasNestedWork = true;
settleAfterTaskRead = true;
const result = yield* service.taskStatus(scope, taskId);
assert.equal(result.status, "completed");
assert.equal(result.summary, "terminal result");
assert.equal(result.latestTerminalRunId, childRunId);
assert.equal(result.latestTerminalStatus, "completed");
assert.equal(result.resultContextTransferId, resultTransferId);
const commandIds = yield* Ref.get(acknowledgementCommandIds);
assert.equal(commandIds.length, 2);
assert.notEqual(commandIds[0], commandIds[1]);
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
}),
);
it.effect("reports a restart-cut child as working until its continuation settles", () =>
Effect.gen(function* () {
const parentThreadId = ThreadId.make("thread:mcp-restart-parent");
const childThreadId = ThreadId.make("thread:mcp-restart-child");
const taskId = NodeId.make("node:mcp-restart-task");
const dispatched = yield* Ref.make(0);
let awaitsRestart = true;
let readFails = true;
const parentProjection = {
thread: { id: parentThreadId },
runs: [],
contextTransfers: [],
subagents: [
{
id: taskId,
threadId: parentThreadId,
origin: "app_owned",
childThreadId,
driver: "codex",
model: "gpt-5.6-terra",
status: "running",
result: null,
completionDelivery: { state: "pending" },
},
],
} as unknown as OrchestrationV2ThreadProjection;
const childProjection = {
thread: { id: childThreadId, title: "Child" },
runs: [
{
id: RunId.make("run:mcp-restart-child"),
ordinal: 1,
status: "cancelled",
delegatedTaskId: taskId,
},
{ id: RunId.make("run:mcp-restart-later"), ordinal: 2, status: "running" },
],
contextTransfers: [],
messages: [],
subagents: [],
providerThreads: [],
runtimeRequests: [],
turnItems: [],
} as unknown as OrchestrationV2ThreadProjection;
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: (threadId) =>
Effect.succeed(threadId === parentThreadId ? parentProjection : childProjection),
delegatedTaskResultPending: () =>
readFails
? Effect.fail(new OrchestratorProjectionError({ threadId: childThreadId }))
: Effect.succeed(awaitsRestart),
dispatch: () => Ref.update(dispatched, (count) => count + 1).pipe(Effect.as({} as never)),
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
const scope: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:mcp-restart"),
requestNamespace: "provider-session:mcp-restart",
thread: {
threadId: parentThreadId,
providerSessionId: "provider-session:mcp-restart",
providerInstanceId: ProviderInstanceId.make("codex"),
},
client: undefined,
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const failed = yield* service.taskStatus(scope, taskId).pipe(Effect.flip);
assert.equal(failed.code, "orchestration_error");
assert.equal(yield* Ref.get(dispatched), 0);
readFails = false;
const held = yield* service.taskStatus(scope, taskId);
assert.equal(held.status, "running");
assert.equal(held.workState, "working");
assert.isNull(held.summary);
assert.equal(yield* Ref.get(dispatched), 0);
awaitsRestart = false;
const settled = yield* service.taskStatus(scope, taskId);
assert.equal(settled.status, "cancelled");
assert.equal(yield* Ref.get(dispatched), 1);
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
}),
);
it.effect("tells the parent to end its turn only while its task still runs", () =>
Effect.gen(function* () {
const parentThreadId = ThreadId.make("thread:mcp-next-parent");
const childThreadId = ThreadId.make("thread:mcp-next-child");
const taskId = NodeId.make("node:mcp-next-task");
let finished = false;
let pendingRequest = false;
const parentProjection = () =>
({
thread: { id: parentThreadId },
runs: [],
contextTransfers: [],
subagents: [
{
id: taskId,
threadId: parentThreadId,
origin: "app_owned",
childThreadId,
driver: "codex",
model: "gpt-5.6-terra",
status: finished ? "completed" : "running",
result: finished ? "done" : null,
completionDelivery: { state: "pending" },
},
],
}) as unknown as OrchestrationV2ThreadProjection;
const childRun = () => ({
id: RunId.make("run:mcp-next-child"),
ordinal: 1,
status: finished ? ("completed" as const) : ("running" as const),
delegatedTaskId: taskId,
});
const childProjection = () =>
({
thread: { id: childThreadId, title: "Child task" },
runs: [childRun()],
contextTransfers: [],
messages: [],
subagents: [],
providerThreads: [],
runtimeRequests: pendingRequest ? [{ status: "pending" }] : [],
nodes: [],
turnItems: [],
}) as unknown as OrchestrationV2ThreadProjection;
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: (threadId) =>
Effect.succeed(threadId === parentThreadId ? parentProjection() : childProjection()),
getThreadShell: (threadId) => Effect.succeed(liveThreadShell(threadId)),
getProjectThreadRecords: () => Effect.succeed(childProjection()),
waitForThread: () =>
Effect.succeed({
threadId: childThreadId,
run: childRun() as unknown as OrchestrationV2ThreadProjection["runs"][number],
timedOut: !finished,
}),
dispatch: () => Effect.succeed({} as never),
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
const scope: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:mcp-next"),
requestNamespace: "provider-session:mcp-next",
thread: {
threadId: parentThreadId,
providerSessionId: "provider-session:mcp-next",
providerInstanceId: ProviderInstanceId.make("codex"),
},
client: undefined,
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const running = yield* service.taskStatus(scope, taskId);
assert.equal(running.status, "running");
assert.equal(running.next, ORCHESTRATOR_MCP_RUNNING_TASK_NEXT);
const waiting = yield* service.waitForThread(scope, { threadId: childThreadId });
assert.isTrue(waiting.timedOut);
assert.equal(waiting.next, ORCHESTRATOR_MCP_RUNNING_TASK_NEXT);
// A child waiting on a question or approval needs an answer, not a wake.
pendingRequest = true;
const asking = yield* service.waitForThread(scope, { threadId: childThreadId });
assert.isTrue(asking.timedOut);
assert.notProperty(asking, "next");
pendingRequest = false;
finished = true;
const completed = yield* service.taskStatus(scope, taskId);
assert.equal(completed.status, "completed");
assert.notProperty(completed, "next");
const waited = yield* service.waitForThread(scope, { threadId: childThreadId });
assert.equal(waited.status, "completed");
assert.notProperty(waited, "next");
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
}),
);
it.effect("does not dispose delivery when a nonterminal task has no active child run", () =>
Effect.gen(function* () {
const parentThreadId = ThreadId.make("thread:mcp-cancel-parent");
const childThreadId = ThreadId.make("thread:mcp-cancel-child");
const taskId = NodeId.make("node:mcp-cancel-task");
const dispatched = yield* Ref.make<ReadonlyArray<unknown>>([]);
const parentProjection = {
thread: { id: parentThreadId },
runs: [],
contextTransfers: [],
subagents: [
{
id: taskId,
threadId: parentThreadId,
origin: "app_owned",
childThreadId,
driver: "codex",
model: "gpt-5.6-terra",
result: null,
completionDelivery: { state: "pending" },
},
],
} as unknown as OrchestrationV2ThreadProjection;
const childProjection = {
thread: { id: childThreadId, title: "Child" },
runs: [],
contextTransfers: [],
messages: [],
subagents: [],
providerThreads: [],
runtimeRequests: [],
} as unknown as OrchestrationV2ThreadProjection;
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: (threadId) =>
Effect.succeed(threadId === parentThreadId ? parentProjection : childProjection),
getThreadShell: (threadId) => Effect.succeed(liveThreadShell(threadId)),
listAppOwnedChildThreadIds: () => Effect.succeed([]),
dispatch: (command) =>
Ref.update(dispatched, (commands) => [...commands, command]).pipe(
Effect.as({} as never),
),
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
const scope: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:mcp-cancel"),
requestNamespace: "provider-session:mcp-cancel",
thread: {
threadId: parentThreadId,
providerSessionId: "provider-session:mcp-cancel",
providerInstanceId: ProviderInstanceId.make("codex"),
},
client: undefined,
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const error = yield* service
.cancelTask(scope, { taskId, clientRequestId: "cancel-unstarted-task" })
.pipe(Effect.flip);
assert.equal(error.code, "task_not_cancellable");
assert.deepEqual(yield* Ref.get(dispatched), []);
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
}),
);
it.effect.each(["no runs", "a finished run"] as const)(
"cancels an orphaned follow-up through its parent when the child has %s",
(childState) =>
Effect.gen(function* () {
const parentThreadId = ThreadId.make("thread:mcp-orphan-parent");
const childThreadId = ThreadId.make("thread:mcp-orphan-child");
const taskId = NodeId.make("node:mcp-orphan-task");
const parentRunId = RunId.make("run:mcp-orphan-parent");
const dispatched = yield* Ref.make<ReadonlyArray<OrchestrationV2ServerCommand>>([]);
const status = yield* Ref.make("running");
const parentProjection = (taskStatus: string) =>
({
thread: { id: parentThreadId },
runs: [],
contextTransfers: [],
subagents: [
{
id: taskId,
threadId: parentThreadId,
runId: parentRunId,
origin: "app_owned",
childThreadId,
driver: "codex",
model: "gpt-5.6-terra",
status: taskStatus,
result: null,
completionDelivery: { state: "pending" },
},
],
}) as unknown as OrchestrationV2ThreadProjection;
// A finished run whose binding to the follow-up was lost.
const childProjection = {
thread: { id: childThreadId, title: "Child" },
runs:
childState === "no runs"
? []
: [{ id: RunId.make("run:mcp-orphan-child"), ordinal: 1, status: "completed" }],
contextTransfers: [],
messages: [],
subagents: [],
providerThreads: [],
runtimeRequests: [],
turnItems: [],
} as unknown as OrchestrationV2ThreadProjection;
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: (threadId) =>
threadId === parentThreadId
? Effect.map(Ref.get(status), parentProjection)
: Effect.succeed(childProjection),
getThreadShell: (threadId) => Effect.succeed(liveThreadShell(threadId)),
listAppOwnedChildThreadIds: () => Effect.succeed([]),
delegatedTaskResultPending: () => Effect.succeed(false),
stopDelegatedTasks: () => Effect.void,
// The orchestrator's subagent.stop repair is covered in ThreadStop.test.ts.
dispatch: (command) =>
Ref.update(dispatched, (commands) => [...commands, command]).pipe(
Effect.andThen(
command.type === "subagent.stop" ? Ref.set(status, "cancelled") : Effect.void,
),
Effect.as({} as never),
),
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
const scope: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:mcp-orphan"),
requestNamespace: "provider-session:mcp-orphan",
thread: {
threadId: parentThreadId,
providerSessionId: "provider-session:mcp-orphan",
providerInstanceId: ProviderInstanceId.make("codex"),
},
client: undefined,
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const result = yield* service.cancelTask(scope, {
taskId,
clientRequestId: "cancel-orphan-task",
});
assert.deepEqual(result, { taskId, status: "cancelled" });
const commands = yield* Ref.get(dispatched);
// A child whose run finished can still run another turn's work, so it is stopped too.
assert.deepEqual(
commands.flatMap((command) =>
command.type === "thread.stop" ? [command.threadId] : [],
),
childState === "a finished run" ? [childThreadId] : [],
);
const stop = commands.find((command) => command.type === "subagent.stop");
if (stop?.type !== "subagent.stop") return;
assert.deepEqual(
{ threadId: stop.threadId, runId: stop.runId, subagentId: stop.subagentId },
{ threadId: parentThreadId, runId: parentRunId, subagentId: taskId },
);
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
}),
);
it.effect("does not dispose delivery when the child stop fails", () =>
Effect.gen(function* () {
const parentThreadId = ThreadId.make("thread:mcp-cancel-failed-parent");
const childThreadId = ThreadId.make("thread:mcp-cancel-failed-child");
const childRunId = RunId.make("run:mcp-cancel-failed-child");
const taskId = NodeId.make("node:mcp-cancel-failed-task");
const dispatched = yield* Ref.make<ReadonlyArray<unknown>>([]);
const parentProjection = {
thread: { id: parentThreadId },
runs: [],
contextTransfers: [],
subagents: [
{
id: taskId,
threadId: parentThreadId,
origin: "app_owned",
childThreadId,
driver: "codex",
model: "gpt-5.6-terra",
result: null,
completionDelivery: { state: "pending" },
},
],
} as unknown as OrchestrationV2ThreadProjection;
const childProjection = {
thread: { id: childThreadId, title: "Child" },
runs: [{ id: childRunId, status: "running" }],
contextTransfers: [],
messages: [],
subagents: [],
providerThreads: [],
runtimeRequests: [],
} as unknown as OrchestrationV2ThreadProjection;
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: (threadId) =>
Effect.succeed(threadId === parentThreadId ? parentProjection : childProjection),
getThreadShell: (threadId) => Effect.succeed(liveThreadShell(threadId)),
listAppOwnedChildThreadIds: () => Effect.succeed([]),
dispatch: (command) =>
Ref.update(dispatched, (commands) => [...commands, command]).pipe(
Effect.andThen(Effect.fail(new Error("simulated stop failure") as never)),
),
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
const scope: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:mcp-cancel-failed"),
requestNamespace: "provider-session:mcp-cancel-failed",
thread: {
threadId: parentThreadId,
providerSessionId: "provider-session:mcp-cancel-failed",
providerInstanceId: ProviderInstanceId.make("codex"),
},
client: undefined,
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const error = yield* service
.cancelTask(scope, { taskId, clientRequestId: "cancel-failed-task" })
.pipe(Effect.flip);
assert.equal(error.code, "task_not_cancellable");
assert.deepEqual(
(yield* Ref.get(dispatched)).map((command) => (command as { type: string }).type),
["thread.stop"],
);
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
}),
);
it.effect("returns cancel requested when post-stop disposal fails", () =>
Effect.gen(function* () {
const parentThreadId = ThreadId.make("thread:mcp-cancel-dispose-failed-parent");
const childThreadId = ThreadId.make("thread:mcp-cancel-dispose-failed-child");
const childRunId = RunId.make("run:mcp-cancel-dispose-failed-child");
const taskId = NodeId.make("node:mcp-cancel-dispose-failed-task");
const dispatched = yield* Ref.make<ReadonlyArray<unknown>>([]);
const parentProjection = {
thread: { id: parentThreadId },
runs: [],
contextTransfers: [],
subagents: [
{
id: taskId,
threadId: parentThreadId,
origin: "app_owned",
childThreadId,
driver: "codex",
model: "gpt-5.6-terra",
result: null,
completionDelivery: { state: "pending" },
},
],
} as unknown as OrchestrationV2ThreadProjection;
const childProjection = {
thread: { id: childThreadId, title: "Child" },
runs: [{ id: childRunId, status: "running" }],
contextTransfers: [],
messages: [],
subagents: [],
providerThreads: [],
runtimeRequests: [],
} as unknown as OrchestrationV2ThreadProjection;
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: (threadId) =>
Effect.succeed(threadId === parentThreadId ? parentProjection : childProjection),
getThreadShell: (threadId) => Effect.succeed(liveThreadShell(threadId)),
listAppOwnedChildThreadIds: () => Effect.succeed([]),
dispatch: (command) =>
Ref.update(dispatched, (commands) => [...commands, command]).pipe(
Effect.andThen(
command.type === "delegated_task.completion-delivery.dispose"
? Effect.fail(new Error("simulated disposal failure") as never)
: Effect.succeed({} as never),
),
),
stopDelegatedTasks: () => Effect.void,
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
const scope: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:mcp-cancel-dispose-failed"),
requestNamespace: "provider-session:mcp-cancel-dispose-failed",
thread: {
threadId: parentThreadId,
providerSessionId: "provider-session:mcp-cancel-dispose-failed",
providerInstanceId: ProviderInstanceId.make("codex"),
},
client: undefined,
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const result = yield* service.cancelTask(scope, {
taskId,
clientRequestId: "cancel-dispose-failed-task",
});
assert.equal(result.status, "cancel_requested");
assert.deepEqual(
(yield* Ref.get(dispatched)).map((command) => (command as { type: string }).type),
["thread.stop", "delegated_task.completion-delivery.dispose"],
);
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
}),
);
it.effect("refuses to cancel a task whose child now runs above the parent's modes", () =>
Effect.gen(function* () {
const parentThreadId = ThreadId.make("thread:mcp-cancel-dispose-failed-parent");
const childThreadId = ThreadId.make("thread:mcp-cancel-dispose-failed-child");
const childRunId = RunId.make("run:mcp-cancel-dispose-failed-child");
const taskId = NodeId.make("node:mcp-cancel-dispose-failed-task");
const dispatched = yield* Ref.make<ReadonlyArray<unknown>>([]);
const parentProjection = {
thread: { id: parentThreadId, runtimeMode: "approval-required", interactionMode: "plan" },
runs: [],
contextTransfers: [],
subagents: [
{
id: taskId,
threadId: parentThreadId,
origin: "app_owned",
childThreadId,
driver: "codex",
model: "gpt-5.6-terra",
result: null,
completionDelivery: { state: "pending" },
},
],
} as unknown as OrchestrationV2ThreadProjection;
const childProjection = {
thread: { id: childThreadId, title: "Child" },
runs: [{ id: childRunId, status: "running" }],
contextTransfers: [],
messages: [],
subagents: [],
providerThreads: [],
runtimeRequests: [],
} as unknown as OrchestrationV2ThreadProjection;
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: (threadId) =>
Effect.succeed(threadId === parentThreadId ? parentProjection : childProjection),
getThreadShell: (threadId) => Effect.succeed(liveThreadShell(threadId)),
listAppOwnedChildThreadIds: () => Effect.succeed([]),
dispatch: (command) =>
Ref.update(dispatched, (commands) => [...commands, command]).pipe(
Effect.andThen(
command.type === "delegated_task.completion-delivery.dispose"
? Effect.fail(new Error("simulated disposal failure") as never)
: Effect.succeed({} as never),
),
),
stopDelegatedTasks: () => Effect.void,
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
const scope: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:mcp-cancel-dispose-failed"),
requestNamespace: "provider-session:mcp-cancel-dispose-failed",
thread: {
threadId: parentThreadId,
providerSessionId: "provider-session:mcp-cancel-dispose-failed",
providerInstanceId: ProviderInstanceId.make("codex"),
},
client: undefined,
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const error = yield* service
.cancelTask(scope, { taskId, clientRequestId: "cancel-above-modes" })
.pipe(Effect.flip);
assert.equal(error.code, "runtime_mode_escalation_denied");
assert.deepEqual(yield* Ref.get(dispatched), []);
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
}),
);
const cancelOverRaisedGrandchild = (child: {
readonly deleted: boolean;
readonly raisedDuringStop?: boolean;
}) =>
Effect.gen(function* () {
const parentThreadId = ThreadId.make("thread:mcp-cancel-grandchild-parent");
const childThreadId = ThreadId.make("thread:mcp-cancel-grandchild-child");
const grandchildThreadId = ThreadId.make("thread:mcp-cancel-grandchild-grandchild");
const taskId = NodeId.make("node:mcp-cancel-grandchild-task");
const dispatched = yield* Ref.make<ReadonlyArray<unknown>>([]);
const stoppedBelow = yield* Ref.make(false);
const subagentReads = yield* Ref.make<ReadonlyArray<ProjectionRecordFilter | undefined>>([]);
const appOwnedTask = (
id: string,
threadId: ThreadId,
childId: ThreadId,
settled?: "settled",
) => ({
id: NodeId.make(id),
threadId,
origin: "app_owned",
childThreadId: childId,
driver: "codex",
model: "gpt-5.6-terra",
status: settled === undefined ? "running" : "completed",
result: settled === undefined ? null : "Done.",
completionDelivery: { state: settled === undefined ? "pending" : "delivered" },
});
// Older tasks the parent and child dispatched and that have long settled.
const settledThreadId = ThreadId.make("thread:mcp-cancel-grandchild-settled");
const projections = new Map([
[
parentThreadId,
{
thread: {
id: parentThreadId,
runtimeMode: "approval-required",
interactionMode: "default",
},
runs: [],
contextTransfers: [],
subagents: [
appOwnedTask(
"node:mcp-cancel-grandchild-old",
parentThreadId,
settledThreadId,
"settled",
),
appOwnedTask(taskId, parentThreadId, childThreadId),
],
},
],
[
childThreadId,
{
thread: { id: childThreadId, title: "Child" },
runs: [{ id: RunId.make("run:mcp-cancel-grandchild-child"), status: "running" }],
contextTransfers: [],
messages: [],
subagents: [
appOwnedTask(
"node:mcp-cancel-grandchild-done",
childThreadId,
settledThreadId,
"settled",
),
appOwnedTask("node:mcp-cancel-grandchild-below", childThreadId, grandchildThreadId),
],
providerThreads: [],
runtimeRequests: [],
},
],
[
settledThreadId,
{
thread: { id: settledThreadId },
runs: [],
contextTransfers: [],
messages: [],
subagents: [],
providerThreads: [],
runtimeRequests: [],
},
],
[
grandchildThreadId,
{
thread: { id: grandchildThreadId },
runs: [],
contextTransfers: [],
messages: [],
subagents: [],
providerThreads: [],
runtimeRequests: [],
},
],
]) as unknown as ReadonlyMap<ThreadId, OrchestrationV2ThreadProjection>;
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: (threadId, fields, filter) =>
((fields as ReadonlyArray<string>).includes("subagents")
? Ref.update(subagentReads, (reads) => [...reads, filter])
: Effect.void
).pipe(Effect.as(projections.get(threadId)!)),
listAppOwnedChildThreadIds: (threadId) =>
Effect.succeed(
projections
.get(threadId)!
.subagents.flatMap((task) =>
task.origin === "app_owned" && task.childThreadId !== null
? [task.childThreadId]
: [],
),
),
getThreadShell: (threadId) =>
Effect.succeed(
threadId === grandchildThreadId && child.raisedDuringStop !== true
? liveThreadShell(threadId)
: threadId === childThreadId && child.deleted
? null
: liveThreadShell(threadId, { runtimeMode: "approval-required" }),
),
dispatch: (command) =>
Ref.update(dispatched, (commands) => [...commands, command]).pipe(
Effect.as({} as never),
),
stopDelegatedTasks: () =>
Effect.gen(function* () {
const limit = yield* DispatchModeLimit;
if (child.raisedDuringStop === true && limit?.refused !== undefined) {
const refusal: DispatchModeRefusal = {
threadId: grandchildThreadId,
mode: "runtime",
runtimeMode: "full-access",
interactionMode: "default",
};
yield* Ref.set(limit.refused, refusal);
return yield* new OrchestratorThreadAboveModeLimitError({
commandId: CommandId.make("stop-grandchild"),
threadId: grandchildThreadId,
mode: "runtime",
runtimeMode: "full-access",
interactionMode: "default",
});
}
yield* Ref.set(stoppedBelow, true);
}),
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
const scope: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:mcp-cancel-grandchild"),
requestNamespace: "provider-session:mcp-cancel-grandchild",
thread: {
threadId: parentThreadId,
providerSessionId: "provider-session:mcp-cancel-grandchild",
providerInstanceId: ProviderInstanceId.make("codex"),
},
client: undefined,
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
return yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const error = yield* service
.cancelTask(scope, { taskId, clientRequestId: "cancel-grandchild-above-modes" })
.pipe(Effect.flip);
// No read decodes every task a thread has dispatched.
for (const filter of yield* Ref.get(subagentReads)) {
assert.isTrue(
filter?.subagentIds !== undefined || filter?.omitSettledSubagents !== undefined,
);
}
return {
code: error.code,
dispatched: yield* Ref.get(dispatched),
stoppedBelow: yield* Ref.get(stoppedBelow),
};
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
});
it.effect("refuses to cancel a task when a task under it now runs above the parent's modes", () =>
Effect.gen(function* () {
assert.deepEqual(yield* cancelOverRaisedGrandchild({ deleted: false }), {
code: "runtime_mode_escalation_denied",
dispatched: [],
stoppedBelow: false,
});
}),
);
it.effect("reports a task under the child that its user raises while it is being stopped", () =>
Effect.gen(function* () {
const outcome = yield* cancelOverRaisedGrandchild({ deleted: false, raisedDuringStop: true });
assert.equal(outcome.code, "runtime_mode_escalation_denied");
assert.isFalse(outcome.stoppedBelow);
}),
);
it.effect("checks the tasks under a deleted child before cancelling it", () =>
Effect.gen(function* () {
assert.deepEqual(yield* cancelOverRaisedGrandchild({ deleted: true }), {
code: "runtime_mode_escalation_denied",
dispatched: [],
stoppedBelow: false,
});
}),
);
});
describe("OrchestratorMcpService provider resolution", () => {
const parentThreadId = ThreadId.make("thread:mcp-providers-parent");
const childThreadId = ThreadId.make("thread:mcp-providers-child");
const parentRunId = RunId.make("run:mcp-providers-parent");
const parentNodeId = NodeId.make("node:mcp-providers-root");
const taskId = NodeId.make("node:mcp-providers-task");
const projectId = ProjectId.make("project:mcp-providers");
const codexInstanceId = ProviderInstanceId.make("codex");
const antigravityInstanceId = ProviderInstanceId.make("antigravity");
const scope: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:mcp-providers"),
requestNamespace: "provider-session:mcp-providers",
thread: {
threadId: parentThreadId,
providerSessionId: "provider-session:mcp-providers",
providerInstanceId: codexInstanceId,
},
client: undefined,
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
const providerSnapshot = (input: {
readonly instanceId: ProviderInstanceId;
readonly driver: ProviderDriverKind;
readonly model?: string;
readonly enabled?: boolean;
}): ServerProvider => ({
instanceId: input.instanceId,
driver: input.driver,
enabled: input.enabled ?? true,
installed: input.enabled !== false,
version: input.enabled === false ? null : "test",
status: input.enabled === false ? "disabled" : "ready",
auth: { status: input.enabled === false ? "unknown" : "authenticated" },
...(input.enabled === false ? { message: "Provider is disabled in T3 Code settings." } : {}),
checkedAt: "2026-09-13T00:00:00.000Z",
models:
input.model === undefined
? []
: [{ slug: input.model, name: input.model, isCustom: false, capabilities: null }],
slashCommands: [],
skills: [],
});
const providerRegistryLayer = (providers: ReadonlyArray<ServerProvider>) =>
Layer.mock(ProviderRegistry.ProviderRegistry)({
getProviders: Effect.succeed(providers),
refreshInstance: () => Effect.succeed(providers),
});
const adapterRegistryLayer = (instanceIds: ReadonlyArray<ProviderInstanceId>) =>
Layer.succeed(
ProviderAdapterRegistry.ProviderAdapterRegistryV2,
ProviderAdapterRegistry.ProviderAdapterRegistryV2.of({
list: () => Effect.succeed(instanceIds),
get: (instanceId) =>
instanceIds.includes(instanceId)
? Effect.succeed({
instanceId,
} as unknown as ProviderAdapter.ProviderAdapterV2["Service"])
: Effect.fail(
new ProviderAdapterRegistry.ProviderAdapterRegistryLookupError({ instanceId }),
),
}),
);
const parentProjection = (
subagents: ReadonlyArray<unknown>,
modelSelection: {
readonly instanceId: ProviderInstanceId;
readonly model: string;
readonly options?: ReadonlyArray<{ readonly id: string; readonly value: unknown }>;
} = { instanceId: codexInstanceId, model: "gpt-5.4" },
): OrchestrationV2ThreadProjection =>
({
thread: {
id: parentThreadId,
projectId,
title: "MCP parent",
createdBy: "user",
creationSource: "web",
modelSelection,
runtimeMode: "full-access",
interactionMode: "default",
},
runs: [
{
id: parentRunId,
ordinal: 1,
status: "running",
rootNodeId: parentNodeId,
providerInstanceId: codexInstanceId,
modelSelection,
},
],
contextTransfers: [],
subagents,
}) as unknown as OrchestrationV2ThreadProjection;
const childProjection = {
thread: { id: childThreadId, title: "Child" },
runs: [],
contextTransfers: [],
messages: [],
subagents: [],
providerThreads: [],
runtimeRequests: [],
turnItems: [],
} as unknown as OrchestrationV2ThreadProjection;
it.effect.each([
"parent completion",
"nested child completion",
"child run completion",
"child question",
"child approval",
] as const)("a task wait still returns on %s", (wake) =>
Effect.gen(function* () {
const events = yield* Queue.unbounded<OrchestrationV2StoredEvent>();
const subscribed = yield* Deferred.make<void>();
const nestedId = NodeId.make("node:mcp-wait-nested");
const childRunId = RunId.make("run:mcp-wait-child");
const childRootId = NodeId.make("node:mcp-wait-child-root");
const eventThreadId = wake === "parent completion" ? parentThreadId : childThreadId;
const eventType =
wake === "child run completion"
? "run.updated"
: wake === "child question" || wake === "child approval"
? "runtime-request.updated"
: "subagent.updated";
const terminal = wake.endsWith("completion");
let ready = false;
const task = () => ({
id: taskId,
threadId: parentThreadId,
runId: parentRunId,
parentNodeId,
origin: "app_owned",
providerInstanceId: codexInstanceId,
driver: "codex",
childThreadId,
model: "gpt-5.4",
status: ready && terminal ? "completed" : "running",
result: ready && wake === "parent completion" ? "done" : null,
});
const child = () =>
({
...childProjection,
runs: [
{
id: childRunId,
ordinal: 1,
status:
wake === "nested child completion" || (ready && terminal) ? "completed" : "running",
startedAt: DateTime.makeUnsafe(0),
completedAt: ready && terminal ? DateTime.makeUnsafe(1) : null,
},
],
subagents:
wake === "nested child completion"
? [{ id: nestedId, status: ready ? "completed" : "running" }]
: [],
nodes: [{ id: childRootId, runId: childRunId }],
runtimeRequests:
ready && !terminal
? [
{
id: "request:mcp-wait-answer",
nodeId: childRootId,
kind: wake === "child question" ? "user_input" : "command",
status: "pending",
responseCapability: { type: "live" },
createdAt: DateTime.makeUnsafe(0),
},
]
: [],
}) as unknown as OrchestrationV2ThreadProjection;
const dependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
hasReceipt: () => Effect.succeed(false),
assertProviderInstanceEnabled: () => Effect.void,
isProviderInstanceEnabledForProject: () => Effect.succeed(true),
getThreadRecords: (threadId) =>
Effect.sync(() => (threadId === parentThreadId ? parentProjection([task()]) : child())),
getThreadEventSequence: () => Effect.succeed(0),
delegatedTaskResultPending: () => Effect.succeed(false),
streamStoredEventsFrom: (input) =>
input?.threadId === eventThreadId && input.eventType === eventType
? Stream.fromEffect(Deferred.succeed(subscribed, undefined)).pipe(
Stream.drain,
Stream.concat(Stream.fromQueue(events)),
)
: Stream.never,
dispatch: () =>
Effect.succeed({
sequence: 1,
storedEvents: [{ event: { type: "subagent.updated", payload: task() } }],
} as never),
}),
ServerSettings.layerTest(),
providerRegistryLayer([
providerSnapshot({
instanceId: codexInstanceId,
driver: ProviderDriverKind.make("codex"),
model: "gpt-5.4",
}),
]),
adapterRegistryLayer([codexInstanceId]),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const waiting = yield* service
.delegateTask(scope, { task: "Review the change.", mode: "wait" })
.pipe(Effect.forkChild);
yield* Deferred.await(subscribed);
ready = true;
if (wake === "parent completion") {
yield* Queue.offer(events, {
sequence: 2,
event: {
type: "subagent.updated",
threadId: parentThreadId,
payload: { ...task(), id: nestedId },
},
} as unknown as OrchestrationV2StoredEvent);
}
yield* Queue.offer(events, {
sequence: 3,
event: {
type: eventType,
threadId: eventThreadId,
payload: { id: wake === "parent completion" ? taskId : nestedId },
},
} as unknown as OrchestrationV2StoredEvent);
const result = yield* Fiber.join(waiting);
assert.isFalse(result.waitTimedOut);
if (terminal) {
assert.equal(result.status, "completed");
if (wake === "parent completion") assert.equal(result.summary, "done");
} else {
assert.equal(result.status, "running");
if (wake === "child question") assert.isTrue(result.hasPendingQuestion);
else {
assert.deepEqual(result.pendingApproval, {
requestId: "request:mcp-wait-answer",
kind: "command",
runId: childRunId,
});
}
}
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(dependencies))));
}),
);
it.effect(
"advertises orchestration capability from registered adapters rather than a driver allowlist",
() =>
Effect.gen(function* () {
const disabledAntigravityInstanceId = ProviderInstanceId.make("antigravity-alt");
const disabledWithoutAdapterInstanceId = ProviderInstanceId.make("codex-without-adapter");
const projectDisabledInstanceId = ProviderInstanceId.make("codex-project-off");
const forkOnlyInstanceId = ProviderInstanceId.make("forkOnly");
const forkShadow = yield* buildUnavailableProviderSnapshot({
driverKind: "forkOnly",
instanceId: forkOnlyInstanceId,
reason: "Driver 'forkOnly' is not registered in this build.",
checkedAt: "2026-09-13T00:00:00.000Z",
});
let providers: ReadonlyArray<ServerProvider> = [
providerSnapshot({
instanceId: codexInstanceId,
driver: ProviderDriverKind.make("codex"),
model: "gpt-5.4",
}),
providerSnapshot({
instanceId: ProviderInstanceId.make("claudeAgent"),
driver: ProviderDriverKind.make("claudeAgent"),
model: "claude-sonnet-4-6",
}),
providerSnapshot({
instanceId: ProviderInstanceId.make("pi"),
driver: ProviderDriverKind.make("pi"),
model: "pi-model",
}),
providerSnapshot({
instanceId: ProviderInstanceId.make("acpRegistry"),
driver: ProviderDriverKind.make("acpRegistry"),
model: "acp-model",
}),
providerSnapshot({
instanceId: antigravityInstanceId,
driver: ProviderDriverKind.make("antigravity"),
model: "ant-model",
}),
providerSnapshot({
instanceId: disabledAntigravityInstanceId,
driver: ProviderDriverKind.make("antigravity"),
model: "ant-model",
enabled: false,
}),
providerSnapshot({
instanceId: disabledWithoutAdapterInstanceId,
driver: ProviderDriverKind.make("codex"),
model: "gpt-5.4",
enabled: false,
}),
providerSnapshot({
instanceId: projectDisabledInstanceId,
driver: ProviderDriverKind.make("codex"),
model: "gpt-5.4",
}),
forkShadow,
];
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: () => Effect.succeed(parentProjection([])),
}),
ServerSettings.layerTest({
providerInstances: {
[ProviderInstanceId.make("pi")]: {
driver: ProviderDriverKind.make("pi"),
enabled: true,
},
[ProviderInstanceId.make("acpRegistry")]: {
driver: ProviderDriverKind.make("acpRegistry"),
enabled: true,
},
[antigravityInstanceId]: {
driver: ProviderDriverKind.make("antigravity"),
enabled: true,
},
[projectDisabledInstanceId]: { driver: ProviderDriverKind.make("codex") },
},
projectSettingsOverrides: {
[projectId]: {
providerInstances: { [projectDisabledInstanceId]: { enabled: false } },
},
},
}),
Layer.mock(ProviderRegistry.ProviderRegistry)({
getProviders: Effect.sync(() => providers),
}),
adapterRegistryLayer([
codexInstanceId,
projectDisabledInstanceId,
ProviderInstanceId.make("claudeAgent"),
ProviderInstanceId.make("pi"),
ProviderInstanceId.make("acpRegistry"),
antigravityInstanceId,
disabledAntigravityInstanceId,
]),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const capabilities = yield* service.capabilities(scope);
const byId = new Map(
capabilities.providers.map((provider) => [provider.providerInstanceId, provider]),
);
for (const provider of providers) {
assert.deepEqual(
byId.get(provider.instanceId)?.models.map((model) => model.id),
provider.models.map((model) => model.slug),
);
}
providers = providers.map((provider) => ({
...provider,
models: [
...provider.models,
{
slug: `${provider.driver}/custom-model-after-refresh`,
name: "Custom model",
isCustom: true,
capabilities: null,
},
],
}));
const refreshed = yield* service.capabilities(scope);
for (const provider of providers) {
assert.deepEqual(
refreshed.providers
.find((entry) => entry.providerInstanceId === provider.instanceId)
?.models.map((model) => model.id),
provider.models.map((model) => model.slug),
);
}
for (const instanceId of [
codexInstanceId,
ProviderInstanceId.make("claudeAgent"),
ProviderInstanceId.make("pi"),
ProviderInstanceId.make("acpRegistry"),
antigravityInstanceId,
]) {
const entry = byId.get(instanceId);
assert.isDefined(entry);
assert.isTrue(
entry!.canRunChildTask,
`expected ${instanceId} to advertise canRunChildTask`,
);
assert.isTrue(entry!.canRunCrossProviderChildTask);
assert.deepEqual(entry!.constraints, []);
}
const disabled = byId.get(disabledAntigravityInstanceId);
assert.isDefined(disabled);
assert.isFalse(disabled!.canRunChildTask);
assert.isFalse(disabled!.canRunCrossProviderChildTask);
assert.deepEqual(disabled!.constraints, ["Provider instance is disabled."]);
const projectDisabled = byId.get(projectDisabledInstanceId);
assert.isDefined(projectDisabled);
assert.isFalse(projectDisabled!.canRunChildTask);
assert.deepEqual(projectDisabled!.constraints, ["Provider instance is disabled."]);
const disabledWithoutAdapter = byId.get(disabledWithoutAdapterInstanceId);
assert.isDefined(disabledWithoutAdapter);
assert.isFalse(disabledWithoutAdapter!.canRunChildTask);
assert.isFalse(disabledWithoutAdapter!.canRunCrossProviderChildTask);
assert.deepEqual(disabledWithoutAdapter!.constraints, [
"No V2 provider adapter is registered.",
"Provider instance is disabled.",
]);
const fork = byId.get(forkOnlyInstanceId);
assert.isDefined(fork);
assert.isFalse(fork!.canRunChildTask);
assert.isFalse(fork!.canRunCrossProviderChildTask);
assert.deepEqual(fork!.constraints, [
"No V2 provider adapter is registered.",
"Driver 'forkOnly' is not registered in this build.",
"Provider instance is disabled.",
]);
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
}),
);
describe("listed models", () => {
const opencodeInstanceId = ProviderInstanceId.make("opencode");
const model = (slug: string, extra: Partial<ServerProvider["models"][number]> = {}) => ({
slug,
name: slug,
isCustom: false,
capabilities: null,
...extra,
});
const opencodeSlugs = Array.from(
{ length: 12 },
(_, index) => `oc/m${String(index + 1).padStart(2, "0")}`,
);
const catalog: ReadonlyArray<ServerProvider> = [
{
...providerSnapshot({
instanceId: codexInstanceId,
driver: ProviderDriverKind.make("codex"),
}),
displayName: "Codex",
models: [
model("gpt-6", {
name: "Sol",
capabilities: {
optionDescriptors: [
{
id: "effort",
label: "Reasoning",
description: "How hard the model thinks.",
type: "select",
options: [
{ id: "low", label: "Low", description: "Fast." },
{ id: "high", label: "High", isDefault: true },
],
promptInjectedValues: ["high"],
},
{ id: "fastMode", label: "Fast", type: "boolean" },
{
id: "agent",
label: "Agent",
type: "select",
options: [{ id: "build", label: "Build" }],
currentValue: "build",
},
],
},
}),
model("gpt-5", { name: "Code Legacy", isLegacy: true }),
model("gpt-4", { isLegacy: true }),
model("gpt-3", { name: "GPT-3", isLegacy: true }),
model("my-alpha", { isCustom: true }),
],
},
{
...providerSnapshot({
instanceId: opencodeInstanceId,
driver: ProviderDriverKind.make("opencode"),
}),
models: [
...opencodeSlugs.map((slug) => model(slug, { isLegacy: slug === "oc/m03" })),
model("oc-custom", { isCustom: true }),
],
},
];
const capabilitiesWith = (search?: string) =>
Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
return yield* service.capabilities(scope, search === undefined ? {} : { search });
}).pipe(
Effect.provide(
layerOrchestratorService.pipe(
Layer.provide(
Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: () =>
Effect.succeed(
parentProjection([], { instanceId: codexInstanceId, model: "gpt-3" }),
),
}),
ServerSettings.layerTest({
favorites: [
{ provider: codexInstanceId, model: "gpt-4" },
{ provider: opencodeInstanceId, model: "oc/m10" },
],
providerModelPreferences: {
[opencodeInstanceId]: { hiddenModels: ["oc/m02"], modelOrder: ["oc/m12"] },
},
}),
providerRegistryLayer(catalog),
adapterRegistryLayer([codexInstanceId, opencodeInstanceId]),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
),
),
),
),
);
const listing = (capabilities: OrchestratorMcpCapabilitiesResult) =>
capabilities.providers.map((provider) => ({
id: provider.providerInstanceId,
models: provider.models.map((entry) => entry.id),
omitted: provider.omittedModels ?? 0,
}));
it.effect(
"skips legacy models, lists the first 8 of large catalogs, and keeps pinned models",
() =>
Effect.gen(function* () {
assert.deepEqual(listing(yield* capabilitiesWith()), [
// gpt-4 is a favorite and gpt-3 is the caller's model; legacy gpt-5 is left out.
{ id: codexInstanceId, models: ["gpt-6", "gpt-4", "gpt-3", "my-alpha"], omitted: 1 },
{
id: opencodeInstanceId,
models: [
"oc/m12",
"oc/m01",
"oc/m04",
"oc/m05",
"oc/m06",
"oc/m07",
"oc/m08",
"oc/m09",
"oc/m10",
"oc-custom",
],
omitted: 2,
},
]);
}),
);
it.effect("search matches every word and caps each provider's matches", () =>
Effect.gen(function* () {
assert.deepEqual(listing(yield* capabilitiesWith("GPT 5")), [
{ id: codexInstanceId, models: ["gpt-5"], omitted: 0 },
{ id: opencodeInstanceId, models: [], omitted: 0 },
]);
const opencode = listing(yield* capabilitiesWith("oc/m"))[1];
assert.deepEqual(opencode, {
id: opencodeInstanceId,
models: ["oc/m12", "oc/m01", "oc/m03", "oc/m04", "oc/m05", "oc/m06", "oc/m07", "oc/m08"],
omitted: 3,
});
// A word naming the provider matches all its models, so legacy ones stay out.
assert.deepEqual(listing(yield* capabilitiesWith("Codex")), [
{ id: codexInstanceId, models: ["gpt-6", "gpt-4", "gpt-3", "my-alpha"], omitted: 1 },
{ id: opencodeInstanceId, models: [], omitted: 0 },
]);
assert.deepEqual(listing(yield* capabilitiesWith(" ")), listing(yield* capabilitiesWith()));
for (const search of ["code", "codex code", " CODE "]) {
assert.deepEqual(listing(yield* capabilitiesWith(search))[0], {
id: codexInstanceId,
models: ["gpt-5"],
omitted: 0,
});
}
assert.deepEqual(
listing(yield* capabilitiesWith("open"))[1],
listing(yield* capabilitiesWith())[1],
);
assert.deepEqual(listing(yield* capabilitiesWith("codex gpt 5"))[0], {
id: codexInstanceId,
models: ["gpt-5"],
omitted: 0,
});
}),
);
it.effect("describes models by id, distinct label, and option values", () =>
Effect.gen(function* () {
const codex = (yield* capabilitiesWith()).providers[0];
assert.deepEqual(codex?.models.slice(0, 4), [
{
id: "gpt-6",
label: "Sol",
options: [
{ id: "effort", values: ["low", "high"], default: "high" },
{ id: "fastMode", values: [false, true] },
{ id: "agent", values: ["build"], default: "build" },
],
},
{ id: "gpt-4" },
{ id: "gpt-3" },
{ id: "my-alpha" },
]);
}),
);
});
it.effect("rejects delegation to a provider without a registered adapter", () =>
Effect.gen(function* () {
const forkOnlyInstanceId = ProviderInstanceId.make("forkOnly");
const forkShadow = yield* buildUnavailableProviderSnapshot({
driverKind: "forkOnly",
instanceId: forkOnlyInstanceId,
reason: "Driver 'forkOnly' is not registered in this build.",
checkedAt: "2026-09-13T00:00:00.000Z",
});
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
hasReceipt: () => Effect.succeed(false),
getThreadRecords: () => Effect.succeed(parentProjection([])),
}),
ServerSettings.layerTest(),
providerRegistryLayer([
providerSnapshot({
instanceId: codexInstanceId,
driver: ProviderDriverKind.make("codex"),
model: "gpt-5.4",
}),
forkShadow,
]),
adapterRegistryLayer([codexInstanceId]),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const byInstance = yield* service
.delegateTask(scope, {
task: "Summarize the diff.",
target: { providerInstanceId: forkOnlyInstanceId },
mode: "async",
clientRequestId: "delegate-fork-1",
})
.pipe(Effect.flip);
assert.equal(byInstance.code, "provider_unavailable");
assert.isTrue(byInstance.message.includes("No V2 provider adapter is registered."));
const byDriver = yield* service
.delegateTask(scope, {
task: "Summarize the diff.",
target: { driverKind: ProviderDriverKind.make("forkOnly") },
mode: "async",
clientRequestId: "delegate-fork-2",
})
.pipe(Effect.flip);
assert.equal(byDriver.code, "provider_unavailable");
assert.isTrue(
byDriver.message.includes("No V2 provider adapter is registered for driver forkOnly."),
);
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
}),
);
it.effect("driver-only delegation skips an instance the project turned off", () =>
Effect.gen(function* () {
const altInstanceId = ProviderInstanceId.make("codex-alt");
const dispatched = yield* Ref.make<ReadonlyArray<unknown>>([]);
const task = {
id: taskId,
threadId: parentThreadId,
runId: parentRunId,
parentNodeId,
origin: "app_owned",
createdBy: "agent",
driver: ProviderDriverKind.make("codex"),
providerInstanceId: altInstanceId,
providerThreadId: null,
childThreadId,
nativeTaskRef: null,
prompt: "Summarize the diff.",
title: null,
model: "gpt-5.4",
status: "running",
result: null,
startedAt: null,
completedAt: null,
};
let delegated = false;
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
hasReceipt: () => Effect.succeed(false),
getThreadRecords: (threadId) =>
Effect.succeed(
threadId === parentThreadId
? parentProjection(delegated ? [task] : [])
: childProjection,
),
isProviderInstanceEnabledForProject: ({ instanceId }) =>
Effect.succeed(instanceId !== codexInstanceId),
assertProviderInstanceEnabled: ({ projectId, instanceId }) =>
instanceId === codexInstanceId
? Effect.fail(
new ThreadManagementService.ThreadManagementProviderInstanceDisabledError({
projectId,
instanceId,
}),
)
: Effect.void,
dispatch: (command) =>
Ref.update(dispatched, (commands) => [...commands, command]).pipe(
Effect.andThen(
Effect.sync(() => {
delegated = true;
}),
),
Effect.as({
sequence: 1,
storedEvents: [
{
sequence: 1,
commandId: null,
event: { type: "subagent.updated", payload: task },
},
],
} as never),
),
}),
providerRegistryLayer([
providerSnapshot({
instanceId: codexInstanceId,
driver: ProviderDriverKind.make("codex"),
model: "gpt-5.4",
}),
providerSnapshot({
instanceId: altInstanceId,
driver: ProviderDriverKind.make("codex"),
model: "gpt-5.4",
}),
]),
adapterRegistryLayer([codexInstanceId, altInstanceId]),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
ServerSettings.layerTest(),
);
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const result = yield* service.delegateTask(scope, {
task: "Summarize the diff.",
target: { driverKind: ProviderDriverKind.make("codex") },
mode: "async",
clientRequestId: "delegate-driver-skip-disabled-1",
});
assert.equal(result.status, "running");
const commands = yield* Ref.get(dispatched);
assert.equal(commands.length, 1);
const request = commands[0] as {
modelSelection: { instanceId: string; model: string };
};
assert.equal(request.modelSelection.instanceId, altInstanceId);
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
}),
);
it.effect(
"retrying an accepted driver-only delegation replays even after the project disables every candidate",
() =>
Effect.gen(function* () {
const altInstanceId = ProviderInstanceId.make("codex-alt");
const dispatched = yield* Ref.make<ReadonlyArray<unknown>>([]);
const accepted = yield* Ref.make(false);
const everyCandidateDisabled = yield* Ref.make(false);
const task = {
id: taskId,
threadId: parentThreadId,
runId: parentRunId,
parentNodeId,
origin: "app_owned",
createdBy: "agent",
driver: ProviderDriverKind.make("codex"),
providerInstanceId: codexInstanceId,
providerThreadId: null,
childThreadId,
nativeTaskRef: null,
prompt: "Summarize the diff.",
title: null,
model: "gpt-5.4",
status: "running",
result: null,
startedAt: null,
completedAt: null,
};
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: (threadId) =>
Ref.get(accepted).pipe(
Effect.map((isAccepted) =>
threadId === parentThreadId
? parentProjection(isAccepted ? [task] : [])
: childProjection,
),
),
hasReceipt: () => Ref.get(accepted),
isProviderInstanceEnabledForProject: () =>
Ref.get(everyCandidateDisabled).pipe(Effect.map((disabled) => !disabled)),
assertProviderInstanceEnabled: ({ projectId, instanceId }) =>
Effect.all([Ref.get(accepted), Ref.get(everyCandidateDisabled)]).pipe(
Effect.flatMap(([isAccepted, disabled]) =>
isAccepted || !disabled
? Effect.void
: Effect.fail(
new ThreadManagementService.ThreadManagementProviderInstanceDisabledError({
projectId,
instanceId,
}),
),
),
),
dispatch: (command) =>
Ref.update(dispatched, (commands) => [...commands, command]).pipe(
Effect.andThen(Ref.set(accepted, true)),
Effect.as({
sequence: 1,
storedEvents: [
{
sequence: 1,
commandId: null,
event: { type: "subagent.updated", payload: task },
},
],
} as never),
),
}),
providerRegistryLayer([
providerSnapshot({
instanceId: codexInstanceId,
driver: ProviderDriverKind.make("codex"),
model: "gpt-5.4",
}),
providerSnapshot({
instanceId: altInstanceId,
driver: ProviderDriverKind.make("codex"),
model: "gpt-5.4",
}),
]),
adapterRegistryLayer([codexInstanceId, altInstanceId]),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
ServerSettings.layerTest(),
);
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const first = yield* service.delegateTask(scope, {
task: "Summarize the diff.",
target: { driverKind: ProviderDriverKind.make("codex") },
mode: "async",
clientRequestId: "delegate-driver-retry-after-disable-1",
});
assert.equal(first.status, "running");
yield* Ref.set(everyCandidateDisabled, true);
const retry = yield* service.delegateTask(scope, {
task: "Summarize the diff.",
target: { driverKind: ProviderDriverKind.make("codex") },
mode: "async",
clientRequestId: "delegate-driver-retry-after-disable-1",
});
assert.equal(retry.status, "running");
const commands = yield* Ref.get(dispatched);
assert.equal(commands.length, 2);
const retryCommand = commands[1] as {
modelSelection: { instanceId: string; model: string };
};
assert.equal(retryCommand.modelSelection.instanceId, codexInstanceId);
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
}),
);
it.live.each([
{ name: "parent instance", parentEnabled: true, model: "gpt-5.4" },
{ name: "alternate instance", parentEnabled: false, model: "gpt-5.5" },
])(
"replays accepted creation on the $name without authorizing new disabled work",
({ parentEnabled, model }) =>
Effect.scoped(
Effect.gen(function* () {
const altInstanceId = ProviderInstanceId.make("codex-alt");
const driver = ProviderDriverKind.make("codex");
const cwd = yield* checkpointWorkspace("mcp-create-retry");
const layerRegistry = ProviderAdapterRegistry.layerFromAdapters(
[codexInstanceId, altInstanceId].map((instanceId) => ({
instanceId,
driver,
getCapabilities: () => Effect.succeed(CodexProviderCapabilitiesV2),
planSelectionTransition: () =>
Effect.succeed({ type: "apply_on_next_turn" as const }),
openSession: () =>
Effect.die("These tests exercise committed commands before provider execution."),
})),
);
const layerDatabase = SqlitePersistence.layerMemory;
const layerOrchestrator = ProviderReplayHarness.layerWithRegistry(
{ name: "mcp-create-retry", runtimePolicyOverride: { cwd } },
layerRegistry,
{ databaseLayer: layerDatabase, runEffectWorker: false },
);
const layerSettings = ServerSettings.layerTest({
providerInstances: {
[codexInstanceId]: { driver: "codex", enabled: true },
[altInstanceId]: { driver: "codex", enabled: true },
},
projectSettingsOverrides: {
[projectId]: { providerInstances: { [codexInstanceId]: { enabled: parentEnabled } } },
},
});
const layerThreads = ThreadManagementService.layer.pipe(
Layer.provideMerge(layerOrchestrator),
Layer.provide(
LegacyV1ThreadImporter.layer.pipe(
Layer.provide(layerOrchestrator),
Layer.provide(layerDatabase),
),
),
Layer.provide(CommandReceiptStore.layer.pipe(Layer.provide(layerDatabase))),
Layer.provideMerge(layerSettings),
);
const layerTest = layerOrchestratorService.pipe(
Layer.provideMerge(layerThreads),
Layer.provide(
Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
layerRegistry,
layerSettings,
providerRegistryLayer([
providerSnapshot({ instanceId: codexInstanceId, driver, model: "gpt-5.4" }),
providerSnapshot({ instanceId: altInstanceId, driver, model: "gpt-5.5" }),
]),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
),
),
);
yield* Effect.gen(function* () {
const orchestrator = yield* Orchestrator.OrchestratorV2;
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const settings = yield* ServerSettings.ServerSettingsService;
yield* orchestrator.dispatch({
type: "thread.create",
createdBy: "user",
creationSource: "web",
commandId: CommandId.make("parent:create"),
threadId: parentThreadId,
projectId,
title: "MCP parent",
modelSelection: { instanceId: codexInstanceId, model: "gpt-5.4" },
runtimeMode: "full-access",
interactionMode: "default",
branch: null,
worktreePath: cwd,
});
yield* orchestrator.dispatch({
type: "message.dispatch",
createdBy: "user",
creationSource: "web",
commandId: CommandId.make("parent:start"),
threadId: parentThreadId,
messageId: MessageId.make("parent:message"),
text: "Create a thread.",
attachments: [],
dispatchMode: { type: "start_immediately" },
});
const request = {
threads: [{ target: { driverKind: driver, model } }],
clientRequestId: "create-retry",
};
const first = yield* service.createThreads(scope, request);
const child = first.threads[0]!;
const selection = parentEnabled
? { instanceId: codexInstanceId, model: "gpt-5.4" }
: { instanceId: altInstanceId, model: "gpt-5.5" };
assert.equal(first.threads.length, 1);
assert.equal(child.providerInstanceId, selection.instanceId);
assert.equal(child.model, selection.model);
assert.deepEqual(yield* service.createThreads(scope, request), first);
// The creation receipt exists, but this prompt has not been accepted yet.
const withPrompt = {
...request,
threads: [{ ...request.threads[0]!, prompt: "Start work." }],
};
const started = yield* service.createThreads(scope, withPrompt);
assert.equal(started.threads[0]?.threadId, child.threadId);
const before = yield* orchestrator.getThreadProjection(child.threadId);
assert.deepEqual(before.runs[0]?.modelSelection, selection);
assert.equal(before.messages.length, 1);
const empty = yield* service.createThreads(scope, {
...request,
clientRequestId: "empty",
});
const emojiAtLimit = yield* service.createThreads(scope, {
threads: [{ ...request.threads[0]!, prompt: `${"a".repeat(76)}😀 and more work.` }],
clientRequestId: "emoji-title",
});
const titled = yield* orchestrator.getThreadProjection(
emojiAtLimit.threads[0]!.threadId,
);
assert.equal(titled.thread.title, `${"a".repeat(76)}...`);
yield* settings.updateSettings({
projectSettingsOverrides: {
[projectId]: {
providerInstances: {
[codexInstanceId]: { enabled: false },
[altInstanceId]: { enabled: false },
},
},
},
});
assert.deepEqual(yield* service.createThreads(scope, withPrompt), started);
const after = yield* orchestrator.getThreadProjection(child.threadId);
assert.deepEqual(after.thread.modelSelection, selection);
assert.deepEqual(after.runs, before.runs);
assert.deepEqual(after.messages, before.messages);
const freshError = yield* service
.createThreads(scope, {
...request,
clientRequestId: "fresh",
})
.pipe(Effect.flip);
assert.equal(freshError.code, "provider_unavailable");
const promptError = yield* service
.createThreads(scope, {
...withPrompt,
clientRequestId: "empty",
})
.pipe(Effect.flip);
assert.equal(promptError.code, "invalid_request");
assert.include(promptError.message, "disabled");
const untouched = yield* orchestrator.getThreadProjection(empty.threads[0]!.threadId);
assert.equal(untouched.messages.length, 0);
assert.equal(untouched.runs.length, 0);
}).pipe(Effect.provide(layerTest));
}).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
),
);
it.effect(
"inherits an available parent instance for driver-only targets and otherwise selects a healthy peer",
() =>
Effect.gen(function* () {
const codexAltInstanceId = ProviderInstanceId.make("codex-alt");
const driver = ProviderDriverKind.make("codex");
const claudeDriver = ProviderDriverKind.make("claudeAgent");
const parentModelSelection = {
instanceId: codexInstanceId,
model: "gpt-5.4",
options: [{ id: "reasoningEffort", value: "high" }],
} as const;
const task = {
id: taskId,
threadId: parentThreadId,
runId: parentRunId,
parentNodeId,
origin: "app_owned",
createdBy: "agent",
driver,
providerInstanceId: codexInstanceId,
providerThreadId: null,
childThreadId,
nativeTaskRef: null,
prompt: "Summarize the diff.",
title: null,
model: "gpt-5.4",
status: "running",
result: null,
startedAt: null,
completedAt: null,
};
const cases = [
{
name: "healthy-inherited",
inheritedEnabled: true,
peerEnabled: true,
explicit: false,
selectedInstanceId: codexInstanceId,
candidateDriver: driver,
},
{
name: "unavailable-inherited-falls-back-to-healthy-peer",
inheritedEnabled: false,
peerEnabled: true,
explicit: false,
selectedInstanceId: codexAltInstanceId,
candidateDriver: driver,
},
{
name: "no-available-peer",
inheritedEnabled: false,
peerEnabled: false,
explicit: false,
selectedInstanceId: null,
candidateDriver: driver,
},
{
name: "cross-driver-no-available-candidate",
inheritedEnabled: false,
peerEnabled: false,
explicit: false,
selectedInstanceId: null,
candidateDriver: claudeDriver,
},
{
name: "explicit-unavailable",
inheritedEnabled: false,
peerEnabled: true,
explicit: true,
selectedInstanceId: null,
candidateDriver: driver,
},
{
name: "inherited-unavailable",
inheritedEnabled: false,
peerEnabled: true,
explicit: false,
selectedInstanceId: null,
candidateDriver: driver,
},
{
name: "explicit-disabled-without-adapter",
inheritedEnabled: false,
peerEnabled: true,
explicit: true,
selectedInstanceId: null,
candidateDriver: driver,
},
{
name: "explicit-healthy",
inheritedEnabled: true,
peerEnabled: true,
explicit: true,
selectedInstanceId: codexAltInstanceId,
candidateDriver: driver,
},
] as const;
for (const testCase of cases) {
const dispatched = yield* Ref.make<ReadonlyArray<unknown>>([]);
let delegated = false;
const layerDependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
hasReceipt: () => Effect.succeed(false),
assertProviderInstanceEnabled: () => Effect.void,
isProviderInstanceEnabledForProject: () => Effect.succeed(true),
getThreadRecords: (threadId) =>
Effect.succeed(
threadId === parentThreadId
? parentProjection(delegated ? [task] : [], parentModelSelection)
: childProjection,
),
dispatch: (command) =>
Ref.update(dispatched, (commands) => [...commands, command]).pipe(
Effect.andThen(
Effect.sync(() => {
delegated = true;
}),
),
Effect.as({
sequence: 1,
storedEvents: [
{
sequence: 1,
commandId: null,
event: { type: "subagent.updated", payload: task },
},
],
} as never),
),
}),
ServerSettings.layerTest(),
providerRegistryLayer([
providerSnapshot({
instanceId: codexInstanceId,
driver,
model: "gpt-5.4",
enabled: testCase.inheritedEnabled,
}),
providerSnapshot({
instanceId: codexAltInstanceId,
driver: testCase.candidateDriver,
model: "codex-alt-model",
enabled: testCase.peerEnabled,
}),
]),
adapterRegistryLayer(
testCase.name === "explicit-disabled-without-adapter"
? [codexAltInstanceId]
: [codexInstanceId, codexAltInstanceId],
),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const target =
testCase.name === "inherited-unavailable"
? undefined
: testCase.explicit
? ({
providerInstanceId:
testCase.selectedInstanceId === null
? codexInstanceId
: testCase.selectedInstanceId,
} as const)
: ({ driverKind: testCase.candidateDriver } as const);
if (testCase.selectedInstanceId === null) {
const error = yield* service
.delegateTask(scope, {
task: "Summarize the diff.",
target,
mode: "async",
clientRequestId: `delegate-select-${testCase.name}`,
})
.pipe(Effect.flip);
assert.equal(error.code, "provider_unavailable", testCase.name);
if (
testCase.name === "explicit-unavailable" ||
testCase.name === "inherited-unavailable" ||
testCase.name === "explicit-disabled-without-adapter"
) {
const expectedMessage =
`Provider ${codexInstanceId} cannot run a child task: ` +
(testCase.name === "explicit-disabled-without-adapter"
? "No V2 provider adapter is registered. "
: "") +
"Provider instance is disabled.";
assert.equal(error.message, expectedMessage);
const threadError = yield* service
.createThreads(scope, {
threads: [{ prompt: "Summarize the diff.", target }],
clientRequestId: `disabled-threads-${testCase.name}`,
})
.pipe(Effect.flip);
assert.equal(threadError.code, "provider_unavailable");
assert.equal(threadError.message, expectedMessage);
}
if (testCase.name === "cross-driver-no-available-candidate") {
assert.isTrue(error.message.includes("driver claudeAgent"), testCase.name);
const threadError = yield* service
.createThreads(scope, {
threads: [{ prompt: "Summarize the diff.", target }],
clientRequestId: `delegate-threads-${testCase.name}`,
})
.pipe(Effect.flip);
assert.equal(
threadError.code,
"provider_unavailable",
`${testCase.name}-createThreads`,
);
assert.isTrue(
threadError.message.includes("driver claudeAgent"),
`${testCase.name}-createThreads`,
);
}
assert.deepEqual(yield* Ref.get(dispatched), [], testCase.name);
return;
}
const result = yield* service.delegateTask(scope, {
task: "Summarize the diff.",
target,
mode: "async",
clientRequestId: `delegate-select-${testCase.name}`,
});
assert.equal(result.status, "running", testCase.name);
const commands = yield* Ref.get(dispatched);
assert.equal(commands.length, 1, testCase.name);
const request = commands[0] as {
type: string;
modelSelection: {
instanceId: string;
model: string;
options?: ReadonlyArray<{ id: string; value: unknown }>;
};
};
assert.equal(request.type, "delegated_task.request", testCase.name);
assert.equal(
request.modelSelection.instanceId,
testCase.selectedInstanceId,
testCase.name,
);
if (testCase.name === "healthy-inherited") {
assert.deepEqual(request.modelSelection, parentModelSelection, testCase.name);
} else {
assert.equal(request.modelSelection.model, "codex-alt-model", testCase.name);
}
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(layerDependencies))));
}
}),
);
describe("scheduled tasks at modes above the caller's", () => {
const projectId = ProjectId.make("project:scheduled");
const boundThreadId = ThreadId.make("thread:scheduled-bound");
const task = (overrides: Partial<ScheduledTask>): ScheduledTask => ({
id: ScheduledTaskId.make("scheduled-task:webhook"),
title: "On push",
prompt: "Do {{body.instruction}}",
enabled: true,
schedule: { type: "webhook", signature: null },
projectId,
threadId: null,
workspaceStrategy: { type: "root" },
modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5" },
runtimeMode: "approval-required",
interactionMode: "default",
createdBy: "agent",
creationSource: "mcp",
createdAt: "2026-10-05T00:00:00.000Z",
updatedAt: "2026-10-05T00:00:00.000Z",
nextRunAt: null,
lastRunAt: null,
lastRunStatus: "never",
lastRunError: null,
runCount: 0,
webhook: {
path: "/hooks/scheduled-task/secret",
url: "https://t3.example/hooks/secret",
hasSecret: false,
},
...overrides,
});
const supervisedClient: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:scheduled"),
requestNamespace: "client:scheduled",
thread: undefined,
client: {
sessionId: "scheduled",
label: "Claude Code",
access: "approval-required",
},
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
const service = (
tasks: ReadonlyArray<ScheduledTask>,
boundThread: OrchestrationV2ThreadShell | null,
upserted: Ref.Ref<number>,
) =>
layerOrchestratorService.pipe(
Layer.provide(
Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadShell: (threadId) =>
Effect.succeed(threadId === boundThreadId ? boundThread : null),
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({
list: () => Effect.succeed({ tasks }),
upsert: () =>
Ref.update(upserted, (count) => count + 1).pipe(Effect.as({ task: tasks[0]! })),
}),
),
),
);
it.effect("hides a webhook URL from a caller below the task's modes", () =>
Effect.gen(function* () {
const upserted = yield* Ref.make(0);
const listed = yield* OrchestratorMcpService.OrchestratorMcpService.pipe(
Effect.flatMap((mcp) => mcp.listScheduledTasks(supervisedClient, { projectId })),
Effect.provide(
service(
[
task({ runtimeMode: "full-access" }),
task({ id: ScheduledTaskId.make("scheduled-task:supervised") }),
],
null,
upserted,
),
),
);
assert.deepEqual(
listed.tasks.map((summary) => summary.webhookUrl),
[undefined, "https://t3.example/hooks/secret"],
);
}),
);
it.effect("hides a webhook URL from a thread whose turn has ended", () =>
Effect.gen(function* () {
const callerId = ThreadId.make("thread:scheduled-ended");
const shell = liveThreadShell(callerId, { activeRunId: null });
const listed = yield* OrchestratorMcpService.OrchestratorMcpService.pipe(
Effect.flatMap((mcp) =>
mcp.listScheduledTasks(
{
...supervisedClient,
requestNamespace: "provider:scheduled-ended",
thread: {
threadId: callerId,
providerSessionId: "provider:scheduled-ended",
providerInstanceId: shell.providerInstanceId,
},
client: undefined,
},
{ projectId },
),
),
Effect.provide(
layerOrchestratorService.pipe(
Layer.provide(
Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadShell: () => Effect.succeed(null),
getThreadRecords: () => Effect.succeed(idleThreadProjection(shell)),
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({
getProviders: Effect.succeed([]),
}),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({
list: () => Effect.succeed({ tasks: [task({})] }),
}),
),
),
),
),
);
assert.equal(listed.tasks[0]?.webhookUrl, undefined);
}),
);
it.effect("never shows a read-only client a webhook URL", () =>
Effect.gen(function* () {
const upserted = yield* Ref.make(0);
const listed = yield* OrchestratorMcpService.OrchestratorMcpService.pipe(
Effect.flatMap((mcp) =>
mcp.listScheduledTasks(
{
...supervisedClient,
client: { sessionId: "scheduled", label: "Claude Code", access: "read-only" },
},
{ projectId },
),
),
Effect.provide(service([task({})], null, upserted)),
);
assert.equal(listed.tasks[0]?.webhookUrl, undefined);
}),
);
it.effect("checks a bound task against its thread's current modes", () =>
Effect.gen(function* () {
const upserted = yield* Ref.make(0);
const bound = task({ threadId: boundThreadId });
const layer = service(
[bound],
liveThreadShell(boundThreadId, { runtimeMode: "full-access" }),
upserted,
);
const mcp = yield* OrchestratorMcpService.OrchestratorMcpService.pipe(
Effect.provide(layer),
);
const listed = yield* mcp.listScheduledTasks(supervisedClient, { projectId });
assert.equal(listed.tasks[0]?.webhookUrl, undefined);
const error = yield* mcp
.updateScheduledTask(supervisedClient, {
scheduledTaskId: bound.id,
prompt: "Something else",
})
.pipe(Effect.flip);
assert.equal(error.code, "runtime_mode_escalation_denied");
assert.equal(yield* Ref.get(upserted), 0);
}),
);
it.effect("reports a saved task even when its bound thread cannot be read", () =>
Effect.gen(function* () {
const upserted = yield* Ref.make(0);
const bound = task({ threadId: boundThreadId });
const lookups = yield* Ref.make(0);
const mcp = yield* OrchestratorMcpService.OrchestratorMcpService.pipe(
Effect.provide(
layerOrchestratorService.pipe(
Layer.provide(
Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadShell: (threadId) =>
Ref.getAndUpdate(lookups, (count) => count + 1).pipe(
Effect.flatMap((count) =>
count === 0
? Effect.succeed(
liveThreadShell(threadId, { runtimeMode: "approval-required" }),
)
: Effect.fail(new OrchestratorProjectionError({ threadId })),
),
),
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({
getProviders: Effect.succeed([]),
}),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({
list: () => Effect.succeed({ tasks: [bound] }),
upsert: () =>
Ref.update(upserted, (count) => count + 1).pipe(Effect.as({ task: bound })),
}),
),
),
),
),
);
const updated = yield* mcp.updateScheduledTask(supervisedClient, {
scheduledTaskId: bound.id,
prompt: "Something else",
});
assert.equal(yield* Ref.get(upserted), 1);
assert.equal(updated.scheduledTaskId, bound.id);
assert.equal(updated.webhookUrl, undefined);
}),
);
});
describe("the base branch of an unbound scheduled task", () => {
const projectId = ProjectId.make("project:scheduled-base");
const workspaceRoot = "/repo/scheduled-base";
const existing: ScheduledTask = {
id: ScheduledTaskId.make("scheduled-task:base"),
title: "Nightly",
prompt: "Check the build",
enabled: true,
schedule: { type: "interval", everyMs: 3_600_000 },
projectId,
threadId: null,
workspaceStrategy: { type: "root" },
modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5" },
runtimeMode: "approval-required",
interactionMode: "default",
createdBy: "agent",
creationSource: "mcp",
createdAt: "2026-10-05T00:00:00.000Z",
updatedAt: "2026-10-05T00:00:00.000Z",
nextRunAt: null,
lastRunAt: null,
lastRunStatus: "never",
lastRunError: null,
runCount: 0,
};
const client: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:scheduled-base"),
requestNamespace: "client:scheduled-base",
thread: undefined,
client: {
sessionId: "scheduled-base",
label: "Claude Code",
access: "approval-required",
},
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
const service = (
git: Partial<GitVcsDriver.GitVcsDriver["Service"]>,
saved: Ref.Ref<ReadonlyArray<ScheduledTask["workspaceStrategy"]>>,
task: ScheduledTask = existing,
modes?: Ref.Ref<ReadonlyArray<ScheduledTaskUpsertInput["threadMode"]>>,
) =>
OrchestratorMcpService.layer.pipe(
Layer.provide(Layer.mock(ThreadLaunchService.ThreadLaunchService)({})),
Layer.provide(Layer.mock(GitVcsDriver.GitVcsDriver)(git)),
Layer.provide(
Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadShell: () => Effect.succeed(null),
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({
getById: () =>
Effect.succeedSome({
id: projectId,
workspaceRoot,
defaultModelSelection: existing.modelSelection,
} as never),
}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({
list: () => Effect.succeed({ tasks: [task] }),
upsert: (input) =>
Ref.update(saved, (strategies) => [...strategies, input.workspaceStrategy]).pipe(
Effect.andThen(
modes === undefined
? Effect.void
: Ref.update(modes, (all) => [...all, input.threadMode]),
),
Effect.as({ task }),
),
}),
),
),
);
const masterRepository: Partial<GitVcsDriver.GitVcsDriver["Service"]> = {
resolvePrimaryRemoteName: () => Effect.succeed("origin"),
resolveDefaultBranchName: (cwd, remoteName) =>
Effect.succeed(cwd === workspaceRoot && remoteName === "origin" ? "master" : null),
resolveCommit: () => Effect.succeed({ commitSha: "abc123" }),
};
const schedule = { type: "interval", everyMs: 3_600_000 } as const;
it.effect("starts from the project's default branch", () =>
Effect.gen(function* () {
const saved = yield* Ref.make<ReadonlyArray<ScheduledTask["workspaceStrategy"]>>([]);
const mcp = yield* OrchestratorMcpService.OrchestratorMcpService.pipe(
Effect.provide(service(masterRepository, saved)),
);
yield* mcp.scheduleTask(client, { projectId, prompt: "Check the build", schedule });
assert.deepEqual(yield* Ref.get(saved), [
{ type: "worktree", baseRef: "origin/master", startFromOrigin: true },
]);
}),
);
it.effect("keeps one thread when fresh sessions are turned off before the first run", () =>
Effect.gen(function* () {
const modes = yield* Ref.make<ReadonlyArray<ScheduledTaskUpsertInput["threadMode"]>>([]);
const mcp = yield* OrchestratorMcpService.OrchestratorMcpService.pipe(
Effect.provide(
service(
masterRepository,
yield* Ref.make<ReadonlyArray<ScheduledTask["workspaceStrategy"]>>([]),
{ ...existing, threadMode: "fresh_session" },
modes,
),
),
);
yield* mcp.updateScheduledTask(client, {
scheduledTaskId: existing.id,
freshSession: false,
});
yield* mcp.updateScheduledTask(client, {
scheduledTaskId: existing.id,
bindToCurrentThread: false,
});
assert.deepEqual(yield* Ref.get(modes), ["continue", "new_thread"]);
}),
);
it.effect(
"refuses unbinding into fresh sessions in one call, which would keep the thread",
() =>
Effect.gen(function* () {
const modes = yield* Ref.make<ReadonlyArray<ScheduledTaskUpsertInput["threadMode"]>>([]);
const mcp = yield* OrchestratorMcpService.OrchestratorMcpService.pipe(
Effect.provide(
service(
masterRepository,
yield* Ref.make<ReadonlyArray<ScheduledTask["workspaceStrategy"]>>([]),
{
...existing,
threadId: ThreadId.make("thread:scheduled-base"),
threadMode: "continue",
},
modes,
),
),
);
const refused = yield* mcp
.updateScheduledTask(client, {
scheduledTaskId: existing.id,
bindToCurrentThread: false,
freshSession: true,
})
.pipe(Effect.flip);
assert.include(refused.message, "first unbind it");
assert.deepEqual(yield* Ref.get(modes), []);
}),
);
it.effect("follows the default branch when a task is unbound from its thread", () =>
Effect.gen(function* () {
const saved = yield* Ref.make<ReadonlyArray<ScheduledTask["workspaceStrategy"]>>([]);
const mcp = yield* OrchestratorMcpService.OrchestratorMcpService.pipe(
Effect.provide(service(masterRepository, saved)),
);
yield* mcp.updateScheduledTask(client, {
scheduledTaskId: existing.id,
bindToCurrentThread: false,
});
assert.deepEqual(yield* Ref.get(saved), [
{ type: "worktree", baseRef: "origin/master", startFromOrigin: true },
]);
}),
);
it.effect.each([
{
name: "no remote, only master",
remote: null,
remoteDefault: null,
refs: ["refs/heads/master"],
baseRef: "master",
},
{
name: "no remote, main and master",
remote: null,
remoteDefault: null,
refs: ["refs/heads/master", "refs/heads/main"],
baseRef: "main",
},
{
name: "no remote, neither main nor master",
remote: null,
remoteDefault: null,
refs: ["refs/heads/develop"],
baseRef: "main",
},
{
name: "no recorded HEAD, remote main and a stale local master",
remote: "origin",
remoteDefault: null,
refs: ["refs/heads/master", "refs/remotes/origin/main"],
baseRef: "origin/main",
},
{
name: "no recorded HEAD, master only on the remote",
remote: "origin",
remoteDefault: null,
refs: ["refs/remotes/origin/master"],
baseRef: "origin/master",
},
{
name: "no recorded HEAD, local main and master only on the remote",
remote: "origin",
remoteDefault: null,
refs: ["refs/heads/main", "refs/remotes/origin/master"],
baseRef: "origin/master",
},
{
name: "no recorded HEAD, nothing conventional on the remote, local main",
remote: "origin",
remoteDefault: null,
refs: ["refs/heads/main", "refs/remotes/origin/develop"],
baseRef: "main",
},
{
name: "a recorded HEAD whose branch is gone",
remote: "origin",
remoteDefault: "main",
refs: ["refs/heads/main", "refs/remotes/origin/master"],
baseRef: "origin/master",
},
{
name: "a remote not called origin",
remote: "upstream",
remoteDefault: "develop",
refs: ["refs/remotes/upstream/develop"],
baseRef: "upstream/develop",
},
{
name: "a remote not called origin, no recorded HEAD",
remote: "upstream",
remoteDefault: null,
refs: ["refs/remotes/upstream/main"],
baseRef: "upstream/main",
},
])("$name starts from $baseRef", ({ remote, remoteDefault, refs, baseRef }) =>
Effect.gen(function* () {
const saved = yield* Ref.make<ReadonlyArray<ScheduledTask["workspaceStrategy"]>>([]);
const gitFailure = (cwd: string, detail: string) =>
new GitCommandError({ operation: "GitVcsDriver.test", command: "git", cwd, detail });
const mcp = yield* OrchestratorMcpService.OrchestratorMcpService.pipe(
Effect.provide(
service(
{
resolvePrimaryRemoteName: (cwd) =>
remote === null
? Effect.fail(gitFailure(cwd, "No git remote is configured."))
: Effect.succeed(remote),
resolveDefaultBranchName: () => Effect.succeed(remoteDefault),
resolveCommit: ({ cwd, revision }) =>
refs.includes(revision)
? Effect.succeed({ commitSha: "abc123" })
: Effect.fail(gitFailure(cwd, "Needed a single revision")),
},
saved,
),
),
);
yield* mcp.scheduleTask(client, { projectId, prompt: "Check the build", schedule });
assert.deepEqual(yield* Ref.get(saved), [
{ type: "worktree", baseRef, startFromOrigin: true },
]);
}),
);
});
it.effect(
"reports the child run's selection after a restart and the thread selection before launch",
() =>
Effect.gen(function* () {
const runSelection = {
instanceId: ProviderInstanceId.make("claudeAgent-personal"),
model: "claude-opus-4-6",
options: [
{ id: "effort", value: "max" },
{ id: "fastMode", value: true },
],
} as const;
const threadSelection = {
instanceId: codexInstanceId,
model: "gpt-5.4",
options: [{ id: "reasoningEffort", value: "high" }],
} as const;
let hasRun = true;
const task = {
id: taskId,
threadId: parentThreadId,
origin: "app_owned",
childThreadId,
providerInstanceId: ProviderInstanceId.make("claudeAgent-work"),
model: "claude-sonnet-4-6",
status: "running",
result: null,
};
const dependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadRecords: (threadId) =>
Effect.succeed(
threadId === parentThreadId
? parentProjection([task])
: ({
...childProjection,
thread: { ...childProjection.thread, modelSelection: threadSelection },
runs: hasRun
? [
{
id: RunId.make("run:mcp-restarted-child"),
ordinal: 1,
status: "running",
modelSelection: runSelection,
},
]
: [],
} as unknown as OrchestrationV2ThreadProjection),
),
}),
ServerSettings.layerTest(),
providerRegistryLayer([]),
adapterRegistryLayer([]),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
for (const selection of [runSelection, threadSelection]) {
const result = yield* service.taskStatus(scope, taskId);
assert.equal(result.providerInstanceId, selection.instanceId);
assert.equal(result.model, selection.model);
assert.deepEqual(result.options, selection.options);
hasRun = false;
}
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(dependencies))));
}),
);
it.effect(
"inherits delegated options, merges overrides, and resets on explicit clearing or a new target",
() =>
Effect.gen(function* () {
const peerId = ProviderInstanceId.make("codex-subscription-2");
const driver = ProviderDriverKind.make("codex");
const inherited = {
instanceId: codexInstanceId,
model: "gpt-5.4",
options: [
{ id: "reasoningEffort", value: "high" },
{ id: "serviceTier", value: "priority" },
],
} as const;
const override = [{ id: "reasoningEffort", value: "max" }] as const;
const cases = [
{
name: "partial override",
target: { options: override },
expected: { ...inherited, options: [...override, inherited.options[1]] },
},
{
name: "clear with array",
target: { options: [] },
expected: { ...inherited, options: [] },
},
{
name: "clear with object",
target: { options: {} },
expected: { ...inherited, options: [] },
},
{
name: "change model",
target: { model: "other-model" },
expected: { instanceId: codexInstanceId, model: "other-model" },
},
{
name: "change provider with override",
target: { providerInstanceId: peerId, options: { reasoningEffort: "max" } },
expected: { instanceId: peerId, model: inherited.model, options: override },
},
{
name: "old Ultracode effort level",
target: { model: "ultracode-model", options: { effort: "ultracode" } },
expected: {
instanceId: codexInstanceId,
model: "ultracode-model",
options: [
{ id: "effort", value: "xhigh" },
{ id: "ultracode", value: true },
],
},
},
] as const;
for (const testCase of cases) {
const commands: Array<unknown> = [];
const task = {
id: taskId,
threadId: parentThreadId,
origin: "app_owned",
childThreadId,
providerInstanceId: testCase.expected.instanceId,
model: testCase.expected.model,
status: "running",
result: null,
};
const dependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
hasReceipt: () => Effect.succeed(false),
assertProviderInstanceEnabled: () => Effect.void,
getThreadRecords: (threadId) =>
Effect.succeed(
threadId === parentThreadId
? parentProjection(commands.length > 0 ? [task] : [], inherited)
: childProjection,
),
dispatch: (command) =>
Effect.sync(() => {
commands.push(command);
return {
sequence: 1,
storedEvents: [{ event: { type: "subagent.updated", payload: task } }],
} as never;
}),
}),
ServerSettings.layerTest(),
providerRegistryLayer([
{
...providerSnapshot({
instanceId: codexInstanceId,
driver,
model: inherited.model,
}),
models: [
...[inherited.model, "other-model"].map((model) => ({
slug: model,
name: model,
isCustom: false,
capabilities: null,
})),
{
slug: "ultracode-model",
name: "ultracode-model",
isCustom: false,
capabilities: {
optionDescriptors: [
{
id: "effort",
label: "Reasoning",
type: "select",
options: [
{ id: "high", label: "High" },
{ id: "xhigh", label: "Extra High" },
],
},
{ id: "ultracode", label: "Ultracode", type: "boolean" },
],
},
},
],
},
providerSnapshot({ instanceId: peerId, driver, model: inherited.model }),
]),
adapterRegistryLayer([codexInstanceId, peerId]),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const capabilities = yield* service.capabilities(scope);
assert.deepEqual(capabilities.inheritedOptions, inherited.options);
yield* service.delegateTask(scope, {
task: "Review the change.",
target: yield* decodeTarget(testCase.target),
mode: "async",
clientRequestId: testCase.name,
});
assert.deepEqual(
(commands[0] as { modelSelection: unknown }).modelSelection,
testCase.expected,
testCase.name,
);
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(dependencies))));
}
}),
);
it.effect("accepts the inherited options it reports back as a delegate target", () =>
Effect.gen(function* () {
// t3_thread_launch keeps a model selection as given, so a thread can hold an option its model lacks.
const inherited = {
instanceId: codexInstanceId,
model: "gpt-5.4",
options: [
{ id: "reasoningEffort", value: "low" },
{ id: "fastMode", value: false },
],
} as const;
const commands: Array<{ readonly modelSelection?: unknown }> = [];
const task = {
id: taskId,
threadId: parentThreadId,
origin: "app_owned",
childThreadId,
providerInstanceId: codexInstanceId,
model: inherited.model,
status: "running",
result: null,
};
const dependencies = Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
hasReceipt: () => Effect.succeed(false),
assertProviderInstanceEnabled: () => Effect.void,
getThreadRecords: (threadId) =>
Effect.succeed(
threadId === parentThreadId
? parentProjection(commands.length > 0 ? [task] : [], inherited)
: childProjection,
),
dispatch: (command) =>
Effect.sync(() => {
commands.push(command as { readonly modelSelection?: unknown });
return {
sequence: 1,
storedEvents: [{ event: { type: "subagent.updated", payload: task } }],
} as never;
}),
}),
ServerSettings.layerTest(),
providerRegistryLayer([
{
...providerSnapshot({
instanceId: codexInstanceId,
driver: ProviderDriverKind.make("codex"),
}),
models: [
{
slug: inherited.model,
name: inherited.model,
isCustom: false,
capabilities: {
optionDescriptors: [
{
id: "reasoningEffort",
label: "Reasoning",
type: "select",
options: [{ id: "low", label: "Low" }],
},
],
},
},
],
},
]),
adapterRegistryLayer([codexInstanceId]),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
);
yield* Effect.gen(function* () {
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const { inheritedOptions } = yield* service.capabilities(scope);
yield* service.delegateTask(scope, {
task: "Review the change.",
target: yield* decodeTarget({ options: inheritedOptions }),
mode: "async",
});
assert.deepEqual(commands[0]?.modelSelection, {
...inherited,
options: [inherited.options[0]],
});
}).pipe(Effect.provide(layerOrchestratorService.pipe(Layer.provide(dependencies))));
}),
);
describe("resolveRuntimeMode", () => {
const muse = {
modelSelection: { instanceId: ProviderInstanceId.make("muse"), model: "muse-model" },
supportedRuntimeModes: ["approval-required", "full-access"] as const,
};
it.effect("refuses an explicit mode the target provider does not offer", () =>
Effect.gen(function* () {
const error = yield* resolveRuntimeMode("full-access", "auto-accept-edits", muse).pipe(
Effect.flip,
);
assert.equal(error.code, "invalid_request");
assert.include(error.message, "approval-required, full-access");
}),
);
it.effect("steps an inherited mode down to the broadest one the provider offers", () =>
Effect.gen(function* () {
assert.equal(yield* resolveRuntimeMode("full-access", "inherit", muse), "full-access");
assert.equal(yield* resolveRuntimeMode("auto", undefined, muse), "approval-required");
}),
);
});
});
describe("OrchestratorMcpService thread lookup", () => {
const bareId = ThreadId.make("5d0b4a3e-8c1f-4a52-9d37-2f6c7e1b9a04");
const launched = liveThreadShell(ThreadId.make(`mcp:${bareId}`));
const deletedLaunched = { ...launched, deletedAt: DateTime.makeUnsafe("2026-10-05T00:00:00Z") };
const client: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:thread-lookup"),
requestNamespace: "client:thread-lookup",
thread: undefined,
client: { sessionId: "thread-lookup", label: "Claude Code", access: "full-access" },
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
const service = (
shells: ReadonlyArray<OrchestrationV2ThreadShell>,
sent: Ref.Ref<number>,
overrides: Partial<ThreadManagementService.ThreadManagementService["Service"]> = {},
) =>
layerOrchestratorService.pipe(
Layer.provide(
Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
getThreadShell: (threadId) =>
Effect.succeed(shells.find((shell) => shell.id === threadId) ?? null),
sendToThread: () => Ref.update(sent, (count) => count + 1).pipe(Effect.as({} as never)),
...overrides,
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
),
),
);
const failuresFor = (shells: ReadonlyArray<OrchestrationV2ThreadShell>) =>
Effect.gen(function* () {
const sent = yield* Ref.make(0);
return yield* Effect.gen(function* () {
const mcp = yield* OrchestratorMcpService.OrchestratorMcpService;
const read = yield* mcp.readThread(client, { threadId: bareId }).pipe(Effect.flip);
const send = yield* mcp
.sendToThread(client, { threadId: bareId, message: "hello" })
.pipe(Effect.flip);
const wait = yield* mcp.waitForThread(client, { threadId: bareId }).pipe(Effect.flip);
return { read, send, wait, sends: yield* Ref.get(sent) };
}).pipe(Effect.provide(service(shells, sent)));
});
it.effect("points a bare uuid at the mcp: thread it belongs to", () =>
Effect.gen(function* () {
const { read, send, wait, sends } = yield* failuresFor([launched]);
for (const error of [read, send, wait]) {
assert.equal(error.code, "thread_not_found");
assert.include(error.message, `mcp:${bareId}`);
}
assert.equal(sends, 0);
}),
);
it.effect("keeps the plain message for an id that matches nothing", () =>
Effect.gen(function* () {
const { read, send, wait } = yield* failuresFor([]);
assert.equal(read.code, "thread_not_found");
assert.equal(read.message, `Thread ${bareId} is no longer available.`);
assert.equal(send.code, "thread_not_found");
assert.equal(send.message, `Thread ${bareId} was not found.`);
assert.equal(wait.code, "thread_not_found");
assert.equal(wait.message, send.message);
}),
);
it.effect("does not name an mcp: thread that was deleted", () =>
Effect.gen(function* () {
const { read, send, wait } = yield* failuresFor([deletedLaunched]);
assert.equal(read.message, `Thread ${bareId} is no longer available.`);
assert.equal(send.message, `Thread ${bareId} was not found.`);
assert.equal(wait.message, send.message);
}),
);
it.effect("refuses waiting without orchestration capability before reading the target", () =>
Effect.gen(function* () {
const sent = yield* Ref.make(0);
return yield* Effect.gen(function* () {
const mcp = yield* OrchestratorMcpService.OrchestratorMcpService;
const error = yield* mcp
.waitForThread({ ...client, capabilities: new Set() }, { threadId: bareId })
.pipe(Effect.flip);
assert.equal(error.code, "capability_denied");
}).pipe(
Effect.provide(
service([], sent, {
getThreadShell: () => Effect.die("Unauthorized target access"),
}),
),
);
}),
);
it.effect("waits on the caller's own thread without a separate shell lookup", () =>
Effect.gen(function* () {
const sent = yield* Ref.make(0);
return yield* Effect.gen(function* () {
const mcp = yield* OrchestratorMcpService.OrchestratorMcpService;
const result = yield* mcp.waitForThread(
{
...client,
thread: {
threadId: launched.id,
providerSessionId: "provider-session:wait-self",
providerInstanceId: ProviderInstanceId.make("codex"),
},
},
{ threadId: launched.id },
);
assert.deepEqual(result, {
threadId: launched.id,
runId: null,
status: "idle",
timedOut: false,
});
}).pipe(
Effect.provide(
service([], sent, {
getThreadShell: () => Effect.die("Unexpected shell lookup for the caller"),
getThreadRecords: () => Effect.succeed(idleThreadProjection(launched)),
waitForThread: () =>
Effect.succeed({ threadId: launched.id, run: null, timedOut: false }),
}),
),
);
}),
);
});
describe("OrchestratorMcpService thread list", () => {
const client: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:thread-list"),
requestNamespace: "client:thread-list",
thread: undefined,
client: { sessionId: "thread-list", label: "Claude Code", access: "full-access" },
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
const shell = (id: string, projectId: string, snoozed: boolean) => ({
...liveThreadShell(ThreadId.make(id)),
projectId: ProjectId.make(projectId),
status: "completed" as const,
snoozedUntil: snoozed ? DateTime.makeUnsafe("2099-01-01T00:00:00Z") : null,
});
const shells = [
shell("thread:a-snoozed", "project:a", true),
shell("thread:a-awake", "project:a", false),
shell("thread:b-snoozed", "project:b", true),
];
const service = layerOrchestratorService.pipe(
Layer.provide(
Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
Layer.mock(ThreadManagementService.ThreadManagementService)({
listProjectThreads: (input) =>
Effect.succeed(
shells.filter(
(thread) => input.projectId === undefined || thread.projectId === input.projectId,
),
),
}),
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
list: () => Effect.succeed([]),
}),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
),
),
);
it.effect("lists snoozed threads across every project with allProjects", () =>
Effect.gen(function* () {
const mcp = yield* OrchestratorMcpService.OrchestratorMcpService;
const listed = yield* mcp.listThreads(client, {
allProjects: true,
projectId: ProjectId.make("project:a"),
snoozed: true,
});
assert.equal(listed.projectId, null);
assert.deepStrictEqual(
listed.threads.map((thread) => [thread.threadId, thread.projectId]),
[
["thread:a-snoozed", "project:a"],
["thread:b-snoozed", "project:b"],
],
);
}).pipe(Effect.provide(service)),
);
});
describe("OrchestratorMcpService thread stop", () => {
const driver = ProviderDriverKind.make("codex");
const instanceId = ProviderInstanceId.make("codex");
const modelSelection = { instanceId, model: "gpt-5.4" };
const threadId = ThreadId.make("thread:mcp-stop");
const client: McpInvocationScope = {
environmentId: EnvironmentId.make("environment:mcp-stop"),
requestNamespace: "client:mcp-stop",
thread: undefined,
client: { sessionId: "mcp-stop", label: "Claude Code", access: "full-access" },
capabilities: new Set(["orchestration"]),
issuedAt: 1,
};
// A provider whose turns run until they are interrupted.
const liveAdapter = (cwd: string): ProviderAdapter.ProviderAdapterV2["Service"] => ({
instanceId,
driver,
getCapabilities: () => Effect.succeed(CodexProviderCapabilitiesV2),
planSelectionTransition: () => Effect.succeed({ type: "apply_on_next_turn" }),
openSession: (input) =>
Effect.gen(function* () {
const now = yield* DateTime.now;
const events = yield* Queue.unbounded<ProviderAdapter.ProviderAdapterV2Event>();
return {
instanceId,
driver,
providerSessionId: input.providerSessionId,
providerSession: {
id: input.providerSessionId,
driver,
providerInstanceId: instanceId,
status: "ready",
cwd,
model: modelSelection.model,
capabilities: CodexProviderCapabilitiesV2,
createdAt: now,
updatedAt: now,
lastError: null,
},
events: Stream.fromQueue(events),
ensureThread: ({ threadId: appThreadId }) =>
Effect.succeed({
id: ProviderThreadId.make(`provider-thread:${appThreadId}`),
driver,
providerInstanceId: instanceId,
providerSessionId: input.providerSessionId,
appThreadId,
ownerNodeId: null,
nativeThreadRef: { driver, nativeId: `native:${appThreadId}`, strength: "strong" },
nativeConversationHeadRef: null,
status: "idle",
firstRunOrdinal: null,
lastRunOrdinal: null,
handoffIds: [],
forkedFrom: null,
createdAt: now,
updatedAt: now,
}),
resumeThread: ({ providerThread }) => Effect.succeed(providerThread),
startTurn: (turn) =>
Queue.offer(events, {
type: "provider_turn.updated",
driver,
providerTurn: {
id: ProviderTurnId.make(`provider-turn:${turn.attemptId}`),
providerThreadId: turn.providerThread.id,
nodeId: turn.rootNodeId,
runAttemptId: turn.attemptId,
nativeTurnRef: null,
ordinal: turn.providerTurnOrdinal,
status: "running",
startedAt: now,
completedAt: null,
},
}).pipe(Effect.asVoid),
steerTurn: () => Effect.die("unused"),
interruptTurn: () => Effect.void,
respondToRuntimeRequest: () => Effect.die("unused"),
readThreadSnapshot: () => Effect.die("unused"),
rollbackThread: () => Effect.die("unused"),
forkThread: () => Effect.die("unused"),
};
}),
});
it.effect.each([
{ name: "a running turn", queued: false },
{ name: "a running turn with a queued message", queued: true },
])("t3_thread_interrupt stop reports the run it interrupted on $name", ({ queued }) =>
Effect.scoped(
Effect.gen(function* () {
const cwd = yield* checkpointWorkspace("mcp-thread-stop");
const layerAdapters = ProviderAdapterRegistry.layerSingle(liveAdapter(cwd));
const layerDatabase = SqlitePersistence.layerMemory;
const layerOrchestrator = ProviderReplayHarness.layerWithRegistry(
{ name: "mcp-thread-stop" },
layerAdapters,
{ databaseLayer: layerDatabase, runEffectWorker: false },
);
const layerThreads = ThreadManagementService.layer.pipe(
Layer.provideMerge(layerOrchestrator),
Layer.provide(ServerSettings.layerTest()),
Layer.provide(CommandReceiptStore.layer.pipe(Layer.provide(layerDatabase))),
);
const layerTest = layerOrchestratorService.pipe(
Layer.provideMerge(layerThreads),
Layer.provide(
Layer.mergeAll(
NodeServices.layer,
NodeCrypto.layer,
layerAdapters,
ServerSettings.layerTest(),
Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
Layer.mock(ProjectService.ProjectService)({}),
Layer.mock(SecretRequests.SecretRequests)({}),
Layer.mock(RemoteDelegation.RemoteDelegation)({}),
Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
),
),
);
yield* Effect.gen(function* () {
const orchestrator = yield* Orchestrator.OrchestratorV2;
const worker = yield* EffectWorker.OrchestrationEffectWorkerV2;
const service = yield* OrchestratorMcpService.OrchestratorMcpService;
const send = (text: string, type: "start_immediately" | "queue_after_active") =>
orchestrator.dispatch({
type: "message.dispatch",
commandId: CommandId.make(`send:${text}`),
threadId,
messageId: MessageId.make(`message:${text}`),
text,
attachments: [],
dispatchMode: { type },
createdBy: "user",
creationSource: "web",
});
yield* orchestrator.dispatch({
type: "thread.create",
commandId: CommandId.make("create"),
threadId,
projectId: ProjectId.make("project:mcp-stop"),
title: "Stop",
modelSelection,
runtimeMode: "full-access",
interactionMode: "default",
branch: null,
worktreePath: cwd,
createdBy: "user",
creationSource: "web",
});
const running = yield* orchestrator.streamDomainEvents.pipe(
Stream.filter(
(event) =>
event.type === "provider-turn.updated" && event.payload.status === "running",
),
Stream.take(1),
Stream.runDrain,
Effect.forkScoped,
);
yield* send("work", "start_immediately");
yield* worker.drain();
yield* Fiber.join(running);
if (queued) yield* send("later", "queue_after_active");
const before = yield* orchestrator.getThreadProjection(threadId);
const runningRun = before.runs.find((run) => run.status === "running")!;
assert.equal(before.runs.filter((run) => run.status === "queued").length, queued ? 1 : 0);
const stopped = yield* service.interruptThread(client, {
threadId,
stop: true,
clientRequestId: "stop",
});
assert.deepEqual(stopped, {
threadId,
runId: runningRun.id,
status: "interrupt_requested",
});
}).pipe(Effect.provide(layerTest));
}),
),
);
});