Commit 06e627448bc1ee58487c1a2a9d6bf8d5ef479af3 | the-knife

apps/server/src/mcp/McpDeviceToolkit.test.ts+7-3

 @@ -19,9 +19,13 @@ const environmentId = EnvironmentId.make("environment-device-test");
 const threadId = ThreadId.make("thread-device-test");
 const invocation = (capabilities: ReadonlyArray<McpInvocationContext.McpCapability>) => ({
   environmentId,
-  threadId,
+  requestNamespace: "provider-session-device-test",
-  providerSessionId: "provider-session-device-test",
+  thread: {
-  providerInstanceId: ProviderInstanceId.make("codex"),
+    threadId,
+    providerSessionId: "provider-session-device-test",
+    providerInstanceId: ProviderInstanceId.make("codex"),
+  },
+  client: undefined,
   capabilities: new Set(capabilities),
   issuedAt: 1,
 });

apps/server/src/mcp/McpHttpServer.test.ts+7-3

 @@ -27,9 +27,13 @@ const alternateTabId = PreviewTabId.make("tab-mcp-alternate");
 const decodeJsonText = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
 const invocation = {
   environmentId,
-  threadId,
+  requestNamespace: "provider-session-mcp-test",
-  providerSessionId: "provider-session-mcp-test",
+  thread: {
-  providerInstanceId: ProviderInstanceId.make("codex"),
+    threadId,
+    providerSessionId: "provider-session-mcp-test",
+    providerInstanceId: ProviderInstanceId.make("codex"),
+  },
+  client: undefined,
   capabilities: new Set(["preview"] as const),
   issuedAt: 1,
 };

apps/server/src/mcp/McpInvocationContext.test.ts+42-10

 @@ -13,9 +13,13 @@ import * as McpInvocationContext from "./McpInvocationContext.ts";
 it.effect("reports the scoped credential context when preview capability is unavailable", () => {
   const invocation: McpInvocationContext.McpInvocationScope = {
     environmentId: EnvironmentId.make("environment-1"),
-    threadId: ThreadId.make("thread-1"),
+    requestNamespace: "provider-session-1",
-    providerSessionId: "provider-session-1",
+    thread: {
-    providerInstanceId: ProviderInstanceId.make("codex"),
+      threadId: ThreadId.make("thread-1"),
+      providerSessionId: "provider-session-1",
+      providerInstanceId: ProviderInstanceId.make("codex"),
+    },
+    client: undefined,
     capabilities: new Set(),
     issuedAt: 1,
   };
 @@ -30,9 +34,9 @@ it.effect("reports the scoped credential context when preview capability is unav
     expect(error).toMatchObject({
       capability: "preview",
       environmentId: invocation.environmentId,
-      threadId: invocation.threadId,
+      threadId: invocation.thread?.threadId,
-      providerSessionId: invocation.providerSessionId,
+      providerSessionId: invocation.thread?.providerSessionId,
-      providerInstanceId: invocation.providerInstanceId,
+      providerInstanceId: invocation.thread?.providerInstanceId,
     });
     expect(error.message).toContain("MCP credential does not grant the preview capability");
     expect(error.message).toContain("use a headless browser from the shell");
 @@ -42,9 +46,13 @@ it.effect("reports the scoped credential context when preview capability is unav
 it.effect("reports other missing capabilities with the neutral error", () => {
   const invocation: McpInvocationContext.McpInvocationScope = {
     environmentId: EnvironmentId.make("environment-1"),
-    threadId: ThreadId.make("thread-1"),
+    requestNamespace: "provider-session-1",
-    providerSessionId: "provider-session-1",
+    thread: {
-    providerInstanceId: ProviderInstanceId.make("codex"),
+      threadId: ThreadId.make("thread-1"),
+      providerSessionId: "provider-session-1",
+      providerInstanceId: ProviderInstanceId.make("codex"),
+    },
+    client: undefined,
     capabilities: new Set(["preview"]),
     issuedAt: 1,
   };
 @@ -56,7 +64,10 @@ it.effect("reports other missing capabilities with the neutral error", () => {
     );
     expect(error).toBeInstanceOf(McpCapabilityUnavailableError);
-    expect(error).toMatchObject({ capability: "pull-requests", threadId: invocation.threadId });
+    expect(error).toMatchObject({
+      capability: "pull-requests",
+      threadId: invocation.thread?.threadId,
+    });
     const scope = yield* McpInvocationContext.requireMcpCapability("preview").pipe(
       Effect.provideService(McpInvocationContext.McpInvocationContext, invocation),
 @@ -64,3 +75,24 @@ it.effect("reports other missing capabilities with the neutral error", () => {
     expect(scope).toBe(invocation);
   });
 });
+it.effect("refuses thread-owned capabilities to a caller signed in from outside a thread", () => {
+  const invocation: McpInvocationContext.McpInvocationScope = {
+    environmentId: EnvironmentId.make("environment-1"),
+    requestNamespace: "client:session-1",
+    thread: undefined,
+    client: { sessionId: "session-1", label: "Claude Code", runtimeModeCeiling: "auto" },
+    capabilities: new Set(["preview", "orchestration"]),
+    issuedAt: 1,
+  };
+  return Effect.gen(function* () {
+    const error = yield* McpInvocationContext.requireThreadMcpCapability("preview").pipe(
+      Effect.provideService(McpInvocationContext.McpInvocationContext, invocation),
+      Effect.flip,
+    );
+    expect(error).toBeInstanceOf(PreviewAutomationUnavailableError);
+    expect(error).toMatchObject({ capability: "preview", environmentId: "environment-1" });
+    expect(error.threadId).toBeUndefined();
+  });
+});

apps/server/src/mcp/McpInvocationContext.ts+64-5

...	@@ -1,8 +1,10 @@	...	@@ -1,8 +1,10 @@
1	import {	1	import {
2	type EnvironmentId,	2	type EnvironmentId,
3	McpCapabilityUnavailableError,	3	McpCapabilityUnavailableError,
		4	OrchestratorMcpFailure,
4	PreviewAutomationUnavailableError,	5	PreviewAutomationUnavailableError,
5	type ProviderInstanceId,	6	type ProviderInstanceId,
		7	type RuntimeMode,
6	type ThreadId,	8	type ThreadId,
7	} from "@t3tools/contracts";	9	} from "@t3tools/contracts";
8	import * as Context from "effect/Context";	10	import * as Context from "effect/Context";
...	@@ -17,13 +19,35 @@ const ALL_MCP_CAPABILITIES = [	...	@@ -17,13 +19,35 @@ const ALL_MCP_CAPABILITIES = [
17	] as const;	19	] as const;
18	export type McpCapability = (typeof ALL_MCP_CAPABILITIES)[number];	20	export type McpCapability = (typeof ALL_MCP_CAPABILITIES)[number];
19		21
20	export interface McpInvocationScope {	22	/** A provider session T3 Code launched for one thread. */
21	readonly environmentId: EnvironmentId;	23	export interface McpThreadCaller {
22	readonly threadId: ThreadId;	24	readonly threadId: ThreadId;
23	readonly providerSessionId: string;	25	readonly providerSessionId: string;
24	readonly providerInstanceId: ProviderInstanceId;	26	readonly providerInstanceId: ProviderInstanceId;
		27	}
		28
		29	/** An agent T3 Code did not launch, signed in through MCP OAuth. */
		30	export interface McpClientCaller {
		31	readonly sessionId: string;
		32	readonly label: string;
		33	readonly runtimeModeCeiling: RuntimeMode;
		34	}
		35
		36	/**
		37	* Who is calling and what they may do. Tool parameters choose the target
		38	* (thread, project); the caller sets the limits. A thread caller's omitted
		39	* target falls back to its own thread; a client caller has no own thread, so
		40	* tools that act as the caller (delegate_task, preview, worktree handoff)
		41	* need `thread`.
		42	*/
		43	export interface McpInvocationScope {
		44	readonly environmentId: EnvironmentId;
25	readonly capabilities: ReadonlySet<McpCapability>;	45	readonly capabilities: ReadonlySet<McpCapability>;
26	readonly issuedAt: number;	46	readonly issuedAt: number;
		47	/** Namespaces idempotency keys so two callers reusing a clientRequestId cannot collide. */
		48	readonly requestNamespace: string;
		49	readonly thread: McpThreadCaller \| undefined;
		50	readonly client: McpClientCaller \| undefined;
27	}	51	}
28		52
29	export class McpInvocationContext extends Context.Service<	53	export class McpInvocationContext extends Context.Service<
...	@@ -42,9 +66,13 @@ const missingCapability = (	...	@@ -42,9 +66,13 @@ const missingCapability = (
42	): PreviewAutomationUnavailableError \| McpCapabilityUnavailableError => {	66	): PreviewAutomationUnavailableError \| McpCapabilityUnavailableError => {
43	const fields = {	67	const fields = {
44	environmentId: invocation.environmentId,	68	environmentId: invocation.environmentId,
45	threadId: invocation.threadId,	69	...(invocation.thread === undefined
46	providerSessionId: invocation.providerSessionId,	70	? {}
47	providerInstanceId: invocation.providerInstanceId,	71	: {
		72	threadId: invocation.thread.threadId,
		73	providerSessionId: invocation.thread.providerSessionId,
		74	providerInstanceId: invocation.thread.providerInstanceId,
		75	}),
48	};	76	};
49	return capability === "preview"	77	return capability === "preview"
50	? new PreviewAutomationUnavailableError({ capability, ...fields })	78	? new PreviewAutomationUnavailableError({ capability, ...fields })
...	@@ -62,3 +90,34 @@ export const requireMcpCapability = <const C extends McpCapability>(	...	@@ -62,3 +90,34 @@ export const requireMcpCapability = <const C extends McpCapability>(
62	),	90	),
63	Effect.withSpan("mcp.requireCapability"),	91	Effect.withSpan("mcp.requireCapability"),
64	);	92	);
		93
		94	/**
		95	* Preview tabs and device sessions belong to the calling thread, so their
		96	* capabilities are only ever granted to thread callers. A scope that carries
		97	* one without a thread is refused the same way as a missing capability.
		98	*/
		99	export const requireThreadMcpCapability = <const C extends "preview" \| "device">(
		100	capability: C,
		101	): Effect.Effect<McpThreadInvocationScope, McpCapabilityError<C>, McpInvocationContext> =>
		102	McpInvocationContext.pipe(
		103	Effect.filterOrFail(
		104	(invocation): invocation is McpThreadInvocationScope =>
		105	invocation.capabilities.has(capability) && invocation.thread !== undefined,
		106	(invocation) => missingCapability(invocation, capability) as McpCapabilityError<C>,
		107	),
		108	Effect.withSpan("mcp.requireCapability"),
		109	);
		110
		111	const threadCallerRequired = (operation: string) =>
		112	new OrchestratorMcpFailure({
		113	code: "thread_credential_required",
		114	message: `${operation} acts as the calling T3 thread, so it needs an agent running inside T3 Code. This MCP client signed in from outside a thread.`,
		115	});
		116
		117	/** A scope with a thread caller, for tools whose whole surface acts as the caller. */
		118	export type McpThreadInvocationScope = McpInvocationScope & { readonly thread: McpThreadCaller };
		119
		120	export const requireThreadScope = (scope: McpInvocationScope, operation: string) =>
		121	scope.thread === undefined
		122	? Effect.fail(threadCallerRequired(operation))
		123	: Effect.succeed(scope as McpThreadInvocationScope);

apps/server/src/mcp/McpSessionRegistry.test.ts+2-2

...	@@ -47,7 +47,7 @@ it.effect("stores only a token hash, resolves the bearer token, and revokes by t	...	@@ -47,7 +47,7 @@ it.effect("stores only a token hash, resolves the bearer token, and revokes by t
47	expect(token.length).toBeGreaterThan(20);	47	expect(token.length).toBeGreaterThan(20);
48		48
49	const resolved = yield* registry.resolve(token);	49	const resolved = yield* registry.resolve(token);
50	expect(resolved?.threadId).toBe(threadId);	50	expect(resolved?.thread.threadId).toBe(threadId);
51	expect(resolved?.capabilities).toEqual(	51	expect(resolved?.capabilities).toEqual(
52	new Set(["preview", "orchestration", "worktree", "pull-requests"]),	52	new Set(["preview", "orchestration", "worktree", "pull-requests"]),
53	);	53	);
...	@@ -158,7 +158,7 @@ it.effect("keeps a credential alive across turns that never touch an MCP tool",	...	@@ -158,7 +158,7 @@ it.effect("keeps a credential alive across turns that never touch an MCP tool",
158	yield* registry.touch(threadId);	158	yield* registry.touch(threadId);
159	}	159	}
160		160
161	expect((yield* registry.resolve(token))?.threadId).toBe(threadId);	161	expect((yield* registry.resolve(token))?.thread.threadId).toBe(threadId);
162	}),	162	}),
163	);	163	);
164		164

apps/server/src/mcp/McpSessionRegistry.ts+16-11

 @@ -32,7 +32,7 @@ export interface McpSessionRegistryShape {
   readonly issue: (request: McpCredentialRequest) => Effect.Effect<McpIssuedCredential>;
   readonly resolve: (
     rawToken: string,
-  ) => Effect.Effect<McpInvocationContext.McpInvocationScope | undefined>;
+  ) => Effect.Effect<McpInvocationContext.McpThreadInvocationScope | undefined>;
   /**
    * Records a sign of life for every credential bound to `threadId`. Provider
    * turns call this so that a session which is plainly alive keeps its
 @@ -49,9 +49,10 @@ export class McpSessionRegistry extends Context.Service<
   McpSessionRegistryShape
 >()("t3/mcp/McpSessionRegistry") {}
+/** Registry credentials always belong to a provider session, so their scope has a thread. */
 interface CredentialRecord {
   readonly tokenHash: string;
-  readonly scope: McpInvocationContext.McpInvocationScope;
+  readonly scope: McpInvocationContext.McpThreadInvocationScope;
   readonly lastAliveAt: number;
 }
 @@ -127,11 +128,15 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (
       const rawToken = yield* crypto.randomBytes(32).pipe(Effect.map(tokenFromBytes), Effect.orDie);
       const tokenHash = yield* hashToken(rawToken);
       const browserToolsAvailable = request.browserToolsAvailable ?? true;
-      const scope: McpInvocationContext.McpInvocationScope = {
+      const scope: McpInvocationContext.McpThreadInvocationScope = {
         environmentId,
-        threadId: ThreadId.make(request.threadId),
+        requestNamespace: providerSessionId,
-        providerSessionId,
+        thread: {
-        providerInstanceId: ProviderInstanceId.make(request.providerInstanceId),
+          threadId: ThreadId.make(request.threadId),
+          providerSessionId,
+          providerInstanceId: ProviderInstanceId.make(request.providerInstanceId),
+        },
+        client: undefined,
         capabilities: new Set<McpInvocationContext.McpCapability>([
           "orchestration",
           "worktree",
 @@ -148,9 +153,9 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (
       return {
         config: {
           environmentId,
-          threadId: scope.threadId,
+          threadId: scope.thread.threadId,
           providerSessionId,
-          providerInstanceId: scope.providerInstanceId,
+          providerInstanceId: scope.thread.providerInstanceId,
           endpoint,
           authorizationHeader: `Bearer ${rawToken}`,
           browserToolsAvailable: scope.capabilities.has("preview"),
 @@ -183,7 +188,7 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (
         const current = pruneDead(records, timestamp);
         const next = new Map(current);
         for (const [tokenHash, record] of current) {
-          if (record.scope.threadId === threadId) {
+          if (record.scope.thread.threadId === threadId) {
             next.set(tokenHash, { ...record, lastAliveAt: timestamp });
           }
         }
 @@ -203,11 +208,11 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (
     touch,
     revokeProviderSession: Effect.fn("McpSessionRegistry.revokeProviderSession")(
       function* (providerSessionId) {
-        yield* revokeWhere((record) => record.scope.providerSessionId === providerSessionId);
+        yield* revokeWhere((record) => record.scope.thread.providerSessionId === providerSessionId);
       },
     ),
     revokeThread: Effect.fn("McpSessionRegistry.revokeThread")(function* (threadId) {
-      yield* revokeWhere((record) => record.scope.threadId === threadId);
+      yield* revokeWhere((record) => record.scope.thread.threadId === threadId);
     }),
     revokeAll: SynchronizedRef.set(state, { records: new Map() }),
   });

apps/server/src/mcp/OrchestratorMcpService.activity.test.ts+112-54

 @@ -2,10 +2,12 @@ import {
   EnvironmentId,
   NodeId,
   type OrchestrationV2ThreadProjection,
+  type OrchestrationV2ThreadShell,
   ProjectId,
   ProviderDriverKind,
   ProviderInstanceId,
   RunId,
+  ScheduledTaskId,
   ThreadId,
 } from "@t3tools/contracts";
 import * as DateTime from "effect/DateTime";
 @@ -16,6 +18,7 @@ import { expect, it } from "vite-plus/test";
 import * as ProviderAdapterRegistry from "../orchestration-v2/ProviderAdapterRegistry.ts";
 import * as ProviderRegistry from "../provider/Services/ProviderRegistry.ts";
+import * as ProjectService from "../project/ProjectService.ts";
 import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
 import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
 import type * as McpInvocationContext from "./McpInvocationContext.ts";
 @@ -37,9 +40,13 @@ const parentInstanceId = ProviderInstanceId.make("codex");
 const makeScope = (): McpInvocationContext.McpInvocationScope => ({
   environmentId,
-  threadId: parentThreadId,
+  requestNamespace: "provider-session-mcp-orchestrator-detail",
-  providerSessionId: "provider-session-mcp-orchestrator-detail",
+  thread: {
-  providerInstanceId: parentInstanceId,
+    threadId: parentThreadId,
+    providerSessionId: "provider-session-mcp-orchestrator-detail",
+    providerInstanceId: parentInstanceId,
+  },
+  client: undefined,
   capabilities: new Set(["orchestration"]),
   issuedAt: 1,
 });
 @@ -127,10 +134,21 @@ it("readThread prefers activity-run status over a newer cancelled queued run", a
             threadId === parentThreadId
               ? Effect.succeed(projection)
               : Effect.die(`unexpected thread ${threadId}`),
+          getThreadShell: (threadId) =>
+            Effect.succeed(
+              threadId === parentThreadId
+                ? (projection.thread as unknown as OrchestrationV2ThreadShell)
+                : null,
+            ),
+          getProjectThreadRecords: (input) =>
+            input.threadId === parentThreadId
+              ? Effect.succeed(projection)
+              : Effect.die(`unexpected thread ${input.threadId}`),
         } satisfies Partial<ThreadManagementService.ThreadManagementService["Service"]>),
         Layer.mock(ProviderRegistry.ProviderRegistry)({
           getProviders: Effect.succeed([]),
         } satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({
           list: () => Effect.succeed({ tasks: [] }),
         } satisfies Partial<ScheduledTaskService.ScheduledTaskService["Service"]>),
 @@ -180,10 +198,21 @@ it("readThread prefers waiting activity status over a newer cancelled queued run
             threadId === parentThreadId
               ? Effect.succeed(projection)
               : Effect.die(`unexpected thread ${threadId}`),
+          getThreadShell: (threadId) =>
+            Effect.succeed(
+              threadId === parentThreadId
+                ? (projection.thread as unknown as OrchestrationV2ThreadShell)
+                : null,
+            ),
+          getProjectThreadRecords: (input) =>
+            input.threadId === parentThreadId
+              ? Effect.succeed(projection)
+              : Effect.die(`unexpected thread ${input.threadId}`),
         } satisfies Partial<ThreadManagementService.ThreadManagementService["Service"]>),
         Layer.mock(ProviderRegistry.ProviderRegistry)({
           getProviders: Effect.succeed([]),
         } satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({
           list: () => Effect.succeed({ tasks: [] }),
         } satisfies Partial<ScheduledTaskService.ScheduledTaskService["Service"]>),
 @@ -295,6 +324,7 @@ it("taskStatus returns task.providerInstanceId rather than the driver kind", asy
         Layer.mock(ProviderRegistry.ProviderRegistry)({
           getProviders: Effect.succeed([]),
         } satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({
           list: () => Effect.succeed({ tasks: [] }),
         } satisfies Partial<ScheduledTaskService.ScheduledTaskService["Service"]>),
 @@ -317,34 +347,12 @@ it("taskStatus returns task.providerInstanceId rather than the driver kind", asy
   }).pipe(Effect.provide(layer), Effect.runPromise);
 });
-it("readThread reaches a thread the user attached as context, but not one an agent attached", async () => {
+it("readThread and sendToThread reach threads in other projects", async () => {
+  let parentRuns: ReadonlyArray<unknown> = [
+    makeRun({ id: RunId.make("run-parent-live"), ordinal: 1, status: "running" }),
+  ];
   const foreignProjectId = ProjectId.make("project-mcp-orchestrator-foreign");
   const foreignThreadId = ThreadId.make("thread-mcp-orchestrator-foreign");
-  const agentOnlyThreadId = ThreadId.make("thread-mcp-orchestrator-agent-only");
-  const threadRecord = (threadId: ThreadId) => ({
-    version: 1,
-    kind: "thread",
-    contextId: `thread_${threadId}`,
-    label: "Attached",
-    environmentId,
-    threadId,
-    title: "Attached",
-  });
-  const message = (input: { createdBy: "user" | "agent"; threadId: ThreadId }) => ({
-    id: `message-${input.threadId}`,
-    threadId: parentThreadId,
-    runId: null,
-    nodeId: null,
-    role: "user",
-    text: `[Attached](t3-context://v1/thread/thread_${input.threadId})`,
-    context: { version: 1, records: [threadRecord(input.threadId)] },
-    attachments: [],
-    streaming: false,
-    createdBy: input.createdBy,
-    creationSource: input.createdBy === "user" ? "user" : "mcp",
-    createdAt: now,
-    updatedAt: now,
-  });
   const parentProjection = {
     thread: baseThread({
       threadId: parentThreadId,
 @@ -352,13 +360,12 @@ it("readThread reaches a thread the user attached as context, but not one an age
       instanceId: parentInstanceId,
       model: "gpt-5.4",
     }),
-    runs: [],
+    get runs() {
+      return parentRuns;
+    },
     visibleTurnItems: [],
     runtimeRequests: [],
-    messages: [
+    messages: [],
-      message({ createdBy: "user", threadId: foreignThreadId }),
-      message({ createdBy: "agent", threadId: agentOnlyThreadId }),
-    ],
     contextTransfers: [],
     subagents: [],
     updatedAt: now,
 @@ -406,11 +413,15 @@ it("readThread reaches a thread the user attached as context, but not one an age
         Layer.mock(ThreadManagementService.ThreadManagementService)({
           getThreadRecords: (threadId) => {
             if (threadId === parentThreadId) return Effect.succeed(parentProjection);
-            if (threadId === foreignThreadId || threadId === agentOnlyThreadId) {
+            if (threadId === foreignThreadId) return Effect.succeed(foreignProjection(threadId));
-              return Effect.succeed(foreignProjection(threadId));
-            }
             return Effect.die(`unexpected thread ${threadId}`);
           },
+          getThreadShell: (threadId) =>
+            Effect.succeed(
+              threadId === foreignThreadId
+                ? (foreignProjection(threadId).thread as unknown as OrchestrationV2ThreadShell)
+                : null,
+            ),
           getTimelinePage: (threadId) =>
             Effect.succeed({
               items: foreignProjection(threadId).visibleTurnItems,
 @@ -418,18 +429,36 @@ it("readThread reaches a thread the user attached as context, but not one an age
               hasMore: false,
             }),
           getProjectThreadRecords: (input) =>
-            Effect.fail(
+            input.threadId === foreignThreadId && input.projectId === foreignProjectId
-              new ThreadManagementService.ThreadManagementThreadNotFoundError({
+              ? Effect.succeed(foreignProjection(input.threadId))
-                projectId: input.projectId,
+              : Effect.fail(
-                threadId: input.threadId,
+                  new ThreadManagementService.ThreadManagementThreadNotFoundError({
-              }),
+                    projectId: input.projectId,
-            ),
+                    threadId: input.threadId,
+                  }),
+                ),
+          sendToThread: () =>
+            Effect.succeed({
+              run: { id: "run-foreign", status: "queued" },
+              delivery: "started",
+            } as unknown as ThreadManagementService.ThreadManagementSendResult),
         } satisfies Partial<ThreadManagementService.ThreadManagementService["Service"]>),
         Layer.mock(ProviderRegistry.ProviderRegistry)({
           getProviders: Effect.succeed([]),
         } satisfies Partial<ProviderRegistry.ProviderRegistry["Service"]>),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({
-          list: () => Effect.succeed({ tasks: [] }),
+          list: () =>
+            Effect.succeed({
+              tasks: [
+                {
+                  id: "task-foreign",
+                  projectId: foreignProjectId,
+                  runtimeMode: "approval-required",
+                  interactionMode: "default",
+                } as never,
+              ],
+            }),
         } satisfies Partial<ScheduledTaskService.ScheduledTaskService["Service"]>),
         Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
           list: () => Effect.succeed([]),
 @@ -441,18 +470,47 @@ it("readThread reaches a thread the user attached as context, but not one an age
   await Effect.gen(function* () {
     const service = yield* OrchestratorMcpService.OrchestratorMcpService;
-    const attached = yield* service.readThread(makeScope(), { threadId: foreignThreadId });
+    const foreign = yield* service.readThread(makeScope(), { threadId: foreignThreadId });
-    expect(attached.thread.threadId).toBe(foreignThreadId);
+    expect(foreign.thread.threadId).toBe(foreignThreadId);
-    expect(attached.items.map((item) => item.text)).toEqual(["Foreign thread said hello"]);
+    expect(foreign.thread.projectId).toBe(foreignProjectId);
+    expect(foreign.items.map((item) => item.text)).toEqual(["Foreign thread said hello"]);
-    const denied = yield* service
+    const sent = yield* service.sendToThread(makeScope(), {
-      .readThread(makeScope(), { threadId: agentOnlyThreadId })
+      threadId: foreignThreadId,
-      .pipe(Effect.flip);
+      message: "hi",
-    expect(denied.code).toBe("thread_not_found");
+    });
+    expect(sent.threadId).toBe(foreignThreadId);
-    const write = yield* service
+    // Once the caller's run ends, it can still read other threads but no longer write to them.
-      .sendToThread(makeScope(), { threadId: foreignThreadId, message: "hi" })
+    parentRuns = [];
+    yield* service.readThread(makeScope(), { threadId: foreignThreadId });
+    const stale = yield* service
+      .sendToThread(makeScope(), { threadId: foreignThreadId, message: "hi again" })
+      .pipe(Effect.flip);
+    expect(stale.code).toBe("parent_not_active");
+    const staleInterrupt = yield* service
+      .interruptThread(makeScope(), { threadId: foreignThreadId })
+      .pipe(Effect.flip);
+    expect(staleInterrupt.code).toBe("parent_not_active");
+    // Nor create, change or remove scheduled work in another project.
+    const staleSchedule = yield* service
+      .scheduleTask(makeScope(), {
+        projectId: foreignProjectId,
+        prompt: "check in later",
+        schedule: { type: "interval", everyMs: 3_600_000 },
+      })
+      .pipe(Effect.flip);
+    expect(staleSchedule.code).toBe("parent_not_active");
+    const staleUpdate = yield* service
+      .updateScheduledTask(makeScope(), {
+        scheduledTaskId: ScheduledTaskId.make("task-foreign"),
+        enabled: false,
+      })
+      .pipe(Effect.flip);
+    expect(staleUpdate.code).toBe("parent_not_active");
+    const staleDelete = yield* service
+      .deleteScheduledTask(makeScope(), { scheduledTaskId: ScheduledTaskId.make("task-foreign") })
       .pipe(Effect.flip);
-    expect(write.code).toBe("thread_not_found");
+    expect(staleDelete.code).toBe("parent_not_active");
   }).pipe(Effect.provide(layer), Effect.runPromise);
 });

apps/server/src/mcp/OrchestratorMcpService.test.ts+53-18

 @@ -22,6 +22,7 @@ import * as ProviderAdapterRegistry from "../orchestration-v2/ProviderAdapterReg
 import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
 import * as ProviderRegistry from "../provider/Services/ProviderRegistry.ts";
 import { buildUnavailableProviderSnapshot } from "../provider/unavailableProviderSnapshot.ts";
+import * as ProjectService from "../project/ProjectService.ts";
 import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
 import type { McpInvocationScope } from "./McpInvocationContext.ts";
 import * as OrchestratorMcpService from "./OrchestratorMcpService.ts";
 @@ -118,13 +119,18 @@ describe("OrchestratorMcpService", () => {
         Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
           list: () => Effect.succeed([]),
         }),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
       const scope: McpInvocationScope = {
         environmentId: EnvironmentId.make("environment:mcp-ack"),
-        threadId: parentThreadId,
+        requestNamespace: "provider-session:mcp-ack",
-        providerSessionId: "provider-session:mcp-ack",
+        thread: {
-        providerInstanceId: ProviderInstanceId.make("codex"),
+          threadId: parentThreadId,
+          providerSessionId: "provider-session:mcp-ack",
+          providerInstanceId: ProviderInstanceId.make("codex"),
+        },
+        client: undefined,
         capabilities: new Set(["orchestration"]),
         issuedAt: 1,
       };
 @@ -202,13 +208,18 @@ describe("OrchestratorMcpService", () => {
         Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
           list: () => Effect.succeed([]),
         }),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
       const scope: McpInvocationScope = {
         environmentId: EnvironmentId.make("environment:mcp-restart"),
-        threadId: parentThreadId,
+        requestNamespace: "provider-session:mcp-restart",
-        providerSessionId: "provider-session:mcp-restart",
+        thread: {
-        providerInstanceId: ProviderInstanceId.make("codex"),
+          threadId: parentThreadId,
+          providerSessionId: "provider-session:mcp-restart",
+          providerInstanceId: ProviderInstanceId.make("codex"),
+        },
+        client: undefined,
         capabilities: new Set(["orchestration"]),
         issuedAt: 1,
       };
 @@ -278,13 +289,18 @@ describe("OrchestratorMcpService", () => {
         Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
           list: () => Effect.succeed([]),
         }),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
       const scope: McpInvocationScope = {
         environmentId: EnvironmentId.make("environment:mcp-cancel"),
-        threadId: parentThreadId,
+        requestNamespace: "provider-session:mcp-cancel",
-        providerSessionId: "provider-session:mcp-cancel",
+        thread: {
-        providerInstanceId: ProviderInstanceId.make("codex"),
+          threadId: parentThreadId,
+          providerSessionId: "provider-session:mcp-cancel",
+          providerInstanceId: ProviderInstanceId.make("codex"),
+        },
+        client: undefined,
         capabilities: new Set(["orchestration"]),
         issuedAt: 1,
       };
 @@ -346,13 +362,18 @@ describe("OrchestratorMcpService", () => {
         Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
           list: () => Effect.succeed([]),
         }),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
       const scope: McpInvocationScope = {
         environmentId: EnvironmentId.make("environment:mcp-cancel-failed"),
-        threadId: parentThreadId,
+        requestNamespace: "provider-session:mcp-cancel-failed",
-        providerSessionId: "provider-session:mcp-cancel-failed",
+        thread: {
-        providerInstanceId: ProviderInstanceId.make("codex"),
+          threadId: parentThreadId,
+          providerSessionId: "provider-session:mcp-cancel-failed",
+          providerInstanceId: ProviderInstanceId.make("codex"),
+        },
+        client: undefined,
         capabilities: new Set(["orchestration"]),
         issuedAt: 1,
       };
 @@ -421,13 +442,18 @@ describe("OrchestratorMcpService", () => {
         Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
           list: () => Effect.succeed([]),
         }),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
       const scope: McpInvocationScope = {
         environmentId: EnvironmentId.make("environment:mcp-cancel-dispose-failed"),
-        threadId: parentThreadId,
+        requestNamespace: "provider-session:mcp-cancel-dispose-failed",
-        providerSessionId: "provider-session:mcp-cancel-dispose-failed",
+        thread: {
-        providerInstanceId: ProviderInstanceId.make("codex"),
+          threadId: parentThreadId,
+          providerSessionId: "provider-session:mcp-cancel-dispose-failed",
+          providerInstanceId: ProviderInstanceId.make("codex"),
+        },
+        client: undefined,
         capabilities: new Set(["orchestration"]),
         issuedAt: 1,
       };
 @@ -460,9 +486,13 @@ describe("OrchestratorMcpService provider resolution", () => {
   const scope: McpInvocationScope = {
     environmentId: EnvironmentId.make("environment:mcp-providers"),
-    threadId: parentThreadId,
+    requestNamespace: "provider-session:mcp-providers",
-    providerSessionId: "provider-session:mcp-providers",
+    thread: {
-    providerInstanceId: codexInstanceId,
+      threadId: parentThreadId,
+      providerSessionId: "provider-session:mcp-providers",
+      providerInstanceId: codexInstanceId,
+    },
+    client: undefined,
     capabilities: new Set(["orchestration"]),
     issuedAt: 1,
   };
 @@ -613,6 +643,7 @@ describe("OrchestratorMcpService provider resolution", () => {
             antigravityInstanceId,
             disabledAntigravityInstanceId,
           ]),
+          Layer.mock(ProjectService.ProjectService)({}),
           Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
         );
 @@ -756,6 +787,7 @@ describe("OrchestratorMcpService provider resolution", () => {
             ]),
           }),
           adapterRegistryLayer([codexInstanceId, antigravityInstanceId]),
+          Layer.mock(ProjectService.ProjectService)({}),
           Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
         );
 @@ -849,6 +881,7 @@ describe("OrchestratorMcpService provider resolution", () => {
           ]),
         }),
         adapterRegistryLayer([codexInstanceId, antigravityInstanceId]),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
 @@ -897,6 +930,7 @@ describe("OrchestratorMcpService provider resolution", () => {
           ]),
         }),
         adapterRegistryLayer([codexInstanceId]),
+        Layer.mock(ProjectService.ProjectService)({}),
         Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
       );
 @@ -1060,6 +1094,7 @@ describe("OrchestratorMcpService provider resolution", () => {
               ]),
             }),
             adapterRegistryLayer([codexInstanceId, codexAltInstanceId]),
+            Layer.mock(ProjectService.ProjectService)({}),
             Layer.mock(ScheduledTaskService.ScheduledTaskService)({}),
           );

apps/server/src/mcp/OrchestratorMcpService.ts+283-128

...	@@ -29,6 +29,8 @@ import {	...	@@ -29,6 +29,8 @@ import {
29	type OrchestratorMcpTaskCancelInput,	29	type OrchestratorMcpTaskCancelInput,
30	type OrchestratorMcpTaskCancelResult,	30	type OrchestratorMcpTaskCancelResult,
31	type OrchestratorMcpUpdateScheduledTaskInput,	31	type OrchestratorMcpUpdateScheduledTaskInput,
		32	type OrchestratorMcpListScheduledTasksInput,
		33	type ProjectId,
32	type OrchestratorMcpThreadDetail,	34	type OrchestratorMcpThreadDetail,
33	type OrchestratorMcpThreadInterruptInput,	35	type OrchestratorMcpThreadInterruptInput,
34	type OrchestratorMcpThreadInterruptResult,	36	type OrchestratorMcpThreadInterruptResult,
...	@@ -68,9 +70,14 @@ import {	...	@@ -68,9 +70,14 @@ import {
68	delegatedTaskProgress,	70	delegatedTaskProgress,
69	} from "../orchestration-v2/SubagentProjection.ts";	71	} from "../orchestration-v2/SubagentProjection.ts";
70	import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";	72	import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
		73	import * as ProjectService from "../project/ProjectService.ts";
71	import * as ProviderRegistry from "../provider/Services/ProviderRegistry.ts";	74	import * as ProviderRegistry from "../provider/Services/ProviderRegistry.ts";
72	import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";	75	import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
73	import type { McpInvocationScope } from "./McpInvocationContext.ts";	76	import {
		77	type McpInvocationScope,
		78	type McpThreadInvocationScope,
		79	requireThreadScope,
		80	} from "./McpInvocationContext.ts";
74		81
75	const DEFAULT_WAIT_TIMEOUT_MS = 10 * 60 * 1_000;	82	const DEFAULT_WAIT_TIMEOUT_MS = 10 * 60 * 1_000;
76	const MAX_WAIT_TIMEOUT_MS = 60 * 60 * 1_000;	83	const MAX_WAIT_TIMEOUT_MS = 60 * 60 * 1_000;
...	@@ -115,6 +122,7 @@ export interface OrchestratorMcpServiceShape {	...	@@ -115,6 +122,7 @@ export interface OrchestratorMcpServiceShape {
115	) => Effect.Effect<OrchestratorMcpScheduleTaskResult, OrchestratorMcpFailure>;	122	) => Effect.Effect<OrchestratorMcpScheduleTaskResult, OrchestratorMcpFailure>;
116	readonly listScheduledTasks: (	123	readonly listScheduledTasks: (
117	scope: McpInvocationScope,	124	scope: McpInvocationScope,
		125	input: OrchestratorMcpListScheduledTasksInput,
118	) => Effect.Effect<OrchestratorMcpListScheduledTasksResult, OrchestratorMcpFailure>;	126	) => Effect.Effect<OrchestratorMcpListScheduledTasksResult, OrchestratorMcpFailure>;
119	readonly updateScheduledTask: (	127	readonly updateScheduledTask: (
120	scope: McpInvocationScope,	128	scope: McpInvocationScope,
...	@@ -486,7 +494,7 @@ function stableCommandId(input: {	...	@@ -486,7 +494,7 @@ function stableCommandId(input: {
486	[	494	[
487	"command",	495	"command",
488	"mcp",	496	"mcp",
489	stablePart(input.scope.providerSessionId),	497	stablePart(input.scope.requestNamespace),
490	stablePart(input.operation),	498	stablePart(input.operation),
491	stablePart(input.requestKey),	499	stablePart(input.requestKey),
492	...(input.index === undefined ? [] : [String(input.index)]),	500	...(input.index === undefined ? [] : [String(input.index)]),
...	@@ -503,7 +511,7 @@ function stableThreadId(input: {	...	@@ -503,7 +511,7 @@ function stableThreadId(input: {
503	[	511	[
504	"thread",	512	"thread",
505	"mcp",	513	"mcp",
506	stablePart(input.scope.providerSessionId),	514	stablePart(input.scope.requestNamespace),
507	stablePart(input.requestKey),	515	stablePart(input.requestKey),
508	String(input.index),	516	String(input.index),
509	].join(":"),	517	].join(":"),
...	@@ -519,7 +527,7 @@ function stableMessageId(input: {	...	@@ -519,7 +527,7 @@ function stableMessageId(input: {
519	[	527	[
520	"message",	528	"message",
521	"mcp",	529	"mcp",
522	stablePart(input.scope.providerSessionId),	530	stablePart(input.scope.requestNamespace),
523	stablePart(input.requestKey),	531	stablePart(input.requestKey),
524	String(input.index),	532	String(input.index),
525	].join(":"),	533	].join(":"),
...	@@ -535,7 +543,7 @@ function stableOperationMessageId(input: {	...	@@ -535,7 +543,7 @@ function stableOperationMessageId(input: {
535	[	543	[
536	"message",	544	"message",
537	"mcp",	545	"mcp",
538	stablePart(input.scope.providerSessionId),	546	stablePart(input.scope.requestNamespace),
539	stablePart(input.operation),	547	stablePart(input.operation),
540	stablePart(input.requestKey),	548	stablePart(input.requestKey),
541	].join(":"),	549	].join(":"),
...	@@ -760,6 +768,35 @@ const make = Effect.gen(function* () {	...	@@ -760,6 +768,35 @@ const make = Effect.gen(function* () {
760	const providerRegistry = yield* ProviderRegistry.ProviderRegistry;	768	const providerRegistry = yield* ProviderRegistry.ProviderRegistry;
761	const providerAdapters = yield* ProviderAdapterRegistry.ProviderAdapterRegistryV2;	769	const providerAdapters = yield* ProviderAdapterRegistry.ProviderAdapterRegistryV2;
762	const scheduledTasks = yield* ScheduledTaskService.ScheduledTaskService;	770	const scheduledTasks = yield* ScheduledTaskService.ScheduledTaskService;
		771	const projects = yield* ProjectService.ProjectService;
		772
		773	/** A caller-named project, which must exist before anything is recorded against it. */
		774	const requireProject = (projectId: ProjectId) =>
		775	projects.getById(projectId).pipe(
		776	Effect.mapError((error) =>
		777	failure("orchestration_error", `Unable to read project ${projectId}: ${error.message}`),
		778	),
		779	Effect.flatMap(
		780	Option.match({
		781	onNone: () =>
		782	Effect.fail(failure("invalid_request", `Project ${projectId} was not found.`)),
		783	onSome: Effect.succeed,
		784	}),
		785	),
		786	);
		787
		788	/** A client has no thread to inherit a model from, so it falls back to the project default. */
		789	const projectDefaultModelSelection = (
		790	project: Effect.Success<ReturnType<typeof requireProject>>,
		791	) =>
		792	project.defaultModelSelection === null
		793	? Effect.fail(
		794	failure(
		795	"invalid_request",
		796	`Project ${project.id} has no default model, so this caller cannot pick one for it.`,
		797	),
		798	)
		799	: Effect.succeed(project.defaultModelSelection);
763		800
764	const requireCapability = (scope: McpInvocationScope) =>	801	const requireCapability = (scope: McpInvocationScope) =>
765	scope.capabilities.has("orchestration")	802	scope.capabilities.has("orchestration")
...	@@ -817,61 +854,133 @@ const make = Effect.gen(function* () {	...	@@ -817,61 +854,133 @@ const make = Effect.gen(function* () {
817	)	854	)
818	.pipe(Effect.mapError(threadManagementFailure));	855	.pipe(Effect.mapError(threadManagementFailure));
819		856
820	const loadScopedThread = (scope: McpInvocationScope, threadId: ThreadId) =>	857	/**
		858	* The caller's own thread and the most it may hand to threads it targets. A
		859	* thread caller is capped by its own modes; an OAuth client by the ceiling
		860	* chosen when it was approved.
		861	*/
		862	const loadCaller = (scope: McpInvocationScope) =>
821	Effect.gen(function* () {	863	Effect.gen(function* () {
822	yield* requireCapability(scope);	864	yield* requireCapability(scope);
823	const parent = yield* loadProjection(scope.threadId);	865	if (scope.thread === undefined) {
		866	return {
		867	parent: undefined,
		868	limits: {
		869	runtimeMode: scope.client?.runtimeModeCeiling ?? "approval-required",
		870	interactionMode: "default",
		871	} satisfies { runtimeMode: RuntimeMode; interactionMode: ProviderInteractionMode },
		872	} as const;
		873	}
		874	const parent = yield* loadProjection(scope.thread.threadId);
		875	return {
		876	parent,
		877	limits: {
		878	runtimeMode: parent.thread.runtimeMode,
		879	interactionMode: parent.thread.interactionMode,
		880	},
		881	} as const;
		882	});
		883
		884	/** The caller's own thread, for operations that act as the caller. */
		885	const loadThreadCaller = (scope: McpInvocationScope, operation: string) =>
		886	Effect.gen(function* () {
		887	yield* requireCapability(scope);
		888	const threadScope = yield* requireThreadScope(scope, operation);
		889	const parent = yield* loadProjection(threadScope.thread.threadId);
		890	return { scope: threadScope, parent } as const;
		891	});
		892
		893	/** A target project: the one passed, else the calling thread's. */
		894	const resolveProjectTarget = (
		895	parent: Pick<OrchestrationV2ThreadProjection, "thread"> \| undefined,
		896	projectId: ProjectId \| undefined,
		897	) =>
		898	projectId !== undefined
		899	? Effect.succeed(projectId)
		900	: parent !== undefined
		901	? Effect.succeed(parent.thread.projectId)
		902	: Effect.fail(
		903	failure(
		904	"target_required",
		905	"Pass projectId: this MCP client is not running inside a T3 thread.",
		906	),
		907	);
		908
		909	/** Any live thread in the environment. */
		910	const loadTargetThread = (threadId: ThreadId) =>
		911	Effect.gen(function* () {
		912	const shell = yield* threadManagement
		913	.getThreadShell(threadId)
		914	.pipe(Effect.mapError(threadManagementFailure));
		915	if (shell === null \|\| shell.deletedAt !== null) {
		916	return yield* failure("thread_not_found", `Thread ${threadId} was not found.`);
		917	}
		918	return yield* loadProjectThread(shell.projectId, threadId);
		919	});
		920
		921	const loadScopedThread = (scope: McpInvocationScope, threadId: ThreadId) =>
		922	Effect.gen(function* () {
		923	const caller = yield* loadCaller(scope);
824	const target =	924	const target =
825	threadId === scope.threadId	925	caller.parent !== undefined && threadId === caller.parent.thread.id
826	? parent	926	? caller.parent
827	: yield* loadProjectThread(parent.thread.projectId, threadId);	927	: yield* loadTargetThread(threadId);
828	return { parent, target } as const;	928	return { ...caller, target } as const;
829	});	929	});
830		930
831	/**	931	/**
832	* A thread the user attached as context (a `thread` record on one of their own messages)	932	* A thread caller writes to another thread only while its own run is live,
833	* is readable even outside the calling project. Only records the user authored count:	933	* so a credential that outlived its session cannot reach across threads.
834	* an agent cannot widen its own reach by writing a record.
835	*/	934	*/
836	const userAttachedThreadIds = (	935	const assertLiveCallerForOtherThread = (
837	parent: Pick<OrchestrationV2ThreadProjection, "messages">,	936	scope: McpInvocationScope,
838	): Set<ThreadId> => {	937	parent: Pick<OrchestrationV2ThreadProjection, "thread" \| "runs"> \| undefined,
839	const ids = new Set<ThreadId>();	938	target: Pick<OrchestrationV2ThreadProjection, "thread">,
840	for (const message of parent.messages) {	939	) =>
841	if (message.role !== "user" \|\| message.createdBy !== "user") continue;	940	parent === undefined \|\| target.thread.id === parent.thread.id
842	for (const record of message.context?.records ?? []) {	941	? Effect.void
843	if (record.kind === "thread" && "threadId" in record) ids.add(record.threadId);	942	: assertLiveCaller(scope, parent);
844	}	943
845	}	944	/** Scheduled work outside the caller's own project needs the same live run. */
846	return ids;	945	const assertLiveCallerForOtherProject = (
		946	scope: McpInvocationScope,
		947	parent: Pick<OrchestrationV2ThreadProjection, "thread" \| "runs"> \| undefined,
		948	projectId: ProjectId,
		949	) =>
		950	parent === undefined \|\| projectId === parent.thread.projectId
		951	? Effect.void
		952	: assertLiveCaller(scope, parent);
		953
		954	const assertLiveCaller = (
		955	scope: McpInvocationScope,
		956	parent: Pick<OrchestrationV2ThreadProjection, "thread" \| "runs">,
		957	) => {
		958	const activeRun = ThreadManagementService.latestActiveRun(parent);
		959	return parent.thread.archivedAt !== null \|\|
		960	activeRun === undefined \|\|
		961	activeRun.providerInstanceId !== scope.thread?.providerInstanceId
		962	? Effect.fail(
		963	failure("parent_not_active", "The calling provider no longer owns an active thread run."),
		964	)
		965	: Effect.void;
847	};	966	};
848		967
849	const loadReadableThread = (scope: McpInvocationScope, threadId: ThreadId) =>	968	const loadReadableThread = (scope: McpInvocationScope, threadId: ThreadId) =>
850	Effect.gen(function* () {	969	Effect.gen(function* () {
851	yield* requireCapability(scope);	970	const { parent } = yield* loadCaller(scope);
852	const parent = yield* loadProjection(scope.threadId);	971	const shell = yield* threadManagement
853	const loadTarget = () =>	972	.getThreadShell(threadId)
854	threadManagement	973	.pipe(Effect.mapError(threadManagementFailure));
855	.getThreadRecords(threadId, ["runs", "runtimeRequests", "contextTransfers"])	974	if (shell === null \|\| shell.deletedAt !== null) {
856	.pipe(Effect.mapError(threadManagementFailure));	975	return yield* failure("thread_not_found", `Thread ${threadId} is no longer available.`);
857	if (threadId === scope.threadId) return { parent, target: yield* loadTarget() } as const;	976	}
858	const target = yield* threadManagement	977	const target = yield* threadManagement
859	.getProjectThreadRecords({ projectId: parent.thread.projectId, threadId }, [	978	.getProjectThreadRecords({ projectId: shell.projectId, threadId }, [
860	"runs",	979	"runs",
861	"runtimeRequests",	980	"runtimeRequests",
862	"contextTransfers",	981	"contextTransfers",
863	])	982	])
864	.pipe(	983	.pipe(Effect.mapError(threadManagementFailure));
865	Effect.mapError(threadManagementFailure),
866	Effect.catchIf(
867	(error) =>
868	error.code === "thread_not_found" && userAttachedThreadIds(parent).has(threadId),
869	loadTarget,
870	),
871	);
872	if (target.thread.deletedAt !== null) {
873	return yield* failure("thread_not_found", `Thread ${threadId} is no longer available.`);
874	}
875	return { parent, target } as const;	984	return { parent, target } as const;
876	});	985	});
877		986
...	@@ -1010,7 +1119,7 @@ const make = Effect.gen(function* () {	...	@@ -1010,7 +1119,7 @@ const make = Effect.gen(function* () {
1010	: Effect.succeed(clientRequestId);	1119	: Effect.succeed(clientRequestId);
1011		1120
1012	const readTask = (	1121	const readTask = (
1013	scope: McpInvocationScope,	1122	scope: McpThreadInvocationScope,
1014	taskId: NodeId,	1123	taskId: NodeId,
1015	waitTimedOut = false,	1124	waitTimedOut = false,
1016	acknowledgeTerminal = false,	1125	acknowledgeTerminal = false,
...	@@ -1018,17 +1127,17 @@ const make = Effect.gen(function* () {	...	@@ -1018,17 +1127,17 @@ const make = Effect.gen(function* () {
1018	): Effect.Effect<OrchestratorMcpDelegateTaskResult, OrchestratorMcpFailure> =>	1127	): Effect.Effect<OrchestratorMcpDelegateTaskResult, OrchestratorMcpFailure> =>
1019	Effect.gen(function* () {	1128	Effect.gen(function* () {
1020	yield* requireCapability(scope);	1129	yield* requireCapability(scope);
1021	const parentProjection = yield* loadProjection(scope.threadId);	1130	const parentProjection = yield* loadProjection(scope.thread.threadId);
1022	const task = parentProjection.subagents.find(	1131	const task = parentProjection.subagents.find(
1023	(candidate) =>	1132	(candidate) =>
1024	candidate.id === taskId &&	1133	candidate.id === taskId &&
1025	candidate.origin === "app_owned" &&	1134	candidate.origin === "app_owned" &&
1026	candidate.threadId === scope.threadId,	1135	candidate.threadId === scope.thread.threadId,
1027	);	1136	);
1028	if (task === undefined \|\| task.childThreadId === null) {	1137	if (task === undefined \|\| task.childThreadId === null) {
1029	return yield* failure(	1138	return yield* failure(
1030	"task_not_found",	1139	"task_not_found",
1031	`Delegated task ${taskId} does not belong to thread ${scope.threadId}.`,	1140	`Delegated task ${taskId} does not belong to thread ${scope.thread.threadId}.`,
1032	);	1141	);
1033	}	1142	}
1034	const childControls = yield* threadManagement	1143	const childControls = yield* threadManagement
...	@@ -1094,7 +1203,7 @@ const make = Effect.gen(function* () {	...	@@ -1094,7 +1203,7 @@ const make = Effect.gen(function* () {
1094	(transfer) =>	1203	(transfer) =>
1095	transfer.type === "subagent_result" &&	1204	transfer.type === "subagent_result" &&
1096	transfer.sourceThreadId === task.childThreadId &&	1205	transfer.sourceThreadId === task.childThreadId &&
1097	transfer.targetThreadId === scope.threadId,	1206	transfer.targetThreadId === scope.thread.threadId,
1098	);	1207	);
1099	const resultTransferForRun = (run: OrchestrationV2Run \| undefined) =>	1208	const resultTransferForRun = (run: OrchestrationV2Run \| undefined) =>
1100	!canExposeTaskRunResult(run)	1209	!canExposeTaskRunResult(run)
...	@@ -1145,10 +1254,10 @@ const make = Effect.gen(function* () {	...	@@ -1145,10 +1254,10 @@ const make = Effect.gen(function* () {
1145	requestKey: acknowledgementRequestKey,	1254	requestKey: acknowledgementRequestKey,
1146	operation: acknowledgementOperation,	1255	operation: acknowledgementOperation,
1147	}),	1256	}),
1148	parentThreadId: scope.threadId,	1257	parentThreadId: scope.thread.threadId,
1149	taskId,	1258	taskId,
1150	observedByRunId:	1259	observedByRunId:
1151	observingRun?.providerInstanceId === scope.providerInstanceId	1260	observingRun?.providerInstanceId === scope.thread.providerInstanceId
1152	? observingRun.id	1261	? observingRun.id
1153	: null,	1262	: null,
1154	})	1263	})
...	@@ -1164,7 +1273,7 @@ const make = Effect.gen(function* () {	...	@@ -1164,7 +1273,7 @@ const make = Effect.gen(function* () {
1164	return response;	1273	return response;
1165	});	1274	});
1166		1275
1167	const waitForTask = (scope: McpInvocationScope, taskId: NodeId, timeoutMs: number) =>	1276	const waitForTask = (scope: McpThreadInvocationScope, taskId: NodeId, timeoutMs: number) =>
1168	Effect.gen(function* () {	1277	Effect.gen(function* () {
1169	while (true) {	1278	while (true) {
1170	const result = yield* readTask(scope, taskId, false, true);	1279	const result = yield* readTask(scope, taskId, false, true);
...	@@ -1173,11 +1282,17 @@ const make = Effect.gen(function* () {	...	@@ -1173,11 +1282,17 @@ const make = Effect.gen(function* () {
1173	}	1282	}
1174	}).pipe(Effect.timeoutOption(Duration.millis(timeoutMs)));	1283	}).pipe(Effect.timeoutOption(Duration.millis(timeoutMs)));
1175		1284
1176	// Load a single scheduled task and enforce that it belongs to the calling	1285	/**
1177	// thread's project, so agents can only read/mutate tasks in their own scope.	1286	* A scheduled task the caller may change: one whose modes are no broader
1178	const loadScopedScheduledTask = (	1287	* than the caller's own, so editing its prompt cannot run work above the
1179	projectId: ScheduledTask["projectId"],	1288	* caller's limits.
		1289	*/
		1290	const loadScheduledTask = (
1180	scheduledTaskId: ScheduledTask["id"],	1291	scheduledTaskId: ScheduledTask["id"],
		1292	limits: {
		1293	readonly runtimeMode: RuntimeMode;
		1294	readonly interactionMode: ProviderInteractionMode;
		1295	},
1181	): Effect.Effect<ScheduledTask, OrchestratorMcpFailure> =>	1296	): Effect.Effect<ScheduledTask, OrchestratorMcpFailure> =>
1182	Effect.gen(function* () {	1297	Effect.gen(function* () {
1183	const { tasks } = yield* scheduledTasks	1298	const { tasks } = yield* scheduledTasks
...	@@ -1188,21 +1303,38 @@ const make = Effect.gen(function* () {	...	@@ -1188,21 +1303,38 @@ const make = Effect.gen(function* () {
1188	),	1303	),
1189	);	1304	);
1190	const task = tasks.find((candidate) => candidate.id === scheduledTaskId);	1305	const task = tasks.find((candidate) => candidate.id === scheduledTaskId);
1191	if (task === undefined \|\| task.projectId !== projectId) {	1306	if (task === undefined) {
1192	return yield* failure(	1307	return yield* failure("task_not_found", `Scheduled task ${scheduledTaskId} was not found.`);
1193	"task_not_found",
1194	`Scheduled task ${scheduledTaskId} was not found in the calling project.`,
1195	);
1196	}	1308	}
		1309	yield* resolveRuntimeMode(limits.runtimeMode, task.runtimeMode);
		1310	yield* resolveInteractionMode(limits.interactionMode, task.interactionMode);
1197	return task;	1311	return task;
1198	});	1312	});
1199		1313
1200	return OrchestratorMcpService.of({	1314	return OrchestratorMcpService.of({
1201	scheduleTask: (scope, input) =>	1315	scheduleTask: (scope, input) =>
1202	Effect.gen(function* () {	1316	Effect.gen(function* () {
1203	yield* requireCapability(scope);	1317	const { parent, limits } = yield* loadCaller(scope);
1204	const parent = yield* loadProjection(scope.threadId);	1318	const projectId = yield* resolveProjectTarget(parent, input.projectId);
1205	const bindToCurrentThread = input.bindToCurrentThread ?? true;	1319	yield* assertLiveCallerForOtherProject(scope, parent, projectId);
		1320	const project = yield* requireProject(projectId);
		1321	// Binding means "wake this thread", which only a thread caller in that project has.
		1322	const bindToCurrentThread =
		1323	input.bindToCurrentThread ??
		1324	(parent !== undefined && parent.thread.projectId === projectId);
		1325	if (
		1326	bindToCurrentThread &&
		1327	(parent === undefined \|\| parent.thread.projectId !== projectId)
		1328	) {
		1329	return yield* failure(
		1330	"invalid_request",
		1331	parent === undefined
		1332	? "bindToCurrentThread needs an agent running inside a T3 thread."
		1333	: "bindToCurrentThread binds to this thread, which belongs to a different project.",
		1334	);
		1335	}
		1336	const modelSelection =
		1337	parent?.thread.modelSelection ?? (yield* projectDefaultModelSelection(project));
1206	const derivedTitle = input.prompt.split("\n")[0]?.trim() ?? "";	1338	const derivedTitle = input.prompt.split("\n")[0]?.trim() ?? "";
1207	const title =	1339	const title =
1208	input.title ?? (derivedTitle.length > 0 ? derivedTitle.slice(0, 80) : "Scheduled task");	1340	input.title ?? (derivedTitle.length > 0 ? derivedTitle.slice(0, 80) : "Scheduled task");
...	@@ -1211,12 +1343,12 @@ const make = Effect.gen(function* () {	...	@@ -1211,12 +1343,12 @@ const make = Effect.gen(function* () {
1211	prompt: input.prompt,	1343	prompt: input.prompt,
1212	enabled: input.enabled ?? true,	1344	enabled: input.enabled ?? true,
1213	schedule: input.schedule,	1345	schedule: input.schedule,
1214	projectId: parent.thread.projectId,	1346	projectId,
1215	threadId: bindToCurrentThread ? scope.threadId : null,	1347	threadId: bindToCurrentThread && parent !== undefined ? parent.thread.id : null,
1216	workspaceStrategy: scheduledTaskWorkspaceStrategy(bindToCurrentThread),	1348	workspaceStrategy: scheduledTaskWorkspaceStrategy(bindToCurrentThread),
1217	modelSelection: parent.thread.modelSelection,	1349	modelSelection,
1218	runtimeMode: parent.thread.runtimeMode,	1350	runtimeMode: limits.runtimeMode,
1219	interactionMode: parent.thread.interactionMode,	1351	interactionMode: limits.interactionMode,
1220	createdBy: "agent",	1352	createdBy: "agent",
1221	creationSource: "mcp",	1353	creationSource: "mcp",
1222	// Scope the idempotency key by provider session so two callers	1354	// Scope the idempotency key by provider session so two callers
...	@@ -1240,10 +1372,10 @@ const make = Effect.gen(function* () {	...	@@ -1240,10 +1372,10 @@ const make = Effect.gen(function* () {
1240	);	1372	);
1241	return scheduledTaskSummary(task);	1373	return scheduledTaskSummary(task);
1242	}),	1374	}),
1243	listScheduledTasks: (scope) =>	1375	listScheduledTasks: (scope, input) =>
1244	Effect.gen(function* () {	1376	Effect.gen(function* () {
1245	yield* requireCapability(scope);	1377	const { parent } = yield* loadCaller(scope);
1246	const parent = yield* loadProjection(scope.threadId);	1378	const projectId = input.projectId ?? parent?.thread.projectId;
1247	const { tasks } = yield* scheduledTasks	1379	const { tasks } = yield* scheduledTasks
1248	.list()	1380	.list()
1249	.pipe(	1381	.pipe(
...	@@ -1251,26 +1383,33 @@ const make = Effect.gen(function* () {	...	@@ -1251,26 +1383,33 @@ const make = Effect.gen(function* () {
1251	failure("orchestration_error", `Could not list scheduled tasks: ${error.message}`),	1383	failure("orchestration_error", `Could not list scheduled tasks: ${error.message}`),
1252	),	1384	),
1253	);	1385	);
1254	// Only expose tasks belonging to the calling thread's project.
1255	return {	1386	return {
1256	tasks: tasks	1387	tasks: tasks
1257	.filter((task) => task.projectId === parent.thread.projectId)	1388	.filter((task) => projectId === undefined \|\| task.projectId === projectId)
1258	.map(scheduledTaskSummary),	1389	.map(scheduledTaskSummary),
1259	};	1390	};
1260	}),	1391	}),
1261	updateScheduledTask: (scope, input) =>	1392	updateScheduledTask: (scope, input) =>
1262	Effect.gen(function* () {	1393	Effect.gen(function* () {
1263	yield* requireCapability(scope);	1394	const { parent, limits } = yield* loadCaller(scope);
1264	const parent = yield* loadProjection(scope.threadId);	1395	const existing = yield* loadScheduledTask(input.scheduledTaskId, limits);
1265	const existing = yield* loadScopedScheduledTask(	1396	yield* assertLiveCallerForOtherProject(scope, parent, existing.projectId);
1266	parent.thread.projectId,	1397	if (
1267	input.scheduledTaskId,	1398	input.bindToCurrentThread === true &&
1268	);	1399	(parent === undefined \|\| parent.thread.projectId !== existing.projectId)
		1400	) {
		1401	return yield* failure(
		1402	"invalid_request",
		1403	parent === undefined
		1404	? "bindToCurrentThread needs an agent running inside a T3 thread."
		1405	: "bindToCurrentThread binds to this thread, which belongs to a different project.",
		1406	);
		1407	}
1269	const threadId =	1408	const threadId =
1270	input.bindToCurrentThread === undefined	1409	input.bindToCurrentThread === undefined
1271	? existing.threadId	1410	? existing.threadId
1272	: input.bindToCurrentThread	1411	: input.bindToCurrentThread && parent !== undefined
1273	? scope.threadId	1412	? parent.thread.id
1274	: null;	1413	: null;
1275	// Rebinding changes where runs execute, so the workspace strategy must	1414	// Rebinding changes where runs execute, so the workspace strategy must
1276	// follow: unbinding a root-strategy task would otherwise run loose	1415	// follow: unbinding a root-strategy task would otherwise run loose
...	@@ -1305,12 +1444,9 @@ const make = Effect.gen(function* () {	...	@@ -1305,12 +1444,9 @@ const make = Effect.gen(function* () {
1305	}),	1444	}),
1306	deleteScheduledTask: (scope, input) =>	1445	deleteScheduledTask: (scope, input) =>
1307	Effect.gen(function* () {	1446	Effect.gen(function* () {
1308	yield* requireCapability(scope);	1447	const { parent, limits } = yield* loadCaller(scope);
1309	const parent = yield* loadProjection(scope.threadId);	1448	const existing = yield* loadScheduledTask(input.scheduledTaskId, limits);
1310	const existing = yield* loadScopedScheduledTask(	1449	yield* assertLiveCallerForOtherProject(scope, parent, existing.projectId);
1311	parent.thread.projectId,
1312	input.scheduledTaskId,
1313	);
1314	yield* scheduledTasks	1450	yield* scheduledTasks
1315	.delete({ id: existing.id })	1451	.delete({ id: existing.id })
1316	.pipe(	1452	.pipe(
...	@@ -1322,16 +1458,15 @@ const make = Effect.gen(function* () {	...	@@ -1322,16 +1458,15 @@ const make = Effect.gen(function* () {
1322	}),	1458	}),
1323	capabilities: (scope) =>	1459	capabilities: (scope) =>
1324	Effect.gen(function* () {	1460	Effect.gen(function* () {
1325	yield* requireCapability(scope);	1461	const { parent, limits } = yield* loadCaller(scope);
1326	const parent = yield* loadProjection(scope.threadId);
1327	const providers = yield* loadProviders;	1462	const providers = yield* loadProviders;
1328	const orchestrationCapableInstanceIds = yield* loadOrchestrationCapableInstanceIds();	1463	const orchestrationCapableInstanceIds = yield* loadOrchestrationCapableInstanceIds();
1329	return {	1464	return {
1330	parentThreadId: scope.threadId,	1465	parentThreadId: parent?.thread.id ?? null,
1331	inheritedProviderInstanceId: parent.thread.modelSelection.instanceId,	1466	inheritedProviderInstanceId: parent?.thread.modelSelection.instanceId ?? null,
1332	inheritedModel: parent.thread.modelSelection.model,	1467	inheritedModel: parent?.thread.modelSelection.model ?? null,
1333	runtimeMode: parent.thread.runtimeMode,	1468	runtimeMode: limits.runtimeMode,
1334	interactionMode: parent.thread.interactionMode,	1469	interactionMode: limits.interactionMode,
1335	providers: providers.map((provider) => {	1470	providers: providers.map((provider) => {
1336	const constraints = providerConstraints(	1471	const constraints = providerConstraints(
1337	provider,	1472	provider,
...	@@ -1366,17 +1501,16 @@ const make = Effect.gen(function* () {	...	@@ -1366,17 +1501,16 @@ const make = Effect.gen(function* () {
1366	},	1501	},
1367	};	1502	};
1368	}),	1503	}),
1369	delegateTask: (scope, input) =>	1504	delegateTask: (callerScope, input) =>
1370	Effect.gen(function* () {	1505	Effect.gen(function* () {
1371	yield* requireCapability(scope);	1506	const { scope, parent } = yield* loadThreadCaller(callerScope, "delegate_task");
1372	const parent = yield* loadProjection(scope.threadId);
1373	const parentRun = parent.runs	1507	const parentRun = parent.runs
1374	.filter(ThreadManagementService.isActiveRun)	1508	.filter(ThreadManagementService.isActiveRun)
1375	.toSorted((left, right) => right.ordinal - left.ordinal)[0];	1509	.toSorted((left, right) => right.ordinal - left.ordinal)[0];
1376	if (	1510	if (
1377	parentRun === undefined \|\|	1511	parentRun === undefined \|\|
1378	parentRun.rootNodeId === null \|\|	1512	parentRun.rootNodeId === null \|\|
1379	parentRun.providerInstanceId !== scope.providerInstanceId	1513	parentRun.providerInstanceId !== scope.thread.providerInstanceId
1380	) {	1514	) {
1381	return yield* failure(	1515	return yield* failure(
1382	"parent_not_active",	1516	"parent_not_active",
...	@@ -1406,7 +1540,7 @@ const make = Effect.gen(function* () {	...	@@ -1406,7 +1540,7 @@ const make = Effect.gen(function* () {
1406	createdBy: "agent",	1540	createdBy: "agent",
1407	creationSource: "mcp",	1541	creationSource: "mcp",
1408	commandId,	1542	commandId,
1409	parentThreadId: scope.threadId,	1543	parentThreadId: scope.thread.threadId,
1410	parentRunId: parentRun.id,	1544	parentRunId: parentRun.id,
1411	parentNodeId: parentRun.rootNodeId,	1545	parentNodeId: parentRun.rootNodeId,
1412	task: taskPrompt(input),	1546	task: taskPrompt(input),
...	@@ -1462,7 +1596,7 @@ const make = Effect.gen(function* () {	...	@@ -1462,7 +1596,7 @@ const make = Effect.gen(function* () {
1462	requestKey: key,	1596	requestKey: key,
1463	operation: "delegate-task-wake-policy",	1597	operation: "delegate-task-wake-policy",
1464	}),	1598	}),
1465	parentThreadId: scope.threadId,	1599	parentThreadId: scope.thread.threadId,
1466	taskId,	1600	taskId,
1467	completionWake: "always",	1601	completionWake: "always",
1468	})	1602	})
...	@@ -1491,12 +1625,17 @@ const make = Effect.gen(function* () {	...	@@ -1491,12 +1625,17 @@ const make = Effect.gen(function* () {
1491	);	1625	);
1492	return yield* readTask(scope, taskId, true, true);	1626	return yield* readTask(scope, taskId, true, true);
1493	}),	1627	}),
1494	taskStatus: (scope, taskId) => readTask(scope, taskId, false, true),	1628	taskStatus: (callerScope, taskId) =>
1495	cancelTask: (scope, input) =>
1496	Effect.gen(function* () {	1629	Effect.gen(function* () {
		1630	const scope = yield* requireThreadScope(callerScope, "task_status");
		1631	return yield* readTask(scope, taskId, false, true);
		1632	}),
		1633	cancelTask: (callerScope, input) =>
		1634	Effect.gen(function* () {
		1635	const scope = yield* requireThreadScope(callerScope, "task_cancel");
1497	const current = yield* readTask(scope, input.taskId);	1636	const current = yield* readTask(scope, input.taskId);
1498	const key = yield* requestKey(input.clientRequestId);	1637	const key = yield* requestKey(input.clientRequestId);
1499	const parentProjection = yield* loadProjection(scope.threadId);	1638	const parentProjection = yield* loadProjection(scope.thread.threadId);
1500	const parentTask = parentProjection.subagents.find(	1639	const parentTask = parentProjection.subagents.find(
1501	(task) => task.id === input.taskId && task.origin === "app_owned",	1640	(task) => task.id === input.taskId && task.origin === "app_owned",
1502	);	1641	);
...	@@ -1511,7 +1650,7 @@ const make = Effect.gen(function* () {	...	@@ -1511,7 +1650,7 @@ const make = Effect.gen(function* () {
1511	requestKey: key,	1650	requestKey: key,
1512	operation: "cancel-task-completion-delivery",	1651	operation: "cancel-task-completion-delivery",
1513	}),	1652	}),
1514	parentThreadId: scope.threadId,	1653	parentThreadId: scope.thread.threadId,
1515	taskId: input.taskId,	1654	taskId: input.taskId,
1516	})	1655	})
1517	.pipe(	1656	.pipe(
...	@@ -1573,15 +1712,14 @@ const make = Effect.gen(function* () {	...	@@ -1573,15 +1712,14 @@ const make = Effect.gen(function* () {
1573	status: "cancel_requested",	1712	status: "cancel_requested",
1574	};	1713	};
1575	}),	1714	}),
1576	createThreads: (scope, input) =>	1715	createThreads: (callerScope, input) =>
1577	Effect.gen(function* () {	1716	Effect.gen(function* () {
1578	yield* requireCapability(scope);	1717	const { scope, parent } = yield* loadThreadCaller(callerScope, "create_threads");
1579	const parent = yield* loadProjection(scope.threadId);
1580	const parentRun = ThreadManagementService.latestActiveRun(parent);	1718	const parentRun = ThreadManagementService.latestActiveRun(parent);
1581	if (	1719	if (
1582	parentRun === undefined \|\|	1720	parentRun === undefined \|\|
1583	parentRun.rootNodeId === null \|\|	1721	parentRun.rootNodeId === null \|\|
1584	parentRun.providerInstanceId !== scope.providerInstanceId	1722	parentRun.providerInstanceId !== scope.thread.providerInstanceId
1585	) {	1723	) {
1586	return yield* failure(	1724	return yield* failure(
1587	"parent_not_active",	1725	"parent_not_active",
...	@@ -1660,7 +1798,7 @@ const make = Effect.gen(function* () {	...	@@ -1660,7 +1798,7 @@ const make = Effect.gen(function* () {
1660	index,	1798	index,
1661	}),	1799	}),
1662	threadId,	1800	threadId,
1663	senderThreadId: scope.threadId,	1801	senderThreadId: scope.thread.threadId,
1664	messageId: stableMessageId({	1802	messageId: stableMessageId({
1665	scope,	1803	scope,
1666	requestKey: key,	1804	requestKey: key,
...	@@ -1691,7 +1829,7 @@ const make = Effect.gen(function* () {	...	@@ -1691,7 +1829,7 @@ const make = Effect.gen(function* () {
1691	operation: "record-created-thread",	1829	operation: "record-created-thread",
1692	index,	1830	index,
1693	}),	1831	}),
1694	parentThreadId: scope.threadId,	1832	parentThreadId: scope.thread.threadId,
1695	parentRunId: parentRun.id,	1833	parentRunId: parentRun.id,
1696	parentNodeId,	1834	parentNodeId,
1697	targetThreadId: threadId,	1835	targetThreadId: threadId,
...	@@ -1722,11 +1860,11 @@ const make = Effect.gen(function* () {	...	@@ -1722,11 +1860,11 @@ const make = Effect.gen(function* () {
1722	}),	1860	}),
1723	listThreads: (scope, input) =>	1861	listThreads: (scope, input) =>
1724	Effect.gen(function* () {	1862	Effect.gen(function* () {
1725	yield* requireCapability(scope);	1863	const { parent } = yield* loadCaller(scope);
1726	const parent = yield* loadProjection(scope.threadId);	1864	const projectId = yield* resolveProjectTarget(parent, input.projectId);
1727	const projectThreads = yield* threadManagement	1865	const projectThreads = yield* threadManagement
1728	.listProjectThreads({	1866	.listProjectThreads({
1729	projectId: parent.thread.projectId,	1867	projectId,
1730	includeSubagents: input.includeSubagents !== false,	1868	includeSubagents: input.includeSubagents !== false,
1731	})	1869	})
1732	.pipe(	1870	.pipe(
...	@@ -1755,8 +1893,8 @@ const make = Effect.gen(function* () {	...	@@ -1755,8 +1893,8 @@ const make = Effect.gen(function* () {
1755	const page = filtered.slice(cursor, cursor + limit);	1893	const page = filtered.slice(cursor, cursor + limit);
1756	const nextCursor = cursor + page.length < filtered.length ? cursor + page.length : null;	1894	const nextCursor = cursor + page.length < filtered.length ? cursor + page.length : null;
1757	return {	1895	return {
1758	projectId: parent.thread.projectId,	1896	projectId,
1759	currentThreadId: scope.threadId,	1897	currentThreadId: parent?.thread.id ?? null,
1760	threads: page.map(listItemFromShell),	1898	threads: page.map(listItemFromShell),
1761	nextCursor,	1899	nextCursor,
1762	total: filtered.length,	1900	total: filtered.length,
...	@@ -1795,8 +1933,13 @@ const make = Effect.gen(function* () {	...	@@ -1795,8 +1933,13 @@ const make = Effect.gen(function* () {
1795	{ concurrency: 1 },	1933	{ concurrency: 1 },
1796	);	1934	);
1797	const messagesByThreadId = new Map(sourceMessages);	1935	const messagesByThreadId = new Map(sourceMessages);
1798	const task = directAppOwnedChildTask(parent, target);	1936	const task = parent === undefined ? undefined : directAppOwnedChildTask(parent, target);
1799	if (task !== undefined && (input.textOffset ?? 0) === 0) {	1937	if (
		1938	parent !== undefined &&
		1939	scope.thread !== undefined &&
		1940	task !== undefined &&
		1941	(input.textOffset ?? 0) === 0
		1942	) {
1800	const transfer = parent.contextTransfers.find(	1943	const transfer = parent.contextTransfers.find(
1801	(transfer) =>	1944	(transfer) =>
1802	transfer.type === "subagent_result" &&	1945	transfer.type === "subagent_result" &&
...	@@ -1822,7 +1965,13 @@ const make = Effect.gen(function* () {	...	@@ -1822,7 +1965,13 @@ const make = Effect.gen(function* () {
1822	maxChars,	1965	maxChars,
1823	})	1966	})
1824	) {	1967	) {
1825	yield* readTask(scope, task.id, false, true, "thread-read-acknowledge");	1968	yield* readTask(
		1969	scope as McpThreadInvocationScope,
		1970	task.id,
		1971	false,
		1972	true,
		1973	"thread-read-acknowledge",
		1974	);
1826	}	1975	}
1827	}	1976	}
1828	return {	1977	return {
...	@@ -1845,9 +1994,10 @@ const make = Effect.gen(function* () {	...	@@ -1845,9 +1994,10 @@ const make = Effect.gen(function* () {
1845	}),	1994	}),
1846	sendToThread: (scope, input) =>	1995	sendToThread: (scope, input) =>
1847	Effect.gen(function* () {	1996	Effect.gen(function* () {
1848	const { parent, target } = yield* loadScopedThread(scope, input.threadId);	1997	const { parent, limits, target } = yield* loadScopedThread(scope, input.threadId);
1849	yield* resolveRuntimeMode(parent.thread.runtimeMode, target.thread.runtimeMode);	1998	yield* assertLiveCallerForOtherThread(scope, parent, target);
1850	yield* resolveInteractionMode(parent.thread.interactionMode, target.thread.interactionMode);	1999	yield* resolveRuntimeMode(limits.runtimeMode, target.thread.runtimeMode);
		2000	yield* resolveInteractionMode(limits.interactionMode, target.thread.interactionMode);
1851		2001
1852	const mode = input.mode ?? "auto";	2002	const mode = input.mode ?? "auto";
1853	const key = yield* requestKey(input.clientRequestId);	2003	const key = yield* requestKey(input.clientRequestId);
...	@@ -1858,14 +2008,14 @@ const make = Effect.gen(function* () {	...	@@ -1858,14 +2008,14 @@ const make = Effect.gen(function* () {
1858	});	2008	});
1859	const result = yield* threadManagement	2009	const result = yield* threadManagement
1860	.sendToThread({	2010	.sendToThread({
1861	projectId: parent.thread.projectId,	2011	projectId: target.thread.projectId,
1862	commandId: stableCommandId({	2012	commandId: stableCommandId({
1863	scope,	2013	scope,
1864	requestKey: key,	2014	requestKey: key,
1865	operation: "thread-send",	2015	operation: "thread-send",
1866	}),	2016	}),
1867	threadId: input.threadId,	2017	threadId: input.threadId,
1868	senderThreadId: scope.threadId,	2018	...(parent === undefined ? {} : { senderThreadId: parent.thread.id }),
1869	messageId,	2019	messageId,
1870	text: input.message,	2020	text: input.message,
1871	attachments: [],	2021	attachments: [],
...	@@ -1893,10 +2043,10 @@ const make = Effect.gen(function* () {	...	@@ -1893,10 +2043,10 @@ const make = Effect.gen(function* () {
1893	}),	2043	}),
1894	waitForThread: (scope, input) =>	2044	waitForThread: (scope, input) =>
1895	Effect.gen(function* () {	2045	Effect.gen(function* () {
1896	const { parent } = yield* loadScopedThread(scope, input.threadId);	2046	const { target } = yield* loadScopedThread(scope, input.threadId);
1897	const result = yield* threadManagement	2047	const result = yield* threadManagement
1898	.waitForThread({	2048	.waitForThread({
1899	projectId: parent.thread.projectId,	2049	projectId: target.thread.projectId,
1900	threadId: input.threadId,	2050	threadId: input.threadId,
1901	...(input.runId === undefined ? {} : { runId: input.runId }),	2051	...(input.runId === undefined ? {} : { runId: input.runId }),
1902	timeoutMs: Math.min(	2052	timeoutMs: Math.min(
...	@@ -1914,11 +2064,15 @@ const make = Effect.gen(function* () {	...	@@ -1914,11 +2064,15 @@ const make = Effect.gen(function* () {
1914	}),	2064	}),
1915	interruptThread: (scope, input) =>	2065	interruptThread: (scope, input) =>
1916	Effect.gen(function* () {	2066	Effect.gen(function* () {
1917	const { parent } = yield* loadScopedThread(scope, input.threadId);	2067	const { parent, limits, target } = yield* loadScopedThread(scope, input.threadId);
		2068	yield* assertLiveCallerForOtherThread(scope, parent, target);
		2069	// Stopping another thread's work is a write: it must run within the caller's modes.
		2070	yield* resolveRuntimeMode(limits.runtimeMode, target.thread.runtimeMode);
		2071	yield* resolveInteractionMode(limits.interactionMode, target.thread.interactionMode);
1918	const key = yield* requestKey(input.clientRequestId);	2072	const key = yield* requestKey(input.clientRequestId);
1919	const result = yield* threadManagement	2073	const result = yield* threadManagement
1920	.interruptThread({	2074	.interruptThread({
1921	projectId: parent.thread.projectId,	2075	projectId: target.thread.projectId,
1922	commandId: stableCommandId({	2076	commandId: stableCommandId({
1923	scope,	2077	scope,
1924	requestKey: key,	2078	requestKey: key,
...	@@ -1962,4 +2116,5 @@ export const layer: Layer.Layer<	...	@@ -1962,4 +2116,5 @@ export const layer: Layer.Layer<
1962	\| ProviderRegistry.ProviderRegistry	2116	\| ProviderRegistry.ProviderRegistry
1963	\| ProviderAdapterRegistry.ProviderAdapterRegistryV2	2117	\| ProviderAdapterRegistry.ProviderAdapterRegistryV2
1964	\| ScheduledTaskService.ScheduledTaskService	2118	\| ScheduledTaskService.ScheduledTaskService
		2119	\| ProjectService.ProjectService
1965	> = Layer.effect(OrchestratorMcpService, make);	2120	> = Layer.effect(OrchestratorMcpService, make);

apps/server/src/mcp/OrchestratorMcpToolkit.integration.test.ts+42-15

 @@ -71,6 +71,7 @@ import {
   materializeReplayTranscriptWorkspace,
 } from "../orchestration-v2/testkit/ReplayTranscriptNdjson.ts";
 import { makeProviderRegistryLayer } from "../provider/testUtils/providerRegistryMock.ts";
+import * as ProjectService from "../project/ProjectService.ts";
 import * as ScheduledTaskService from "../scheduledTasks/ScheduledTaskService.ts";
 import * as McpHttpServer from "./McpHttpServer.ts";
 import * as McpInvocationContext from "./McpInvocationContext.ts";
 @@ -631,6 +632,16 @@ describe("orchestrator MCP toolkit", () => {
             Layer.provide(registryLayer),
             Layer.provide(providerRegistryLayer),
             Layer.provide(scheduledTaskStubLayer),
+            Layer.provide(
+              Layer.mock(ProjectService.ProjectService)({
+                getById: (id) =>
+                  Effect.succeed(
+                    id === projectId
+                      ? Option.some({ id, defaultModelSelection: null } as never)
+                      : Option.none(),
+                  ),
+              }),
+            ),
             Layer.provide(NodeServices.layer),
           );
 @@ -676,9 +687,13 @@ describe("orchestrator MCP toolkit", () => {
             const invocation: McpInvocationContext.McpInvocationScope = {
               environmentId: EnvironmentId.make("environment:mcp-orchestrator"),
-              threadId: parentThreadId,
+              requestNamespace: "mcp-provider-session-parent",
-              providerSessionId: "mcp-provider-session-parent",
+              thread: {
-              providerInstanceId: codexInstanceId,
+                threadId: parentThreadId,
+                providerSessionId: "mcp-provider-session-parent",
+                providerInstanceId: codexInstanceId,
+              },
+              client: undefined,
               capabilities: new Set(["orchestration"]),
               issuedAt: 1,
             };
 @@ -2326,31 +2341,38 @@ describe("orchestrator MCP toolkit", () => {
               branch: null,
               worktreePath: cwd,
             });
+            // Targets reach the whole environment; the caller's modes still cap writes.
             const foreignOrganizeCall = yield* invoke("t3_thread_organize", {
               threadId: foreignThreadId,
               action: "pin",
             });
-            expect(foreignOrganizeCall.structuredContent).toMatchObject({
+            expect(foreignOrganizeCall.isError).toBe(false);
-              code: "thread_not_found",
+            expect((yield* orchestrator.getThreadShell(foreignThreadId))?.pinnedAt).not.toBeNull();
-            });
-            expect((yield* orchestrator.getThreadShell(foreignThreadId))?.pinnedAt).toBeNull();
             const foreignReadCall = yield* invoke("t3_thread_read", {
               threadId: foreignThreadId,
             });
             expect(foreignReadCall.structuredContent).toMatchObject({
-              _tag: "OrchestratorMcpFailure",
+              thread: { threadId: foreignThreadId, projectId: "project:mcp-foreign" },
-              code: "thread_not_found",
             });
             const foreignUpdateCall = yield* invoke("t3_thread_update", {
               threadId: foreignThreadId,
               action: "rename",
-              title: "Should stay foreign",
+              title: "Renamed from another project",
             });
             expect(foreignUpdateCall.structuredContent).toMatchObject({
-              _tag: "OrchestratorMcpFailure",
+              threadId: foreignThreadId,
-              code: "thread_not_found",
+              title: "Renamed from another project",
+            });
+            const foreignListCall = yield* invoke("t3_thread_list", {
+              projectId: "project:mcp-foreign",
             });
+            const foreignListed = yield* decodeThreadListResult(
+              foreignListCall.structuredContent,
+            ).pipe(Effect.orDie);
+            expect(foreignListed.threads.map((thread) => thread.threadId)).toEqual([
+              foreignThreadId,
+            ]);
             const listCall = yield* invoke("t3_thread_list", {
               includeSubagents: false,
               limit: 100,
 @@ -3548,6 +3570,7 @@ describe("orchestrator MCP toolkit", () => {
           ),
           Layer.provide(providerRegistryLayer),
           Layer.provide(unusedScheduledTaskStubLayer),
+          Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
           Layer.provide(NodeServices.layer),
         );
 @@ -3602,9 +3625,13 @@ describe("orchestrator MCP toolkit", () => {
           const invocation: McpInvocationContext.McpInvocationScope = {
             environmentId: EnvironmentId.make("environment:mcp-replay"),
-            threadId: parentThreadId,
+            requestNamespace: "mcp-provider-session-replay-parent",
-            providerSessionId: "mcp-provider-session-replay-parent",
+            thread: {
-            providerInstanceId: codexInstanceId,
+              threadId: parentThreadId,
+              providerSessionId: "mcp-provider-session-replay-parent",
+              providerInstanceId: codexInstanceId,
+            },
+            client: undefined,
             capabilities: new Set(["orchestration"]),
             issuedAt: 1,
           };

apps/server/src/mcp/PreviewAutomationBroker.test.ts+41-27

...	@@ -36,9 +36,13 @@ const makeBroker = PreviewAutomationBroker.make.pipe(Effect.provide(NodeServices	...	@@ -36,9 +36,13 @@ const makeBroker = PreviewAutomationBroker.make.pipe(Effect.provide(NodeServices
36		36
37	const scope = {	37	const scope = {
38	environmentId: EnvironmentId.make("environment-1"),	38	environmentId: EnvironmentId.make("environment-1"),
39	threadId: ThreadId.make("thread-1"),	39	requestNamespace: "provider-session-1",
40	providerSessionId: "provider-session-1",	40	thread: {
41	providerInstanceId: ProviderInstanceId.make("codex"),	41	threadId: ThreadId.make("thread-1"),
		42	providerSessionId: "provider-session-1",
		43	providerInstanceId: ProviderInstanceId.make("codex"),
		44	},
		45	client: undefined,
42	capabilities: new Set(["preview"] as const),	46	capabilities: new Set(["preview"] as const),
43	issuedAt: 1,	47	issuedAt: 1,
44	};	48	};
...	@@ -366,9 +370,9 @@ it.effect("preserves bounded request and remote selector diagnostics", () => {	...	@@ -366,9 +370,9 @@ it.effect("preserves bounded request and remote selector diagnostics", () => {
366	expect(error).toMatchObject({	370	expect(error).toMatchObject({
367	operation: "click",	371	operation: "click",
368	environmentId: scope.environmentId,	372	environmentId: scope.environmentId,
369	threadId: scope.threadId,	373	threadId: scope.thread.threadId,
370	providerSessionId: scope.providerSessionId,	374	providerSessionId: scope.thread.providerSessionId,
371	providerInstanceId: scope.providerInstanceId,	375	providerInstanceId: scope.thread.providerInstanceId,
372	clientId: "client-1",	376	clientId: "client-1",
373	requestId: "preview-0",	377	requestId: "preview-0",
374	tabId: "tab-1",	378	tabId: "tab-1",
...	@@ -468,7 +472,7 @@ it.effect.each([	...	@@ -468,7 +472,7 @@ it.effect.each([
468	.pipe(Effect.flip);	472	.pipe(Effect.flip);
469	expect(error).toMatchObject({	473	expect(error).toMatchObject({
470	_tag: tag,	474	_tag: tag,
471	threadId: scope.threadId,	475	threadId: scope.thread.threadId,
472	});	476	});
473	expect(error.cause).toBe(remoteError);	477	expect(error.cause).toBe(remoteError);
474	expect(error.message).toContain("remains on the desktop");	478	expect(error.message).toContain("remains on the desktop");
...	@@ -500,9 +504,9 @@ it.effect("distinguishes malformed remote failures", () =>	...	@@ -500,9 +504,9 @@ it.effect("distinguishes malformed remote failures", () =>
500	expect(error).toMatchObject({	504	expect(error).toMatchObject({
501	operation: "status",	505	operation: "status",
502	environmentId: scope.environmentId,	506	environmentId: scope.environmentId,
503	threadId: scope.threadId,	507	threadId: scope.thread.threadId,
504	providerSessionId: scope.providerSessionId,	508	providerSessionId: scope.thread.providerSessionId,
505	providerInstanceId: scope.providerInstanceId,	509	providerInstanceId: scope.thread.providerInstanceId,
506	clientId: "client-1",	510	clientId: "client-1",
507	requestId: "preview-0",	511	requestId: "preview-0",
508	timeoutMs: 2_000,	512	timeoutMs: 2_000,
...	@@ -522,9 +526,9 @@ it.effect("rejects calls when no connected host exists", () =>	...	@@ -522,9 +526,9 @@ it.effect("rejects calls when no connected host exists", () =>
522	expect(error).toMatchObject({	526	expect(error).toMatchObject({
523	operation: "status",	527	operation: "status",
524	environmentId: scope.environmentId,	528	environmentId: scope.environmentId,
525	threadId: scope.threadId,	529	threadId: scope.thread.threadId,
526	providerSessionId: scope.providerSessionId,	530	providerSessionId: scope.thread.providerSessionId,
527	providerInstanceId: scope.providerInstanceId,	531	providerInstanceId: scope.thread.providerInstanceId,
528	});	532	});
529	}),	533	}),
530	);	534	);
...	@@ -590,8 +594,11 @@ it.effect("routes requests for background threads through an environment-level h	...	@@ -590,8 +594,11 @@ it.effect("routes requests for background threads through an environment-level h
590	const result = yield* broker.invoke<string>({	594	const result = yield* broker.invoke<string>({
591	scope: {	595	scope: {
592	...scope,	596	...scope,
593	threadId: backgroundThreadId,	597	thread: {
594	providerSessionId: "provider-session-background",	598	...scope.thread,
		599	threadId: backgroundThreadId,
		600	providerSessionId: "provider-session-background",
		601	},
595	},	602	},
596	operation: "status",	603	operation: "status",
597	input: {},	604	input: {},
...	@@ -688,7 +695,7 @@ it.effect("pins a provider session to its initial host despite later focus chang	...	@@ -688,7 +695,7 @@ it.effect("pins a provider session to its initial host despite later focus chang
688	environmentId: scope.environmentId,	695	environmentId: scope.environmentId,
689	connectionId: "connection-stale",	696	connectionId: "connection-stale",
690	focused: true,	697	focused: true,
691	liveTabs: [{ threadId: scope.threadId, tabId: PreviewTabId.make("stale-tab") }],	698	liveTabs: [{ threadId: scope.thread.threadId, tabId: PreviewTabId.make("stale-tab") }],
692	});	699	});
693	expect(yield* broker.invoke<string>({ scope, operation: "status", input: {} })).toBe(	700	expect(yield* broker.invoke<string>({ scope, operation: "status", input: {} })).toBe(
694	"second",	701	"second",
...	@@ -702,7 +709,7 @@ it.effect("pins a provider session to its initial host despite later focus chang	...	@@ -702,7 +709,7 @@ it.effect("pins a provider session to its initial host despite later focus chang
702		709
703	const firstPinnedScope = {	710	const firstPinnedScope = {
704	...scope,	711	...scope,
705	providerSessionId: "provider-session-first-pinned",	712	thread: { ...scope.thread, providerSessionId: "provider-session-first-pinned" },
706	};	713	};
707	expect(	714	expect(
708	yield* broker.invoke<string>({ scope: firstPinnedScope, operation: "status", input: {} }),	715	yield* broker.invoke<string>({ scope: firstPinnedScope, operation: "status", input: {} }),
...	@@ -720,7 +727,10 @@ it.effect("pins a provider session to its initial host despite later focus chang	...	@@ -720,7 +727,10 @@ it.effect("pins a provider session to its initial host despite later focus chang
720	).toBe("first");	727	).toBe("first");
721	expect(	728	expect(
722	yield* broker.invoke<string>({	729	yield* broker.invoke<string>({
723	scope: { ...scope, providerSessionId: "provider-session-second-pinned" },	730	scope: {
		731	...scope,
		732	thread: { ...scope.thread, providerSessionId: "provider-session-second-pinned" },
		733	},
724	operation: "status",	734	operation: "status",
725	input: {},	735	input: {},
726	}),	736	}),
...	@@ -756,7 +766,7 @@ it.effect("prefers the live tab owner for new sessions without moving existing l	...	@@ -756,7 +766,7 @@ it.effect("prefers the live tab owner for new sessions without moving existing l
756	connectionId: connections.get("owner")!,	766	connectionId: connections.get("owner")!,
757	focused: false,	767	focused: false,
758	liveTabs: [	768	liveTabs: [
759	{ threadId: scope.threadId, tabId: PreviewTabId.make("signed-in"), visible: true },	769	{ threadId: scope.thread.threadId, tabId: PreviewTabId.make("signed-in"), visible: true },
760	],	770	],
761	});	771	});
762	yield* broker.focusHost({	772	yield* broker.focusHost({
...	@@ -765,7 +775,11 @@ it.effect("prefers the live tab owner for new sessions without moving existing l	...	@@ -765,7 +775,11 @@ it.effect("prefers the live tab owner for new sessions without moving existing l
765	connectionId: connections.get("other")!,	775	connectionId: connections.get("other")!,
766	focused: true,	776	focused: true,
767	liveTabs: [	777	liveTabs: [
768	{ threadId: scope.threadId, tabId: PreviewTabId.make("signed-in"), visible: false },	778	{
		779	threadId: scope.thread.threadId,
		780	tabId: PreviewTabId.make("signed-in"),
		781	visible: false,
		782	},
769	{	783	{
770	threadId: ThreadId.make("another-thread"),	784	threadId: ThreadId.make("another-thread"),
771	tabId: PreviewTabId.make("different-tab"),	785	tabId: PreviewTabId.make("different-tab"),
...	@@ -778,7 +792,7 @@ it.effect("prefers the live tab owner for new sessions without moving existing l	...	@@ -778,7 +792,7 @@ it.effect("prefers the live tab owner for new sessions without moving existing l
778	);	792	);
779	expect(	793	expect(
780	yield* broker.invoke<string>({	794	yield* broker.invoke<string>({
781	scope: { ...scope, providerSessionId: "explicit-owner" },	795	scope: { ...scope, thread: { ...scope.thread, providerSessionId: "explicit-owner" } },
782	tabId: PreviewTabId.make("signed-in"),	796	tabId: PreviewTabId.make("signed-in"),
783	operation: "snapshot",	797	operation: "snapshot",
784	input: {},	798	input: {},
...	@@ -786,7 +800,7 @@ it.effect("prefers the live tab owner for new sessions without moving existing l	...	@@ -786,7 +800,7 @@ it.effect("prefers the live tab owner for new sessions without moving existing l
786	).toBe("owner");	800	).toBe("owner");
787	expect(	801	expect(
788	yield* broker.invoke<string>({	802	yield* broker.invoke<string>({
789	scope: { ...scope, providerSessionId: "other-tab" },	803	scope: { ...scope, thread: { ...scope.thread, providerSessionId: "other-tab" } },
790	tabId: PreviewTabId.make("different-tab"),	804	tabId: PreviewTabId.make("different-tab"),
791	operation: "evaluate",	805	operation: "evaluate",
792	input: {},	806	input: {},
...	@@ -805,7 +819,7 @@ it.effect("prefers the live tab owner for new sessions without moving existing l	...	@@ -805,7 +819,7 @@ it.effect("prefers the live tab owner for new sessions without moving existing l
805	);	819	);
806	expect(	820	expect(
807	yield* broker.invoke<string>({	821	yield* broker.invoke<string>({
808	scope: { ...scope, providerSessionId: "after-tab-closed" },	822	scope: { ...scope, thread: { ...scope.thread, providerSessionId: "after-tab-closed" } },
809	operation: "evaluate",	823	operation: "evaluate",
810	input: {},	824	input: {},
811	}),	825	}),
...	@@ -1049,7 +1063,7 @@ it.effect("fails over a pinned provider session only after its host disconnects"	...	@@ -1049,7 +1063,7 @@ it.effect("fails over a pinned provider session only after its host disconnects"
1049	environmentId: scope.environmentId,	1063	environmentId: scope.environmentId,
1050	connectionId: firstConnectionId,	1064	connectionId: firstConnectionId,
1051	focused: true,	1065	focused: true,
1052	liveTabs: [{ threadId: scope.threadId, tabId: firstTabId }],	1066	liveTabs: [{ threadId: scope.thread.threadId, tabId: firstTabId }],
1053	});	1067	});
1054	expect(yield* broker.invoke({ scope, operation: "open", input: {} })).toEqual({	1068	expect(yield* broker.invoke({ scope, operation: "open", input: {} })).toEqual({
1055	host: "first",	1069	host: "first",
...	@@ -1193,9 +1207,9 @@ it.effect("fails requests assigned to the stream that is replaced", () =>	...	@@ -1193,9 +1207,9 @@ it.effect("fails requests assigned to the stream that is replaced", () =>
1193	expect(error).toMatchObject({	1207	expect(error).toMatchObject({
1194	operation: "status",	1208	operation: "status",
1195	environmentId: scope.environmentId,	1209	environmentId: scope.environmentId,
1196	threadId: scope.threadId,	1210	threadId: scope.thread.threadId,
1197	providerSessionId: scope.providerSessionId,	1211	providerSessionId: scope.thread.providerSessionId,
1198	providerInstanceId: scope.providerInstanceId,	1212	providerInstanceId: scope.thread.providerInstanceId,
1199	clientId: "client-1",	1213	clientId: "client-1",
1200	requestId: "preview-0",	1214	requestId: "preview-0",
1201	timeoutMs: 15_000,	1215	timeoutMs: 15_000,

apps/server/src/mcp/PreviewAutomationBroker.ts+14-13

...	@@ -40,7 +40,8 @@ import * as SynchronizedRef from "effect/SynchronizedRef";	...	@@ -40,7 +40,8 @@ import * as SynchronizedRef from "effect/SynchronizedRef";
40	import * as McpInvocationContext from "./McpInvocationContext.ts";	40	import * as McpInvocationContext from "./McpInvocationContext.ts";
41		41
42	export interface PreviewAutomationInvokeInput {	42	export interface PreviewAutomationInvokeInput {
43	readonly scope: McpInvocationContext.McpInvocationScope;	43	/** Preview tabs belong to a thread, so only thread callers reach the broker. */
		44	readonly scope: McpInvocationContext.McpThreadInvocationScope;
44	readonly operation: PreviewAutomationOperation;	45	readonly operation: PreviewAutomationOperation;
45	readonly input: unknown;	46	readonly input: unknown;
46	readonly tabId?: PreviewTabId;	47	readonly tabId?: PreviewTabId;
...	@@ -103,9 +104,9 @@ interface HostAssignment {	...	@@ -103,9 +104,9 @@ interface HostAssignment {
103	interface PreviewAutomationRequestErrorContext {	104	interface PreviewAutomationRequestErrorContext {
104	readonly operation: PreviewAutomationOperation;	105	readonly operation: PreviewAutomationOperation;
105	readonly environmentId: McpInvocationContext.McpInvocationScope["environmentId"];	106	readonly environmentId: McpInvocationContext.McpInvocationScope["environmentId"];
106	readonly threadId: McpInvocationContext.McpInvocationScope["threadId"];	107	readonly threadId: McpInvocationContext.McpThreadCaller["threadId"];
107	readonly providerSessionId: string;	108	readonly providerSessionId: string;
108	readonly providerInstanceId: McpInvocationContext.McpInvocationScope["providerInstanceId"];	109	readonly providerInstanceId: McpInvocationContext.McpThreadCaller["providerInstanceId"];
109	readonly clientId: string;	110	readonly clientId: string;
110	readonly connectionId: ClientConnection["connectionId"];	111	readonly connectionId: ClientConnection["connectionId"];
111	readonly requestId: string;	112	readonly requestId: string;
...	@@ -160,8 +161,8 @@ const selectorDiagnosticsFromInput = (	...	@@ -160,8 +161,8 @@ const selectorDiagnosticsFromInput = (
160	return {};	161	return {};
161	};	162	};
162		163
163	const hostAssignmentKey = (scope: McpInvocationContext.McpInvocationScope): string =>	164	const hostAssignmentKey = (scope: McpInvocationContext.McpThreadInvocationScope): string =>
164	`${scope.environmentId}\u0000${scope.providerSessionId}`;	165	`${scope.environmentId}\u0000${scope.thread.providerSessionId}`;
165		166
166	const isPreviewTabId = Schema.is(PreviewTabId);	167	const isPreviewTabId = Schema.is(PreviewTabId);
167		168
...	@@ -498,7 +499,7 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {	...	@@ -498,7 +499,7 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {
498	const ownsTargetTab = (host: ClientConnection, visibleOnly = false) =>	499	const ownsTargetTab = (host: ClientConnection, visibleOnly = false) =>
499	host.liveTabs.some(	500	host.liveTabs.some(
500	(tab) =>	501	(tab) =>
501	tab.threadId === input.scope.threadId &&	502	tab.threadId === input.scope.thread.threadId &&
502	(!visibleOnly \|\| tab.visible === true) &&	503	(!visibleOnly \|\| tab.visible === true) &&
503	(input.tabId === undefined \|\| tab.tabId === input.tabId),	504	(input.tabId === undefined \|\| tab.tabId === input.tabId),
504	);	505	);
...	@@ -545,9 +546,9 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {	...	@@ -545,9 +546,9 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {
545	const context: PreviewAutomationRequestErrorContext = {	546	const context: PreviewAutomationRequestErrorContext = {
546	operation: input.operation,	547	operation: input.operation,
547	environmentId: input.scope.environmentId,	548	environmentId: input.scope.environmentId,
548	threadId: input.scope.threadId,	549	threadId: input.scope.thread.threadId,
549	providerSessionId: input.scope.providerSessionId,	550	providerSessionId: input.scope.thread.providerSessionId,
550	providerInstanceId: input.scope.providerInstanceId,	551	providerInstanceId: input.scope.thread.providerInstanceId,
551	clientId: connection.clientId,	552	clientId: connection.clientId,
552	connectionId: connection.connectionId,	553	connectionId: connection.connectionId,
553	requestId,	554	requestId,
...	@@ -566,9 +567,9 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {	...	@@ -566,9 +567,9 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {
566	return yield* new PreviewAutomationNoAvailableHostError({	567	return yield* new PreviewAutomationNoAvailableHostError({
567	operation: input.operation,	568	operation: input.operation,
568	environmentId: input.scope.environmentId,	569	environmentId: input.scope.environmentId,
569	threadId: input.scope.threadId,	570	threadId: input.scope.thread.threadId,
570	providerSessionId: input.scope.providerSessionId,	571	providerSessionId: input.scope.thread.providerSessionId,
571	providerInstanceId: input.scope.providerInstanceId,	572	providerInstanceId: input.scope.thread.providerInstanceId,
572	});	573	});
573	}	574	}
574	const { connection, requestId, requestContext, requestSequence } = route;	575	const { connection, requestId, requestContext, requestSequence } = route;
...	@@ -594,7 +595,7 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {	...	@@ -594,7 +595,7 @@ export const make = Effect.gen(function* PreviewAutomationBrokerMake() {
594	connectionId: connection.connectionId,	595	connectionId: connection.connectionId,
595	request: {	596	request: {
596	requestId,	597	requestId,
597	threadId: input.scope.threadId,	598	threadId: input.scope.thread.threadId,
598	tabId: requestContext.tabId,	599	tabId: requestContext.tabId,
599	tabIdExplicit: input.tabId !== undefined,	600	tabIdExplicit: input.tabId !== undefined,
600	operation: input.operation,	601	operation: input.operation,

apps/server/src/mcp/ThreadMetadataMcpService.test.ts+95-3

...	@@ -12,9 +12,13 @@ import * as ThreadMetadataMcp from "./ThreadMetadataMcpService.ts";	...	@@ -12,9 +12,13 @@ import * as ThreadMetadataMcp from "./ThreadMetadataMcpService.ts";
12	const threadId = ThreadId.make("thread:metadata-caller");	12	const threadId = ThreadId.make("thread:metadata-caller");
13	const scope: McpInvocationContext.McpInvocationScope = {	13	const scope: McpInvocationContext.McpInvocationScope = {
14	environmentId: EnvironmentId.make("environment:metadata-test"),	14	environmentId: EnvironmentId.make("environment:metadata-test"),
15	threadId,	15	requestNamespace: "provider-session:metadata-test",
16	providerSessionId: "provider-session:metadata-test",	16	thread: {
17	providerInstanceId: ProviderInstanceId.make("codex"),	17	threadId,
		18	providerSessionId: "provider-session:metadata-test",
		19	providerInstanceId: ProviderInstanceId.make("codex"),
		20	},
		21	client: undefined,
18	capabilities: new Set(["orchestration"]),	22	capabilities: new Set(["orchestration"]),
19	issuedAt: 1,	23	issuedAt: 1,
20	};	24	};
...	@@ -74,3 +78,91 @@ it.effect("keeps calling-thread storage failures as orchestration errors", () =>	...	@@ -74,3 +78,91 @@ it.effect("keeps calling-thread storage failures as orchestration errors", () =>
74	expect(error.code).toBe("orchestration_error");	78	expect(error.code).toBe("orchestration_error");
75	}),	79	}),
76	);	80	);
		81
		82	it.effect("refuses to change a thread that runs above the caller's modes", () =>
		83	Effect.gen(function* () {
		84	const fullAccessThread = ThreadId.make("thread:metadata-full-access");
		85	const shells = new Map([
		86	[
		87	threadId,
		88	{
		89	id: threadId,
		90	projectId: "project",
		91	runtimeMode: "auto",
		92	interactionMode: "default",
		93	activeRunId: "run-live",
		94	archivedAt: null,
		95	providerInstanceId: "codex",
		96	deletedAt: null,
		97	},
		98	],
		99	[
		100	fullAccessThread,
		101	{
		102	id: fullAccessThread,
		103	projectId: "project",
		104	runtimeMode: "full-access",
		105	interactionMode: "default",
		106	deletedAt: null,
		107	},
		108	],
		109	]);
		110	const error = yield* Effect.gen(function* () {
		111	const service = yield* ThreadMetadataMcp.ThreadMetadataMcpService;
		112	return yield* service.update(scope, {
		113	threadId: fullAccessThread,
		114	action: "rename",
		115	title: "Renamed from a narrower thread",
		116	});
		117	}).pipe(
		118	Effect.provide(serviceLayer((id) => Effect.succeed((shells.get(id) ?? null) as never))),
		119	Effect.flip,
		120	);
		121
		122	expect(error.code).toBe("runtime_mode_escalation_denied");
		123	}),
		124	);
		125
		126	it.effect("refuses another thread's metadata to a thread caller whose run has ended", () =>
		127	Effect.gen(function* () {
		128	const otherThread = ThreadId.make("thread:metadata-other");
		129	const shells = new Map([
		130	[
		131	threadId,
		132	{
		133	id: threadId,
		134	projectId: "project",
		135	runtimeMode: "full-access",
		136	interactionMode: "default",
		137	activeRunId: null,
		138	archivedAt: null,
		139	providerInstanceId: "codex",
		140	deletedAt: null,
		141	},
		142	],
		143	[
		144	otherThread,
		145	{
		146	id: otherThread,
		147	projectId: "project",
		148	runtimeMode: "approval-required",
		149	interactionMode: "default",
		150	deletedAt: null,
		151	},
		152	],
		153	]);
		154	const error = yield* Effect.gen(function* () {
		155	const service = yield* ThreadMetadataMcp.ThreadMetadataMcpService;
		156	return yield* service.update(scope, {
		157	threadId: otherThread,
		158	action: "rename",
		159	title: "Renamed after the run ended",
		160	});
		161	}).pipe(
		162	Effect.provide(serviceLayer((id) => Effect.succeed((shells.get(id) ?? null) as never))),
		163	Effect.flip,
		164	);
		165
		166	expect(error.code).toBe("parent_not_active");
		167	}),
		168	);

apps/server/src/mcp/ThreadMetadataMcpService.ts+52-22

 @@ -16,6 +16,7 @@ import * as Layer from "effect/Layer";
 import * as ThreadManagementService from "../orchestration-v2/ThreadManagementService.ts";
 import type { McpInvocationScope } from "./McpInvocationContext.ts";
+import { assertTargetWithinLimits } from "./threadAccess.ts";
 export class ThreadMetadataMcpService extends Context.Service<
   ThreadMetadataMcpService,
 @@ -57,7 +58,7 @@ function commandId(input: {
     [
       "command",
       "mcp",
-      stablePart(input.scope.providerSessionId),
+      stablePart(input.scope.requestNamespace),
       "thread-update",
       stablePart(input.threadId),
       stablePart(input.action),
 @@ -146,36 +147,65 @@ const make = Effect.gen(function* () {
       );
     }
-    const parentShell = yield* threadManagement
+    const threadId = input.threadId ?? scope.thread?.threadId;
-      .getThreadShell(scope.threadId)
+    if (threadId === undefined) {
-      .pipe(
+      return yield* failure(
-        Effect.mapError((error) =>
+        "target_required",
-          failure(
+        "Pass threadId: this MCP client is not running inside a T3 thread.",
-            "orchestration_error",
-            `Unable to locate calling thread ${scope.threadId}: ${errorMessage(error)}`,
-          ),
-        ),
       );
-    if (parentShell === null) {
-      return yield* failure("thread_not_found", `Calling thread ${scope.threadId} was not found.`);
     }
-    const parent = yield* threadManagement
+    const shell = yield* threadManagement
-      .getThreadRecords(scope.threadId, [])
+      .getThreadShell(threadId)
       .pipe(
         Effect.mapError((error) =>
           failure(
             "orchestration_error",
-            `Unable to read calling thread ${scope.threadId}: ${errorMessage(error)}`,
+            `Unable to locate thread ${threadId}: ${errorMessage(error)}`,
           ),
         ),
       );
-    const threadId = input.threadId ?? scope.threadId;
+    if (shell === null || shell.deletedAt !== null) {
-    const target =
+      return yield* failure("thread_not_found", `Thread ${threadId} was not found.`);
-      threadId === scope.threadId
+    }
-        ? parent
+    // Another thread may only be changed if it runs within the caller's own modes.
-        : yield* threadManagement
+    if (threadId !== scope.thread?.threadId) {
-            .getProjectThreadRecords({ projectId: parent.thread.projectId, threadId }, [])
+      const limits =
-            .pipe(Effect.mapError(threadLookupFailure));
+        scope.thread === undefined
+          ? {
+              runtimeMode: scope.client?.runtimeModeCeiling ?? ("approval-required" as const),
+              interactionMode: "default" as const,
+            }
+          : yield* threadManagement.getThreadShell(scope.thread.threadId).pipe(
+              Effect.mapError((error) =>
+                failure(
+                  "orchestration_error",
+                  `Unable to locate calling thread: ${errorMessage(error)}`,
+                ),
+              ),
+              Effect.flatMap((caller) =>
+                caller === null
+                  ? Effect.fail(failure("thread_not_found", "The calling thread was not found."))
+                  : // Like every other cross-thread write, a thread caller needs its live run.
+                    caller.archivedAt !== null ||
+                      caller.activeRunId === null ||
+                      caller.providerInstanceId !== scope.thread?.providerInstanceId
+                    ? Effect.fail(
+                        failure(
+                          "parent_not_active",
+                          "The calling provider no longer owns an active thread run.",
+                        ),
+                      )
+                    : Effect.succeed({
+                        runtimeMode: caller.runtimeMode,
+                        interactionMode: caller.interactionMode,
+                      }),
+              ),
+            );
+      yield* assertTargetWithinLimits(limits, shell);
+    }
+    const target = yield* threadManagement
+      .getProjectThreadRecords({ projectId: shell.projectId, threadId }, [])
+      .pipe(Effect.mapError(threadLookupFailure));
     const requestKey =
       input.clientRequestId === undefined
         ? yield* crypto.randomUUIDv4.pipe(Effect.orDie)

apps/server/src/mcp/WorktreeMcpService.test.ts+7-3

 @@ -42,9 +42,13 @@ const makeScope = (
   capabilities: ReadonlySet<McpInvocationContext.McpCapability>,
 ): McpInvocationContext.McpInvocationScope => ({
   environmentId,
-  threadId,
+  requestNamespace: "provider-session-worktree-test",
-  providerSessionId: "provider-session-worktree-test",
+  thread: {
-  providerInstanceId: ProviderInstanceId.make("claudeAgent"),
+    threadId,
+    providerSessionId: "provider-session-worktree-test",
+    providerInstanceId: ProviderInstanceId.make("claudeAgent"),
+  },
+  client: undefined,
   capabilities,
   issuedAt: 1,
 });

apps/server/src/mcp/WorktreeMcpService.ts+43-26

 @@ -23,7 +23,7 @@ import * as ProjectService from "../project/ProjectService.ts";
 import * as ProjectSetupScriptRunner from "../project/ProjectSetupScriptRunner.ts";
 import * as ServerSettings from "../serverSettings.ts";
 import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts";
-import type { McpInvocationScope } from "./McpInvocationContext.ts";
+import type { McpInvocationScope, McpThreadInvocationScope } from "./McpInvocationContext.ts";
 export class WorktreeMcpService extends Context.Service<
   WorktreeMcpService,
 @@ -70,6 +70,17 @@ const make = Effect.gen(function* () {
   // one untracked on disk.
   const handoffThreadsInFlight = new Set<string>();
+  // Worktree tools act on the calling thread's own checkout binding.
+  const requireThreadScope = (scope: McpInvocationScope) =>
+    scope.thread === undefined
+      ? Effect.fail(
+          failure(
+            "thread_credential_required",
+            "Worktree handoff and status act as the calling T3 thread, so they need an agent running inside T3 Code.",
+          ),
+        )
+      : Effect.succeed(scope as McpThreadInvocationScope);
   const requireCapability = (scope: McpInvocationScope) =>
     scope.capabilities.has("worktree")
       ? Effect.void
 @@ -77,23 +88,23 @@ const make = Effect.gen(function* () {
           failure("capability_denied", "This MCP credential does not grant worktree capabilities."),
         );
-  const loadThread = (scope: McpInvocationScope) =>
+  const loadThread = (scope: McpThreadInvocationScope) =>
-    threadManagement.getThreadRecords(scope.threadId, []).pipe(
+    threadManagement.getThreadRecords(scope.thread.threadId, []).pipe(
       Effect.mapError((error) =>
         error._tag === "OrchestratorProjectionError"
-          ? failure("thread_not_found", `Thread '${scope.threadId}' was not found.`)
+          ? failure("thread_not_found", `Thread '${scope.thread.threadId}' was not found.`)
           : failure(
               "operation_failed",
-              `Unable to read thread ${scope.threadId}: ${errorMessage(error)}`,
+              `Unable to read thread ${scope.thread.threadId}: ${errorMessage(error)}`,
             ),
       ),
       Effect.filterOrFail(
         (projection) => projection.thread.deletedAt === null,
-        () => failure("thread_not_found", `Thread '${scope.threadId}' was not found.`),
+        () => failure("thread_not_found", `Thread '${scope.thread.threadId}' was not found.`),
       ),
     );
-  const loadProject = (scope: McpInvocationScope, projectId: ProjectId) =>
+  const loadProject = (scope: McpThreadInvocationScope, projectId: ProjectId) =>
     projects.getById(projectId).pipe(
       asOperationFailed(`Unable to read project ${projectId}`),
       Effect.flatMap(
 @@ -102,7 +113,7 @@ const make = Effect.gen(function* () {
             Effect.fail(
               failure(
                 "project_not_found",
-                `Project '${projectId}' was not found for thread '${scope.threadId}'.`,
+                `Project '${projectId}' was not found for thread '${scope.thread.threadId}'.`,
               ),
             ),
           onSome: Effect.succeed,
 @@ -115,11 +126,13 @@ const make = Effect.gen(function* () {
     asOperationFailed("Unable to read server settings"),
   );
-  const handoffIds = (scope: McpInvocationScope) =>
+  const handoffIds = (scope: McpThreadInvocationScope) =>
     crypto.randomUUIDv4.pipe(
       Effect.map((uuid) => {
         const part = (kind: string, operation: string) =>
-          [kind, "mcp", encodeURIComponent(scope.providerSessionId), operation, uuid].join(":");
+          [kind, "mcp", encodeURIComponent(scope.thread.providerSessionId), operation, uuid].join(
+            ":",
+          );
         return {
           commandId: CommandId.make(part("command", "worktree-handoff")),
           continuationCommandId: CommandId.make(part("command", "worktree-continuation")),
 @@ -130,13 +143,13 @@ const make = Effect.gen(function* () {
     );
   const performHandoff = Effect.fn("WorktreeMcpService.performHandoff")(function* (
-    scope: McpInvocationScope,
+    scope: McpThreadInvocationScope,
     input: WorktreeMcpHandoffInput,
   ) {
     const alreadyInWorktree = (worktreePath: string) =>
       failure(
         "already_in_worktree",
-        `Thread '${scope.threadId}' is already attached to worktree '${worktreePath}'.`,
+        `Thread '${scope.thread.threadId}' is already attached to worktree '${worktreePath}'.`,
       );
     const projection = yield* loadThread(scope);
 @@ -148,7 +161,7 @@ const make = Effect.gen(function* () {
     if (projection.thread.archivedAt !== null) {
       return yield* failure(
         "invalid_request",
-        `Thread '${scope.threadId}' is archived and cannot be handed off to a worktree.`,
+        `Thread '${scope.thread.threadId}' is archived and cannot be handed off to a worktree.`,
       );
     }
 @@ -263,7 +276,7 @@ const make = Effect.gen(function* () {
           Effect.catchCause((cause: Cause.Cause<unknown>) => {
             const detail = errorMessage(Cause.squash(cause));
             return Effect.logWarning(logMessage, {
-              threadId: scope.threadId,
+              threadId: scope.thread.threadId,
               worktreePath,
               detail,
             }).pipe(Effect.as({ status: "failed", detail } as const));
 @@ -301,14 +314,14 @@ const make = Effect.gen(function* () {
           if (recheck.thread.archivedAt !== null) {
             return yield* failure(
               "invalid_request",
-              `Thread '${scope.threadId}' was archived while the worktree was being created; the handoff was rolled back.`,
+              `Thread '${scope.thread.threadId}' was archived while the worktree was being created; the handoff was rolled back.`,
             );
           }
           yield* threadManagement
             .dispatch({
               type: "thread.metadata.update",
               commandId: ids.commandId,
-              threadId: scope.threadId,
+              threadId: scope.thread.threadId,
               branch: worktree.worktree.refName,
               worktreePath,
               expectedWorktreePath: null,
 @@ -357,7 +370,7 @@ const make = Effect.gen(function* () {
                   .sendToThread({
                     projectId: projection.thread.projectId,
                     commandId: ids.continuationCommandId,
-                    threadId: scope.threadId,
+                    threadId: scope.thread.threadId,
                     messageId: ids.continuationMessageId,
                     text: input.continuationPrompt,
                     attachments: [],
 @@ -386,7 +399,7 @@ const make = Effect.gen(function* () {
         if (input.runSetupScript ?? true) {
           setupScript = yield* setupScriptRunner
             .runForThread({
-              threadId: scope.threadId,
+              threadId: scope.thread.threadId,
               projectId: projection.thread.projectId,
               projectCwd,
               worktreePath,
 @@ -430,8 +443,9 @@ const make = Effect.gen(function* () {
   });
   const handoff: WorktreeMcpService["Service"]["handoff"] = Effect.fn("WorktreeMcpService.handoff")(
-    function* (scope, input) {
+    function* (callerScope, input) {
-      yield* requireCapability(scope);
+      yield* requireCapability(callerScope);
+      const scope = yield* requireThreadScope(callerScope);
       // uninterruptibleMask: the guard acquisition and the registration of the
       // releasing finalizer happen with no interruptible gap in between. An
       // interrupt landing between a bare add() and the start of an ensured
 @@ -439,17 +453,19 @@ const make = Effect.gen(function* () {
       // handoff for this thread until restart.
       return yield* Effect.uninterruptibleMask((restore) =>
         Effect.suspend(() => {
-          if (handoffThreadsInFlight.has(scope.threadId)) {
+          if (handoffThreadsInFlight.has(scope.thread.threadId)) {
             return Effect.fail(
               failure(
                 "handoff_in_progress",
-                `A worktree handoff is already in progress for thread '${scope.threadId}'.`,
+                `A worktree handoff is already in progress for thread '${scope.thread.threadId}'.`,
               ),
             );
           }
-          handoffThreadsInFlight.add(scope.threadId);
+          handoffThreadsInFlight.add(scope.thread.threadId);
           return restore(performHandoff(scope, input)).pipe(
-            Effect.ensuring(Effect.sync(() => handoffThreadsInFlight.delete(scope.threadId))),
+            Effect.ensuring(
+              Effect.sync(() => handoffThreadsInFlight.delete(scope.thread.threadId)),
+            ),
           );
         }),
       );
 @@ -457,8 +473,9 @@ const make = Effect.gen(function* () {
   );
   const status: WorktreeMcpService["Service"]["status"] = Effect.fn("WorktreeMcpService.status")(
-    function* (scope) {
+    function* (callerScope) {
-      yield* requireCapability(scope);
+      yield* requireCapability(callerScope);
+      const scope = yield* requireThreadScope(callerScope);
       const projection = yield* loadThread(scope);
       const project = yield* loadProject(scope, projection.thread.projectId);

apps/server/src/mcp/threadAccess.ts+127-28

...	@@ -2,6 +2,9 @@ import type { ProjectionRecordField } from "../orchestration-v2/ProjectionStore.	...	@@ -2,6 +2,9 @@ import type { ProjectionRecordField } from "../orchestration-v2/ProjectionStore.
2	import {	2	import {
3	CommandId,	3	CommandId,
4	OrchestratorMcpFailure,	4	OrchestratorMcpFailure,
		5	type ProjectId,
		6	type ProviderInteractionMode,
		7	type RuntimeMode,
5	type ThreadId,	8	type ThreadId,
6	type OrchestrationV2ThreadShell,	9	type OrchestrationV2ThreadShell,
7	} from "@t3tools/contracts";	10	} from "@t3tools/contracts";
...	@@ -18,6 +21,24 @@ export const unavailable = () =>	...	@@ -18,6 +21,24 @@ export const unavailable = () =>
18	message: "The operation could not be completed.",	21	message: "The operation could not be completed.",
19	});	22	});
20		23
		24	/**
		25	* The most a caller may hand to the threads it targets. A thread caller is
		26	* capped by its own thread's modes; an OAuth client by the ceiling chosen
		27	* when it was approved.
		28	*/
		29	export interface CallerLimits {
		30	readonly runtimeMode: RuntimeMode;
		31	readonly interactionMode: ProviderInteractionMode;
		32	}
		33
		34	export interface Caller {
		35	readonly scope: McpInvocationContext.McpInvocationScope;
		36	readonly threads: ThreadManagement.ThreadManagementService["Service"];
		37	/** The calling thread, absent for a client signed in from outside T3. */
		38	readonly caller: OrchestrationV2ThreadShell \| undefined;
		39	readonly limits: CallerLimits;
		40	}
		41
21	export const readCaller = Effect.fn("mcp.readCaller")(function* () {	42	export const readCaller = Effect.fn("mcp.readCaller")(function* () {
22	const scope = yield* McpInvocationContext.McpInvocationContext;	43	const scope = yield* McpInvocationContext.McpInvocationContext;
23	if (!scope.capabilities.has("orchestration")) {	44	if (!scope.capabilities.has("orchestration")) {
...	@@ -27,26 +48,54 @@ export const readCaller = Effect.fn("mcp.readCaller")(function* () {	...	@@ -27,26 +48,54 @@ export const readCaller = Effect.fn("mcp.readCaller")(function* () {
27	});	48	});
28	}	49	}
29	const threads = yield* ThreadManagement.ThreadManagementService;	50	const threads = yield* ThreadManagement.ThreadManagementService;
30	const caller = yield* threads.getThreadShell(scope.threadId).pipe(Effect.mapError(unavailable));	51	if (scope.thread === undefined) {
		52	return {
		53	scope,
		54	threads,
		55	caller: undefined,
		56	limits: {
		57	runtimeMode: scope.client?.runtimeModeCeiling ?? "approval-required",
		58	interactionMode: "default",
		59	},
		60	} satisfies Caller;
		61	}
		62	const caller = yield* threads
		63	.getThreadShell(scope.thread.threadId)
		64	.pipe(Effect.mapError(unavailable));
31	if (caller === null \|\| caller.deletedAt !== null) {	65	if (caller === null \|\| caller.deletedAt !== null) {
32	return yield* new OrchestratorMcpFailure({	66	return yield* new OrchestratorMcpFailure({
33	code: "thread_not_found",	67	code: "thread_not_found",
34	message: "The calling thread was not found.",	68	message: "The calling thread was not found.",
35	});	69	});
36	}	70	}
37	return { scope, threads, caller };	71	return {
		72	scope,
		73	threads,
		74	caller,
		75	limits: { runtimeMode: caller.runtimeMode, interactionMode: caller.interactionMode },
		76	} satisfies Caller;
38	});	77	});
39		78
40	function assertLiveCaller({	79	/**
41	caller,	80	* A caller may change another thread only if that thread runs within the
42	scope,	81	* caller's own modes. Its own thread is always within them.
43	}: {	82	*/
44	caller: OrchestrationV2ThreadShell;	83	export const assertTargetWithinLimits = (
45	scope: McpInvocationContext.McpInvocationScope;	84	limits: CallerLimits,
46	}) {	85	target: { readonly runtimeMode: RuntimeMode; readonly interactionMode: ProviderInteractionMode },
		86	) =>
		87	OrchestrationMcp.resolveRuntimeMode(limits.runtimeMode, target.runtimeMode).pipe(
		88	Effect.andThen(
		89	OrchestrationMcp.resolveInteractionMode(limits.interactionMode, target.interactionMode),
		90	),
		91	Effect.asVoid,
		92	);
		93
		94	function assertLiveCaller({ caller, scope }: Caller) {
		95	if (caller === undefined) return Effect.void;
47	return caller.archivedAt !== null \|\|	96	return caller.archivedAt !== null \|\|
48	caller.activeRunId === null \|\|	97	caller.activeRunId === null \|\|
49	caller.providerInstanceId !== scope.providerInstanceId	98	caller.providerInstanceId !== scope.thread?.providerInstanceId
50	? Effect.fail(	99	? Effect.fail(
51	new OrchestratorMcpFailure({	100	new OrchestratorMcpFailure({
52	code: "parent_not_active",	101	code: "parent_not_active",
...	@@ -55,34 +104,91 @@ function assertLiveCaller({	...	@@ -55,34 +104,91 @@ function assertLiveCaller({
55	)	104	)
56	: Effect.void;	105	: Effect.void;
57	}	106	}
		107
		108	/**
		109	* Mutations from a thread need that thread's live run, so an agent whose turn
		110	* ended cannot keep acting. An OAuth client has no run; its session and
		111	* ceiling are its authority.
		112	*/
58	export const readMutationCaller = Effect.fn("mcp.readMutationCaller")(function* () {	113	export const readMutationCaller = Effect.fn("mcp.readMutationCaller")(function* () {
59	const context = yield* readCaller();	114	const context = yield* readCaller();
60	yield* assertLiveCaller(context);	115	yield* assertLiveCaller(context);
61	return context;	116	return context;
62	});	117	});
63		118
64	/** Resolve the credential's project before looking up a caller-supplied thread. */	119	/**
		120	* Actions that change the environment itself (projects, preferences, launching
		121	* outside a project) need full access: a thread caller in full-access/default
		122	* mode, or a client approved with a full-access ceiling.
		123	*/
		124	export const readFullAccessCaller = Effect.fn("mcp.readFullAccessCaller")(function* (
		125	message: string,
		126	) {
		127	const context = yield* readMutationCaller();
		128	if (
		129	(context.caller !== undefined && context.caller.archivedAt !== null) \|\|
		130	context.limits.runtimeMode !== "full-access" \|\|
		131	context.limits.interactionMode !== "default"
		132	) {
		133	return yield* new OrchestratorMcpFailure({ code: "capability_denied", message });
		134	}
		135	return context;
		136	});
		137
		138	/** A target project: the one passed, else the calling thread's. */
		139	export const resolveProjectId = (context: Caller, projectId: ProjectId \| undefined) =>
		140	projectId !== undefined
		141	? Effect.succeed(projectId)
		142	: context.caller !== undefined
		143	? Effect.succeed(context.caller.projectId)
		144	: Effect.fail(
		145	new OrchestratorMcpFailure({
		146	code: "target_required",
		147	message: "Pass projectId: this MCP client is not running inside a T3 thread.",
		148	}),
		149	);
		150
		151	/** A target thread: the one passed, else the calling thread. */
		152	const resolveThreadId = (context: Caller, threadId: ThreadId \| undefined) =>
		153	threadId !== undefined
		154	? Effect.succeed(threadId)
		155	: context.caller !== undefined
		156	? Effect.succeed(context.caller.id)
		157	: Effect.fail(
		158	new OrchestratorMcpFailure({
		159	code: "target_required",
		160	message: "Pass threadId: this MCP client is not running inside a T3 thread.",
		161	}),
		162	);
		163
		164	/** Load a target thread anywhere in the environment; an omitted id means the calling thread. */
65	export const readThread = Effect.fn("mcp.readThread")(function* <	165	export const readThread = Effect.fn("mcp.readThread")(function* <
66	K extends ProjectionRecordField = never,	166	K extends ProjectionRecordField = never,
67	>(threadId?: ThreadId, fields: ReadonlyArray<K> = []) {	167	>(threadId?: ThreadId, fields: ReadonlyArray<K> = []) {
68	const { scope, threads, caller } = yield* readCaller();	168	const context = yield* readCaller();
69	const projection = yield* threads	169	const targetId = yield* resolveThreadId(context, threadId);
70	.getProjectThreadRecords(	170	const shell = yield* context.threads.getThreadShell(targetId).pipe(Effect.mapError(unavailable));
71	{ projectId: caller.projectId, threadId: threadId ?? caller.id },	171	if (shell === null \|\| shell.deletedAt !== null) {
72	fields,	172	return yield* new OrchestratorMcpFailure({
73	{ turnItemTypes: ["user_input_request"] },	173	code: "thread_not_found",
74	)	174	message: "The thread was not found.",
		175	});
		176	}
		177	const projection = yield* context.threads
		178	.getProjectThreadRecords({ projectId: shell.projectId, threadId: targetId }, fields, {
		179	turnItemTypes: ["user_input_request"],
		180	})
75	.pipe(	181	.pipe(
76	Effect.mapError((error) =>	182	Effect.mapError((error) =>
77	error._tag === "ThreadManagementThreadNotFoundError"	183	error._tag === "ThreadManagementThreadNotFoundError"
78	? new OrchestratorMcpFailure({	184	? new OrchestratorMcpFailure({
79	code: "thread_not_found",	185	code: "thread_not_found",
80	message: "The thread was not found in the calling project.",	186	message: "The thread was not found.",
81	})	187	})
82	: unavailable(),	188	: unavailable(),
83	),	189	),
84	);	190	);
85	return { scope, threads, caller, projection };	191	return { ...context, projection };
86	});	192	});
87		193
88	export const readWritableThread = Effect.fn("mcp.readWritableThread")(function* <	194	export const readWritableThread = Effect.fn("mcp.readWritableThread")(function* <
...	@@ -90,14 +196,7 @@ export const readWritableThread = Effect.fn("mcp.readWritableThread")(function*	...	@@ -90,14 +196,7 @@ export const readWritableThread = Effect.fn("mcp.readWritableThread")(function*
90	>(threadId?: ThreadId, fields: ReadonlyArray<K> = []) {	196	>(threadId?: ThreadId, fields: ReadonlyArray<K> = []) {
91	const context = yield* readThread(threadId, fields);	197	const context = yield* readThread(threadId, fields);
92	yield* assertLiveCaller(context);	198	yield* assertLiveCaller(context);
93	yield* OrchestrationMcp.resolveRuntimeMode(	199	yield* assertTargetWithinLimits(context.limits, context.projection.thread);
94	context.caller.runtimeMode,
95	context.projection.thread.runtimeMode,
96	);
97	yield* OrchestrationMcp.resolveInteractionMode(
98	context.caller.interactionMode,
99	context.projection.thread.interactionMode,
100	);
101	return context;	200	return context;
102	});	201	});
103		202

apps/server/src/mcp/toolkits/attachment/handlers.ts+3-3

...	@@ -47,7 +47,7 @@ export const AttachmentHandlersLive = AttachmentToolkit.toLayer({	...	@@ -47,7 +47,7 @@ export const AttachmentHandlersLive = AttachmentToolkit.toLayer({
47	}),	47	}),
48	t3_thread_send_attachments: (input) =>	48	t3_thread_send_attachments: (input) =>
49	Effect.gen(function* () {	49	Effect.gen(function* () {
50	const { caller, projection, scope } = yield* readWritableThread(input.threadId, ["messages"]);	50	const { caller, projection } = yield* readWritableThread(input.threadId, ["messages"]);
51	if (projection.thread.archivedAt !== null)	51	if (projection.thread.archivedAt !== null)
52	return yield* new OrchestratorMcpFailure({	52	return yield* new OrchestratorMcpFailure({
53	code: "invalid_request",	53	code: "invalid_request",
...	@@ -60,11 +60,11 @@ export const AttachmentHandlersLive = AttachmentToolkit.toLayer({	...	@@ -60,11 +60,11 @@ export const AttachmentHandlersLive = AttachmentToolkit.toLayer({
60	const commandId = yield* newCommandId();	60	const commandId = yield* newCommandId();
61	const messageId = MessageId.make(commandId);	61	const messageId = MessageId.make(commandId);
62	const result = yield* ThreadMessageIntake.sendToThread({	62	const result = yield* ThreadMessageIntake.sendToThread({
63	projectId: caller.projectId,	63	projectId: projection.thread.projectId,
64	threadId: projection.thread.id,	64	threadId: projection.thread.id,
65	commandId,	65	commandId,
66	messageId,	66	messageId,
67	senderThreadId: scope.threadId,	67	...(caller === undefined ? {} : { senderThreadId: caller.id }),
68	text: input.message ?? "",	68	text: input.message ?? "",
69	attachments,	69	attachments,
70	mode: "auto",	70	mode: "auto",

apps/server/src/mcp/toolkits/attachment/tools.ts+1-1

...	@@ -47,7 +47,7 @@ const AttachmentDiscardTool = Tool.make("t3_attachment_discard", {	...	@@ -47,7 +47,7 @@ const AttachmentDiscardTool = Tool.make("t3_attachment_discard", {
47	const AttachmentSendTool = Tool.make("t3_thread_send_attachments", {	47	const AttachmentSendTool = Tool.make("t3_thread_send_attachments", {
48	...shared,	48	...shared,
49	description:	49	description:
50	"Send uploaded attachments to this thread or another thread in the calling project. Each call is a new message, without a retry key. Acceptance does not mean the provider can consume the attachment or has finished the turn. The target cannot have broader permission modes than the caller; failures retain claimed files when dispatch outcome is uncertain.",	50	"Send uploaded attachments to this thread or any other thread in this environment. Each call is a new message, without a retry key. Acceptance does not mean the provider can consume the attachment or has finished the turn. The target cannot have broader permission modes than the caller; failures retain claimed files when dispatch outcome is uncertain.",
51	parameters: Schema.Struct({	51	parameters: Schema.Struct({
52	threadId: Schema.optional(ThreadId),	52	threadId: Schema.optional(ThreadId),
53	message: Schema.optional(Schema.String.check(Schema.isMaxLength(120000))),	53	message: Schema.optional(Schema.String.check(Schema.isMaxLength(120000))),

apps/server/src/mcp/toolkits/core.test.ts+244-3

...	@@ -14,7 +14,11 @@ import { McpAttachmentInput } from "./attachment/input.ts";	...	@@ -14,7 +14,11 @@ import { McpAttachmentInput } from "./attachment/input.ts";
14	import { McpSchema, McpServer, Tool } from "effect/unstable/ai";	14	import { McpSchema, McpServer, Tool } from "effect/unstable/ai";
15		15
16	import { OrchestratorProjectionError } from "../../orchestration-v2/Orchestrator.ts";	16	import { OrchestratorProjectionError } from "../../orchestration-v2/Orchestrator.ts";
		17	import * as ProviderAdapterRegistry from "../../orchestration-v2/ProviderAdapterRegistry.ts";
17	import * as ThreadManagement from "../../orchestration-v2/ThreadManagementService.ts";	18	import * as ThreadManagement from "../../orchestration-v2/ThreadManagementService.ts";
		19	import * as ProjectService from "../../project/ProjectService.ts";
		20	import * as ProviderRegistry from "../../provider/Services/ProviderRegistry.ts";
		21	import * as ScheduledTaskService from "../../scheduledTasks/ScheduledTaskService.ts";
18	import * as McpHttpServer from "../McpHttpServer.ts";	22	import * as McpHttpServer from "../McpHttpServer.ts";
19	import * as McpInvocationContext from "../McpInvocationContext.ts";	23	import * as McpInvocationContext from "../McpInvocationContext.ts";
20	import { OrchestratorToolkit } from "./orchestrator/tools.ts";	24	import { OrchestratorToolkit } from "./orchestrator/tools.ts";
...	@@ -78,9 +82,13 @@ it("publishes unique tool names with reference-free object-root inputs", () => {	...	@@ -78,9 +82,13 @@ it("publishes unique tool names with reference-free object-root inputs", () => {
78	const threadId = ThreadId.make("mcp-core-thread");	82	const threadId = ThreadId.make("mcp-core-thread");
79	const scope: McpInvocationContext.McpInvocationScope = {	83	const scope: McpInvocationContext.McpInvocationScope = {
80	environmentId: EnvironmentId.make("mcp-core-environment"),	84	environmentId: EnvironmentId.make("mcp-core-environment"),
81	threadId,	85	requestNamespace: "mcp-core-session",
82	providerSessionId: "mcp-core-session",	86	thread: {
83	providerInstanceId: ProviderInstanceId.make("codex"),	87	threadId,
		88	providerSessionId: "mcp-core-session",
		89	providerInstanceId: ProviderInstanceId.make("codex"),
		90	},
		91	client: undefined,
84	issuedAt: 0,	92	issuedAt: 0,
85	capabilities: new Set(["orchestration"]),	93	capabilities: new Set(["orchestration"]),
86	};	94	};
...	@@ -207,3 +215,236 @@ it.effect("resolves reused attachment references from stored metadata", () =>	...	@@ -207,3 +215,236 @@ it.effect("resolves reused attachment references from stored metadata", () =>
207	expect(failure.code).toBe("invalid_request");	215	expect(failure.code).toBe("invalid_request");
208	}),	216	}),
209	);	217	);
		218
		219	const clientScope = (
		220	runtimeModeCeiling: "approval-required" \| "auto-accept-edits" \| "auto" \| "full-access",
		221	): McpInvocationContext.McpInvocationScope => ({
		222	environmentId: EnvironmentId.make("mcp-core-environment"),
		223	requestNamespace: "client:session-1",
		224	thread: undefined,
		225	client: { sessionId: "session-1", label: "Claude Code", runtimeModeCeiling },
		226	issuedAt: 0,
		227	capabilities: new Set(["orchestration", "worktree", "pull-requests"]),
		228	});
		229
		230	it.effect("a client caller targets any thread within its ceiling and cannot act as a thread", () =>
		231	Effect.gen(function* () {
		232	const server = yield* McpServer.McpServer;
		233	const call = (
		234	name: string,
		235	args: Record<string, unknown>,
		236	invocation: McpInvocationContext.McpInvocationScope,
		237	) =>
		238	server
		239	.callTool({ name, arguments: args })
		240	.pipe(
		241	Effect.provideService(McpInvocationContext.McpInvocationContext, invocation),
		242	Effect.provideService(McpSchema.McpServerClient, client),
		243	);
		244
		245	const untargeted = yield* call("t3_thread_organize", { action: "pin" }, clientScope("auto"));
		246	expect(untargeted.structuredContent).toMatchObject({ code: "target_required" });
		247
		248	const pinned = yield* call(
		249	"t3_thread_organize",
		250	{ action: "pin", threadId: "other-project-thread" },
		251	clientScope("auto"),
		252	);
		253	expect(pinned.isError).toBe(false);
		254	expect(pinned.structuredContent).toMatchObject({ sequence: 7 });
		255
		256	const aboveCeiling = yield* call(
		257	"t3_thread_organize",
		258	{ action: "pin", threadId: "other-project-thread" },
		259	clientScope("approval-required"),
		260	);
		261	expect(aboveCeiling.structuredContent).toMatchObject({
		262	code: "runtime_mode_escalation_denied",
		263	});
		264
		265	const forked = yield* call(
		266	"t3_thread_fork",
		267	{ sourcePoint: { type: "latest_stable" } },
		268	clientScope("auto"),
		269	);
		270	expect(forked.structuredContent).toMatchObject({ code: "target_required" });
		271	}).pipe(
		272	Effect.provide(
		273	McpHttpServer.ThreadToolkitRegistrationLive.pipe(
		274	Layer.provideMerge(McpServer.McpServer.layer),
		275	Layer.provide(NodeCrypto.layer),
		276	Layer.provide(
		277	Layer.mock(ThreadManagement.ThreadManagementService)({
		278	getThreadShell: () =>
		279	Effect.succeed({
		280	id: ThreadId.make("other-project-thread"),
		281	projectId: "other-project",
		282	deletedAt: null,
		283	} as never),
		284	getProjectThreadRecords: () =>
		285	Effect.succeed({
		286	thread: {
		287	id: ThreadId.make("other-project-thread"),
		288	projectId: "other-project",
		289	runtimeMode: "auto",
		290	interactionMode: "default",
		291	deletedAt: null,
		292	},
		293	} as never),
		294	dispatch: () => Effect.succeed({ sequence: 7 } as never),
		295	}),
		296	),
		297	),
		298	),
		299	),
		300	);
		301
		302	it.effect("refuses act-as-caller tools to a client caller", () =>
		303	Effect.gen(function* () {
		304	const server = yield* McpServer.McpServer;
		305	const result = yield* server
		306	.callTool({
		307	name: "delegate_task",
		308	arguments: { task: "Review", mode: "async" },
		309	})
		310	.pipe(
		311	Effect.provideService(
		312	McpInvocationContext.McpInvocationContext,
		313	clientScope("full-access"),
		314	),
		315	Effect.provideService(McpSchema.McpServerClient, client),
		316	);
		317	expect(result.structuredContent).toMatchObject({ code: "thread_credential_required" });
		318	}).pipe(
		319	Effect.provide(
		320	McpHttpServer.OrchestratorToolkitRegistrationLive.pipe(
		321	Layer.provideMerge(McpServer.McpServer.layer),
		322	Layer.provide(NodeCrypto.layer),
		323	Layer.provide(Layer.mock(ThreadManagement.ThreadManagementService)({})),
		324	Layer.provide(Layer.mock(ProviderRegistry.ProviderRegistry)({})),
		325	Layer.provide(Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({})),
		326	Layer.provide(Layer.mock(ScheduledTaskService.ScheduledTaskService)({})),
		327	Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
		328	),
		329	),
		330	),
		331	);
		332
		333	it.effect("a caller cannot rewrite a scheduled task that runs above its own modes", () =>
		334	Effect.gen(function* () {
		335	const server = yield* McpServer.McpServer;
		336	const call = (name: string, args: Record<string, unknown>) =>
		337	server
		338	.callTool({ name, arguments: args })
		339	.pipe(
		340	Effect.provideService(McpInvocationContext.McpInvocationContext, clientScope("auto")),
		341	Effect.provideService(McpSchema.McpServerClient, client),
		342	);
		343	const update = yield* call("update_scheduled_task", {
		344	scheduledTaskId: "task-full-access",
		345	prompt: "Run something else",
		346	});
		347	expect(update.structuredContent).toMatchObject({ code: "runtime_mode_escalation_denied" });
		348	const remove = yield* call("delete_scheduled_task", { scheduledTaskId: "task-full-access" });
		349	expect(remove.structuredContent).toMatchObject({ code: "runtime_mode_escalation_denied" });
		350	const allowed = yield* call("update_scheduled_task", {
		351	scheduledTaskId: "task-auto",
		352	enabled: false,
		353	});
		354	expect(allowed.isError).toBe(false);
		355	}).pipe(
		356	Effect.provide(
		357	McpHttpServer.OrchestratorToolkitRegistrationLive.pipe(
		358	Layer.provideMerge(McpServer.McpServer.layer),
		359	Layer.provide(NodeCrypto.layer),
		360	Layer.provide(Layer.mock(ThreadManagement.ThreadManagementService)({})),
		361	Layer.provide(Layer.mock(ProviderRegistry.ProviderRegistry)({})),
		362	Layer.provide(Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({})),
		363	Layer.provide(
		364	Layer.mock(ScheduledTaskService.ScheduledTaskService)({
		365	list: () =>
		366	Effect.succeed({
		367	tasks: [
		368	scheduledTask("task-full-access", "full-access"),
		369	scheduledTask("task-auto", "auto"),
		370	],
		371	}),
		372	upsert: (input) =>
		373	Effect.succeed({
		374	task: { ...(scheduledTask(input.id ?? "task-auto", "auto") as object), ...input },
		375	} as never),
		376	}),
		377	),
		378	Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
		379	),
		380	),
		381	),
		382	);
		383
		384	function scheduledTask(id: string, runtimeMode: "auto" \| "full-access"): never {
		385	return {
		386	id,
		387	title: id,
		388	prompt: "Check the build",
		389	enabled: true,
		390	projectId: "project-a",
		391	threadId: null,
		392	schedule: { type: "interval", everyMs: 3_600_000 },
		393	workspaceStrategy: { type: "worktree", baseRef: "main", startFromOrigin: true },
		394	modelSelection: { instanceId: "codex", model: "gpt-5" },
		395	runtimeMode,
		396	interactionMode: "default",
		397	createdBy: "user",
		398	creationSource: "web",
		399	nextRunAt: null,
		400	lastRunStatus: "never",
		401	lastRunAt: null,
		402	lastRunThreadId: null,
		403	lastRunError: null,
		404	runCount: 0,
		405	createdAt: "2026-10-01T00:00:00.000Z",
		406	updatedAt: "2026-10-01T00:00:00.000Z",
		407	} as never;
		408	}
		409
		410	it.effect("a caller cannot interrupt a thread that runs above its own modes", () =>
		411	Effect.gen(function* () {
		412	const server = yield* McpServer.McpServer;
		413	const result = yield* server
		414	.callTool({ name: "t3_thread_interrupt", arguments: { threadId: "full-access-thread" } })
		415	.pipe(
		416	Effect.provideService(McpInvocationContext.McpInvocationContext, clientScope("auto")),
		417	Effect.provideService(McpSchema.McpServerClient, client),
		418	);
		419	expect(result.structuredContent).toMatchObject({ code: "runtime_mode_escalation_denied" });
		420	}).pipe(
		421	Effect.provide(
		422	McpHttpServer.OrchestratorToolkitRegistrationLive.pipe(
		423	Layer.provideMerge(McpServer.McpServer.layer),
		424	Layer.provide(NodeCrypto.layer),
		425	Layer.provide(
		426	Layer.mock(ThreadManagement.ThreadManagementService)({
		427	getThreadShell: () =>
		428	Effect.succeed({ projectId: "project-a", deletedAt: null } as never),
		429	getProjectThreadRecords: () =>
		430	Effect.succeed({
		431	thread: {
		432	id: ThreadId.make("full-access-thread"),
		433	projectId: "project-a",
		434	runtimeMode: "full-access",
		435	interactionMode: "default",
		436	deletedAt: null,
		437	},
		438	runs: [],
		439	} as never),
		440	interruptThread: () => Effect.die("interrupt must not dispatch above the ceiling"),
		441	}),
		442	),
		443	Layer.provide(Layer.mock(ProviderRegistry.ProviderRegistry)({})),
		444	Layer.provide(Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({})),
		445	Layer.provide(Layer.mock(ScheduledTaskService.ScheduledTaskService)({})),
		446	Layer.provide(Layer.mock(ProjectService.ProjectService)({})),
		447	),
		448	),
		449	),
		450	);

apps/server/src/mcp/toolkits/device/handlers.ts+6-6

...	@@ -66,7 +66,7 @@ export function agentDeviceQuickStart(	...	@@ -66,7 +66,7 @@ export function agentDeviceQuickStart(
66	].join("\n");	66	].join("\n");
67	}	67	}
68		68
69	const requireDeviceAccess = McpInvocationContext.requireMcpCapability("device").pipe(	69	const requireDeviceAccess = McpInvocationContext.requireThreadMcpCapability("device").pipe(
70	Effect.mapError(	70	Effect.mapError(
71	() =>	71	() =>
72	new DeviceToolUnavailableError({	72	new DeviceToolUnavailableError({
...	@@ -132,7 +132,7 @@ const handlers = {	...	@@ -132,7 +132,7 @@ const handlers = {
132	}	132	}
133	const hostId = input?.hostId;	133	const hostId = input?.hostId;
134	const open = state.sessions	134	const open = state.sessions
135	.filter((session) => session.threadId === scope.threadId)	135	.filter((session) => session.threadId === scope.thread.threadId)
136	.map((session) => ({ hostId: session.hostId, deviceId: session.deviceId }));	136	.map((session) => ({ hostId: session.hostId, deviceId: session.deviceId }));
137	return {	137	return {
138	hostStatuses: Object.fromEntries(	138	hostStatuses: Object.fromEntries(
...	@@ -159,12 +159,12 @@ const handlers = {	...	@@ -159,12 +159,12 @@ const handlers = {
159	const target = yield* pickDevice(state.devices, input);	159	const target = yield* pickDevice(state.devices, input);
160	// Resolve consent and agent connectivity before booting or registering a session.	160	// Resolve consent and agent connectivity before booting or registering a session.
161	const agentArgs = yield* devices.agentTarget({	161	const agentArgs = yield* devices.agentTarget({
162	threadId: scope.threadId,	162	threadId: scope.thread.threadId,
163	hostId: target.hostId,	163	hostId: target.hostId,
164	deviceId: target.id,	164	deviceId: target.id,
165	});	165	});
166	const session = yield* devices.open({	166	const session = yield* devices.open({
167	threadId: scope.threadId,	167	threadId: scope.thread.threadId,
168	hostId: target.hostId,	168	hostId: target.hostId,
169	deviceId: target.id,	169	deviceId: target.id,
170	platform: target.platform,	170	platform: target.platform,
...	@@ -207,7 +207,7 @@ const handlers = {	...	@@ -207,7 +207,7 @@ const handlers = {
207	Effect.gen(function* () {	207	Effect.gen(function* () {
208	const scope = yield* requireDeviceAccess;	208	const scope = yield* requireDeviceAccess;
209	const devices = yield* DeviceService.DeviceService;	209	const devices = yield* DeviceService.DeviceService;
210	const sessions = yield* devices.sessionsForThread(scope.threadId);	210	const sessions = yield* devices.sessionsForThread(scope.thread.threadId);
211	const target =	211	const target =
212	input.deviceId !== undefined	212	input.deviceId !== undefined
213	? { hostId: input.hostId ?? LOCAL_DEVICE_HOST_ID, deviceId: input.deviceId }	213	? { hostId: input.hostId ?? LOCAL_DEVICE_HOST_ID, deviceId: input.deviceId }
...	@@ -234,7 +234,7 @@ const handlers = {	...	@@ -234,7 +234,7 @@ const handlers = {
234	const scope = yield* requireDeviceAccess;	234	const scope = yield* requireDeviceAccess;
235	const devices = yield* DeviceService.DeviceService;	235	const devices = yield* DeviceService.DeviceService;
236	yield* devices.close({	236	yield* devices.close({
237	threadId: scope.threadId,	237	threadId: scope.thread.threadId,
238	...(input.hostId === undefined ? {} : { hostId: input.hostId }),	238	...(input.hostId === undefined ? {} : { hostId: input.hostId }),
239	...(input.deviceId === undefined ? {} : { deviceId: input.deviceId }),	239	...(input.deviceId === undefined ? {} : { deviceId: input.deviceId }),
240	...(input.shutdown === undefined ? {} : { shutdown: input.shutdown }),	240	...(input.shutdown === undefined ? {} : { shutdown: input.shutdown }),

apps/server/src/mcp/toolkits/environment/handlers.ts+16-20

 @@ -4,7 +4,7 @@ import * as Environment from "../../../environment/ServerEnvironment.ts";
 import * as ThreadCommandExecutor from "../../../orchestration-v2/ThreadCommandExecutor.ts";
 import * as Settings from "../../../serverSettings.ts";
 import * as McpInvocationContext from "../../McpInvocationContext.ts";
-import { readCaller, readMutationCaller, unavailable } from "../../threadAccess.ts";
+import { readCaller, readFullAccessCaller, unavailable } from "../../threadAccess.ts";
 import { EnvironmentToolkit } from "./tools.ts";
 export function preferences(settings: ServerSettings) {
 @@ -30,7 +30,11 @@ export function preferences(settings: ServerSettings) {
 }
 const access = (writable = false) =>
   Effect.gen(function* () {
-    const context = yield* writable ? readMutationCaller() : readCaller();
+    const context = yield* writable
+      ? readFullAccessCaller(
+          "Preference updates require a live full-access/default thread or a full-access client.",
+        )
+      : readCaller();
     const environment = yield* Environment.ServerEnvironment;
     const descriptor = yield* environment.getDescriptor;
     if (descriptor.environmentId !== context.scope.environmentId)
 @@ -57,23 +61,15 @@ export const EnvironmentHandlersLive = EnvironmentToolkit.toLayer({
     Effect.gen(function* () {
       const scope = yield* McpInvocationContext.McpInvocationContext;
       const executor = yield* ThreadCommandExecutor.ThreadCommandExecutor;
-      return yield* executor.withLock(
+      const update = Effect.gen(function* () {
-        scope.threadId,
+        const { settings } = yield* access(true);
-        Effect.gen(function* () {
+        return preferences(
-          const { caller, settings } = yield* access(true);
+          yield* settings.updateSettings(patch).pipe(Effect.mapError(unavailable)),
-          if (
+        );
-            caller.archivedAt !== null ||
+      });
-            caller.runtimeMode !== "full-access" ||
+      // A thread caller serializes with its own turn; a client has no thread to lock.
-            caller.interactionMode !== "default"
+      return yield* scope.thread === undefined
-          )
+        ? update
-            return yield* new OrchestratorMcpFailure({
+        : executor.withLock(scope.thread.threadId, update);
-              code: "capability_denied",
-              message: "Preference updates require a live full-access/default thread.",
-            });
-          return preferences(
-            yield* settings.updateSettings(patch).pipe(Effect.mapError(unavailable)),
-          );
-        }),
-      );
     }),
 });

apps/server/src/mcp/toolkits/orchestrator/handlers.ts+2-2

...	@@ -36,11 +36,11 @@ const handlers = {	...	@@ -36,11 +36,11 @@ const handlers = {
36	const service = yield* OrchestratorMcpService.OrchestratorMcpService;	36	const service = yield* OrchestratorMcpService.OrchestratorMcpService;
37	return yield* service.scheduleTask(scope, input);	37	return yield* service.scheduleTask(scope, input);
38	}),	38	}),
39	list_scheduled_tasks: () =>	39	list_scheduled_tasks: (input) =>
40	Effect.gen(function* () {	40	Effect.gen(function* () {
41	const scope = yield* McpInvocationContext.McpInvocationContext;	41	const scope = yield* McpInvocationContext.McpInvocationContext;
42	const service = yield* OrchestratorMcpService.OrchestratorMcpService;	42	const service = yield* OrchestratorMcpService.OrchestratorMcpService;
43	return yield* service.listScheduledTasks(scope);	43	return yield* service.listScheduledTasks(scope, input);
44	}),	44	}),
45	update_scheduled_task: (input) =>	45	update_scheduled_task: (input) =>
46	Effect.gen(function* () {	46	Effect.gen(function* () {

apps/server/src/mcp/toolkits/orchestrator/tools.ts+14-12

apps/server/src/mcp/toolkits/preview/handlers.ts+3-3

apps/server/src/mcp/toolkits/previewControls/handlers.test.ts+7-3

 @@ -35,9 +35,13 @@ it.effect.each([
       const effective = resolveProjectSettings(settings, projectId).settings;
       const scope: McpInvocationContext.McpInvocationScope = {
         environmentId: EnvironmentId.make("preview-controls-environment"),
-        threadId,
+        requestNamespace: "preview-controls-provider-session",
-        providerSessionId: "preview-controls-provider-session",
+        thread: {
-        providerInstanceId: ProviderInstanceId.make("codex"),
+          threadId,
+          providerSessionId: "preview-controls-provider-session",
+          providerInstanceId: ProviderInstanceId.make("codex"),
+        },
+        client: undefined,
         capabilities: new Set(effective.enableAgentBrowserAccess ? ["preview"] : []),
         issuedAt: 0,
       };

apps/server/src/mcp/toolkits/previewControls/handlers.ts+4-4

apps/server/src/mcp/toolkits/project/handlers.test.ts+106-9

...	@@ -5,6 +5,7 @@ import {	...	@@ -5,6 +5,7 @@ import {
5	ProviderInstanceId,	5	ProviderInstanceId,
6	ThreadId,	6	ThreadId,
7	type OrchestrationV2ThreadShell,	7	type OrchestrationV2ThreadShell,
		8	type Project as ProjectRecord,
8	} from "@t3tools/contracts";	9	} from "@t3tools/contracts";
9	import * as NodeCrypto from "@effect/platform-node/NodeCrypto";	10	import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
10	import * as NodeServices from "@effect/platform-node/NodeServices";	11	import * as NodeServices from "@effect/platform-node/NodeServices";
...	@@ -44,9 +45,13 @@ it.effect("attributes a launched thread's first message to the calling thread",	...	@@ -44,9 +45,13 @@ it.effect("attributes a launched thread's first message to the calling thread",
44	NodeCrypto.layer,	45	NodeCrypto.layer,
45	Layer.succeed(McpInvocationContext.McpInvocationContext, {	46	Layer.succeed(McpInvocationContext.McpInvocationContext, {
46	environmentId: EnvironmentId.make("environment"),	47	environmentId: EnvironmentId.make("environment"),
47	threadId: sourceThreadId,	48	requestNamespace: "session",
48	providerSessionId: "session",	49	thread: {
49	providerInstanceId,	50	threadId: sourceThreadId,
		51	providerSessionId: "session",
		52	providerInstanceId,
		53	},
		54	client: undefined,
50	issuedAt: 0,	55	issuedAt: 0,
51	capabilities: new Set(["orchestration" as const]),	56	capabilities: new Set(["orchestration" as const]),
52	}),	57	}),
...	@@ -106,9 +111,13 @@ it.effect("launches a scratch thread into the Scratch project", () =>	...	@@ -106,9 +111,13 @@ it.effect("launches a scratch thread into the Scratch project", () =>
106	NodeCrypto.layer,	111	NodeCrypto.layer,
107	Layer.succeed(McpInvocationContext.McpInvocationContext, {	112	Layer.succeed(McpInvocationContext.McpInvocationContext, {
108	environmentId: EnvironmentId.make("environment"),	113	environmentId: EnvironmentId.make("environment"),
109	threadId: sourceThreadId,	114	requestNamespace: "session",
110	providerSessionId: "session",	115	thread: {
111	providerInstanceId,	116	threadId: sourceThreadId,
		117	providerSessionId: "session",
		118	providerInstanceId,
		119	},
		120	client: undefined,
112	issuedAt: 0,	121	issuedAt: 0,
113	capabilities: new Set(["orchestration" as const]),	122	capabilities: new Set(["orchestration" as const]),
114	}),	123	}),
...	@@ -194,9 +203,13 @@ it.effect("starts a project from just a title when workspaceRoot is omitted", ()	...	@@ -194,9 +203,13 @@ it.effect("starts a project from just a title when workspaceRoot is omitted", ()
194	NodeCrypto.layer,	203	NodeCrypto.layer,
195	Layer.succeed(McpInvocationContext.McpInvocationContext, {	204	Layer.succeed(McpInvocationContext.McpInvocationContext, {
196	environmentId: EnvironmentId.make("environment"),	205	environmentId: EnvironmentId.make("environment"),
197	threadId: sourceThreadId,	206	requestNamespace: "session",
198	providerSessionId: "session",	207	thread: {
199	providerInstanceId,	208	threadId: sourceThreadId,
		209	providerSessionId: "session",
		210	providerInstanceId,
		211	},
		212	client: undefined,
200	issuedAt: 0,	213	issuedAt: 0,
201	capabilities: new Set(["orchestration" as const]),	214	capabilities: new Set(["orchestration" as const]),
202	}),	215	}),
...	@@ -263,3 +276,87 @@ it.effect("starts a project from just a title when workspaceRoot is omitted", ()	...	@@ -263,3 +276,87 @@ it.effect("starts a project from just a title when workspaceRoot is omitted", ()
263	expect(named).toEqual(["Pinball Stats"]);	276	expect(named).toEqual(["Pinball Stats"]);
264	}),	277	}),
265	);	278	);
		279
		280	const clientLaunchHarness = (input: {
		281	readonly runtimeModeCeiling: "approval-required" \| "auto-accept-edits" \| "auto" \| "full-access";
		282	readonly launched: Array<ThreadLaunch.ThreadLaunchInput>;
		283	}) => {
		284	const projectId = ProjectId.make("project:client-target");
		285	const modelSelection = { instanceId: ProviderInstanceId.make("claude"), model: "claude-opus" };
		286	const dependencies = Layer.mergeAll(
		287	NodeCrypto.layer,
		288	Layer.succeed(McpInvocationContext.McpInvocationContext, {
		289	environmentId: EnvironmentId.make("environment"),
		290	requestNamespace: "client:session-1",
		291	thread: undefined,
		292	client: {
		293	sessionId: "session-1",
		294	label: "Claude Code",
		295	runtimeModeCeiling: input.runtimeModeCeiling,
		296	},
		297	issuedAt: 0,
		298	capabilities: new Set(["orchestration" as const]),
		299	}),
		300	Layer.mock(ThreadManagement.ThreadManagementService)({}),
		301	Layer.mock(ThreadLaunch.ThreadLaunchService)({
		302	launch: (launch) => {
		303	input.launched.push(launch);
		304	return Effect.succeed({
		305	threadId: launch.threadId,
		306	projection: {
		307	thread: {
		308	id: launch.threadId,
		309	projectId: launch.projectId,
		310	modelSelection: launch.modelSelection,
		311	},
		312	runs: [],
		313	},
		314	resumed: false,
		315	} as unknown as ThreadLaunch.ThreadLaunchResult);
		316	},
		317	}),
		318	Layer.mock(Project.ProjectService)({
		319	getById: (id) =>
		320	Effect.succeed(
		321	id === projectId
		322	? Option.some({ id, defaultModelSelection: modelSelection } as unknown as ProjectRecord)
		323	: Option.none(),
		324	),
		325	}),
		326	Layer.mock(ManagedProjectFolders.ManagedProjectFolders)({ namedProjectsRoot: "/projects" }),
		327	NodeServices.layer,
		328	ServerConfig.layerTest(process.cwd(), { prefix: "t3-client-launch-" }).pipe(
		329	Layer.provide(NodeServices.layer),
		330	),
		331	);
		332	return { projectId, modelSelection, dependencies };
		333	};
		334
		335	it.effect("a client launches at its ceiling with the project's default model", () =>
		336	Effect.gen(function* () {
		337	const launched: Array<ThreadLaunch.ThreadLaunchInput> = [];
		338	const { projectId, modelSelection, dependencies } = clientLaunchHarness({
		339	runtimeModeCeiling: "auto-accept-edits",
		340	launched,
		341	});
		342	const toolkit = yield* ProjectToolkit.pipe(
		343	Effect.provide(ProjectHandlersLive.pipe(Layer.provide(dependencies))),
		344	);
		345	const handle = (params: Parameters<typeof toolkit.handle<"t3_thread_launch">>[1]) =>
		346	toolkit
		347	.handle("t3_thread_launch", params)
		348	.pipe(Stream.unwrap, Stream.runCollect, Effect.provide(dependencies));
		349
		350	const result = yield* handle({ title: "Fix", projectId, message: "Fix the bug" });
		351	expect(result.at(-1)?.result).toMatchObject({ projectId, modelSelection });
		352	expect(launched[0]?.runtimeMode).toBe("auto-accept-edits");
		353	expect(launched[0]?.initialMessage?.senderThreadId).toBeUndefined();
		354
		355	const escalated = yield* handle({ title: "Fix", projectId, runtimeMode: "full-access" });
		356	expect(escalated.at(-1)?.result).toMatchObject({ code: "runtime_mode_escalation_denied" });
		357
		358	const untargeted = yield* handle({ title: "Fix" });
		359	expect(untargeted.at(-1)?.result).toMatchObject({ code: "target_required" });
		360	expect(launched).toHaveLength(1);
		361	}),
		362	);

apps/server/src/mcp/toolkits/project/handlers.ts+45-18

 @@ -6,7 +6,15 @@ import * as Claims from "../../../orchestration-v2/AttachmentClaims.ts";
 import * as Project from "../../../project/ProjectService.ts";
 import * as ManagedProjectFolders from "../../../project/ManagedProjectFolders.ts";
 import * as Repositories from "../../../sourceControl/SourceControlRepositoryService.ts";
-import { newCommandId, readCaller, readMutationCaller, unavailable } from "../../threadAccess.ts";
+import { resolveRuntimeMode } from "../../OrchestratorMcpService.ts";
+import {
+  newCommandId,
+  readCaller,
+  readFullAccessCaller,
+  readMutationCaller,
+  resolveProjectId,
+  unavailable,
+} from "../../threadAccess.ts";
 import { ProjectToolkit } from "./tools.ts";
 function projectFailure(error: Project.ProjectServiceError) {
 @@ -25,27 +33,30 @@ const access = Effect.gen(function* () {
   return yield* Project.ProjectService;
 });
 const mutation = Effect.gen(function* () {
-  const { caller } = yield* readMutationCaller();
+  yield* readFullAccessCaller(
-  if (
+    "Project changes require a live full-access/default calling thread or a full-access client.",
-    caller.archivedAt !== null ||
+  );
-    caller.runtimeMode !== "full-access" ||
-    caller.interactionMode !== "default"
-  )
-    return yield* new OrchestratorMcpFailure({
-      code: "capability_denied",
-      message: "Project changes require a live full-access/default calling thread.",
-    });
   return yield* Project.ProjectService;
 });
 export const ProjectHandlersLive = ProjectToolkit.toLayer({
   t3_thread_launch: (input) =>
     Effect.gen(function* () {
-      const { caller, scope } = yield* readMutationCaller();
+      const context = yield* readMutationCaller();
-      if (caller.runtimeMode !== "full-access" || caller.interactionMode !== "default")
+      const { caller, limits } = context;
+      // A thread caller launches only as itself (full-access/default), as before. A client
+      // launches anything up to its ceiling.
+      if (
+        caller !== undefined &&
+        (caller.runtimeMode !== "full-access" || caller.interactionMode !== "default")
+      )
         return yield* new OrchestratorMcpFailure({
           code: "capability_denied",
           message: "Project launches require a full-access/default calling thread.",
         });
+      const runtimeMode = yield* resolveRuntimeMode(
+        limits.runtimeMode,
+        input.runtimeMode ?? caller?.runtimeMode,
+      );
       const commandId = yield* newCommandId();
       const threadId = ThreadId.make(commandId);
       const messageId = MessageId.make(commandId);
 @@ -76,22 +87,38 @@ export const ProjectHandlersLive = ProjectToolkit.toLayer({
                   }),
               ),
             )).projectId
-          : (input.projectId ?? caller.projectId);
+          : yield* resolveProjectId(context, input.projectId);
+      const modelSelection =
+        input.modelSelection ??
+        caller?.modelSelection ??
+        (yield* Project.ProjectService.pipe(
+          Effect.flatMap((projects) => projects.getById(projectId)),
+          Effect.mapError(unavailable),
+          Effect.map((project) =>
+            Option.getOrUndefined(Option.flatMapNullishOr(project, (p) => p.defaultModelSelection)),
+          ),
+        ));
+      if (modelSelection === undefined)
+        return yield* new OrchestratorMcpFailure({
+          code: "invalid_request",
+          message:
+            "Pass modelSelection: the project has no default model. orchestrator_capabilities lists providers and models.",
+        });
       const result = yield* ThreadMessageIntake.launchThread({
         commandId,
         threadId,
         projectId,
         title: input.title,
-        modelSelection: input.modelSelection ?? caller.modelSelection,
+        modelSelection,
-        runtimeMode: input.runtimeMode ?? caller.runtimeMode,
+        runtimeMode,
-        interactionMode: input.interactionMode ?? caller.interactionMode,
+        interactionMode: input.interactionMode ?? caller?.interactionMode ?? "default",
         workspaceStrategy: input.workspaceStrategy ?? { type: "root" },
         ...(input.message === undefined && attachments.length === 0
           ? {}
           : {
               initialMessage: {
                 messageId,
-                senderThreadId: scope.threadId,
+                ...(caller === undefined ? {} : { senderThreadId: caller.id }),
                 text: input.message ?? "",
                 attachments,
               },

apps/server/src/mcp/toolkits/project/tools.ts+1-1

...	@@ -102,7 +102,7 @@ const ProjectCloneTool = Tool.make("t3_project_clone", {	...	@@ -102,7 +102,7 @@ const ProjectCloneTool = Tool.make("t3_project_clone", {
102	const ThreadLaunchTool = Tool.make("t3_thread_launch", {	102	const ThreadLaunchTool = Tool.make("t3_thread_launch", {
103	...shared,	103	...shared,
104	description:	104	description:
105	'Create an ordinary TOP-LEVEL thread with an explicit workspace binding before its agent starts. Use this when the user requests independent work, a new thread, or a PR stack in its own worktree; use delegate_task for child subagents. Set workspaceStrategy to {type:"worktree",baseRef:"parent-branch",branch:"new-branch",startFromOrigin:false} for a new worktree based on local commits, or {type:"existing_worktree",worktreePath:"/absolute/path",branch:"existing-branch"} to use an existing checkout. For upstream commits, set startFromOrigin:true. Omitted workspaceStrategy means the project root, NOT the caller\'s worktree. Omit projectId/modelSelection/modes to inherit those settings. Set scratch:true instead of projectId for a thread without a project: it runs in a fresh folder of its own, outside any repository. Put the task in message. Do not ask the agent to create its own worktree via shell: that does not update the thread binding. Each call creates a new launch with no retry key; retain threadId and use t3_thread_read/t3_thread_wait to follow preparation. After errors or lost responses, inspect t3_thread_list before retrying. Attachments must be pending uploads. Requires a full-access/default caller.',	105	'Create an ordinary TOP-LEVEL thread with an explicit workspace binding before its agent starts. Use this when the user requests independent work, a new thread, or a PR stack in its own worktree; use delegate_task for child subagents. Set workspaceStrategy to {type:"worktree",baseRef:"parent-branch",branch:"new-branch",startFromOrigin:false} for a new worktree based on local commits, or {type:"existing_worktree",worktreePath:"/absolute/path",branch:"existing-branch"} to use an existing checkout. For upstream commits, set startFromOrigin:true. Omitted workspaceStrategy means the project root, NOT the caller\'s worktree. Omit projectId/modelSelection/modes to inherit those settings from the calling thread; a caller outside a T3 thread must pass projectId and gets the project\'s default model. Set scratch:true instead of projectId for a thread without a project: it runs in a fresh folder of its own, outside any repository. Put the task in message. Do not ask the agent to create its own worktree via shell: that does not update the thread binding. Each call creates a new launch with no retry key; retain threadId and use t3_thread_read/t3_thread_wait to follow preparation. After errors or lost responses, inspect t3_thread_list before retrying. Attachments must be pending uploads. Requires a full-access/default calling thread; a caller outside a T3 thread launches up to its approved permission mode.',
106	parameters: Schema.Struct({	106	parameters: Schema.Struct({
107	projectId: Schema.optional(ProjectId),	107	projectId: Schema.optional(ProjectId),
108	scratch: Schema.optional(	108	scratch: Schema.optional(

apps/server/src/mcp/toolkits/pullRequests/handlers.test.ts+7-3

 @@ -38,9 +38,13 @@ const invocation = (
   capabilities: ReadonlyArray<McpInvocationContext.McpCapability>,
 ): McpInvocationContext.McpInvocationScope => ({
   environmentId: EnvironmentId.make("environment-1"),
-  threadId: THREAD_ID,
+  requestNamespace: "provider-session-1",
-  providerSessionId: "provider-session-1",
+  thread: {
-  providerInstanceId: ProviderInstanceId.make("codex"),
+    threadId: THREAD_ID,
+    providerSessionId: "provider-session-1",
+    providerInstanceId: ProviderInstanceId.make("codex"),
+  },
+  client: undefined,
   capabilities: new Set(capabilities),
   issuedAt: 1,
 });

apps/server/src/mcp/toolkits/pullRequests/handlers.ts+60-9

 @@ -26,6 +26,7 @@ import * as Option from "effect/Option";
 import * as Orchestrator from "../../../orchestration-v2/Orchestrator.ts";
 import * as ProjectService from "../../../project/ProjectService.ts";
 import * as McpInvocationContext from "../../McpInvocationContext.ts";
+import { assertTargetWithinLimits } from "../../threadAccess.ts";
 import {
   type ListThreadPullRequestsResult,
   PullRequestLinkFailedError,
 @@ -38,6 +39,8 @@ import {
   type PullRequestTargetInput,
   PullRequestWatchFailedError,
   PullRequestThreadNotFoundError,
+  PullRequestThreadAboveLimitsError,
+  PullRequestThreadRequiredError,
   PullRequestsToolkit,
   type ThreadPullRequestEntry,
 } from "./tools.ts";
 @@ -168,18 +171,64 @@ const make = Effect.gen(function* () {
       | typeof PullRequestUnlinkFailedError
       | typeof PullRequestListFailedError
       | typeof PullRequestWatchFailedError,
+    requested: ThreadId | undefined,
   ) {
     const scope = yield* McpInvocationContext.requireMcpCapability("pull-requests");
+    const threadId = requested ?? scope.thread?.threadId;
+    if (threadId === undefined) {
+      return yield* new PullRequestThreadRequiredError();
+    }
     const thread = yield* engine
-      .getThreadShell(scope.threadId)
+      .getThreadShell(threadId)
       .pipe(Effect.map(Option.fromNullishOr))
       .pipe(Effect.mapError((cause) => new Failure({ cause })));
-    if (Option.isNone(thread)) {
+    if (Option.isNone(thread) || thread.value.deletedAt !== null) {
-      return yield* new PullRequestThreadNotFoundError({ threadId: scope.threadId });
+      return yield* new PullRequestThreadNotFoundError({ threadId });
     }
     return thread.value;
   });
+  /**
+   * A thread whose pull requests the caller may change: its own, or one that
+   * runs within the caller's modes.
+   */
+  const requireWritableThread = Effect.fn("PullRequestsToolkit.requireWritableThread")(function* (
+    Failure:
+      | typeof PullRequestLinkFailedError
+      | typeof PullRequestUnlinkFailedError
+      | typeof PullRequestWatchFailedError,
+    requested: ThreadId | undefined,
+  ) {
+    const thread = yield* requireThread(Failure, requested);
+    const scope = yield* McpInvocationContext.McpInvocationContext;
+    if (thread.id === scope.thread?.threadId) return thread;
+    const limits =
+      scope.thread === undefined
+        ? {
+            runtimeMode: scope.client?.runtimeModeCeiling ?? ("approval-required" as const),
+            interactionMode: "default" as const,
+          }
+        : yield* engine.getThreadShell(scope.thread.threadId).pipe(
+            Effect.mapError((cause) => new Failure({ cause })),
+            Effect.map((caller) =>
+              // A thread caller changes other threads only while its own run is live.
+              caller === null ||
+              caller.archivedAt !== null ||
+              caller.activeRunId === null ||
+              caller.providerInstanceId !== scope.thread?.providerInstanceId
+                ? undefined
+                : { runtimeMode: caller.runtimeMode, interactionMode: caller.interactionMode },
+            ),
+          );
+    if (limits === undefined) {
+      return yield* new PullRequestThreadAboveLimitsError({ threadId: thread.id });
+    }
+    yield* assertTargetWithinLimits(limits, thread).pipe(
+      Effect.mapError(() => new PullRequestThreadAboveLimitsError({ threadId: thread.id })),
+    );
+    return thread;
+  });
   const projectOf = (
     thread: OrchestrationV2ThreadShell,
     Failure:
 @@ -217,7 +266,7 @@ const make = Effect.gen(function* () {
     input: PullRequestTargetInput,
     watching: boolean,
   ) {
-    const thread = yield* requireThread(PullRequestWatchFailedError);
+    const thread = yield* requireWritableThread(PullRequestWatchFailedError, input.threadId);
     const project = yield* projectOf(thread, PullRequestWatchFailedError);
     const target = yield* resolveTarget(input, project);
     const watchedLink = (shell: OrchestrationV2ThreadShell) =>
 @@ -241,7 +290,7 @@ const make = Effect.gen(function* () {
         ...(watching ? { link: { url: target.url, source: "agent" as const } } : {}),
       })
       .pipe(Effect.catchCause(dispatchFailure(PullRequestWatchFailedError)));
-    const after = yield* requireThread(PullRequestWatchFailedError);
+    const after = yield* requireThread(PullRequestWatchFailedError, thread.id);
     return {
       host: target.host,
       repository: target.repository,
 @@ -255,7 +304,7 @@ const make = Effect.gen(function* () {
   return PullRequestsToolkit.of({
     link_pull_request: (input) =>
       Effect.gen(function* () {
-        const thread = yield* requireThread(PullRequestLinkFailedError);
+        const thread = yield* requireWritableThread(PullRequestLinkFailedError, input.threadId);
         const project = yield* projectOf(thread, PullRequestLinkFailedError);
         const target = yield* resolveTarget(input, project);
         const existing = threadPullRequestsOf(thread).find((link) =>
 @@ -285,7 +334,7 @@ const make = Effect.gen(function* () {
       }),
     unlink_pull_request: (input) =>
       Effect.gen(function* () {
-        const thread = yield* requireThread(PullRequestUnlinkFailedError);
+        const thread = yield* requireWritableThread(PullRequestUnlinkFailedError, input.threadId);
         const project = yield* projectOf(thread, PullRequestUnlinkFailedError);
         const target = yield* resolveTarget(input, project);
         if (!threadPullRequestsOf(thread).some((link) => threadPullRequestKeysEqual(link, target)))
 @@ -316,8 +365,10 @@ const make = Effect.gen(function* () {
           wasLinked,
         };
       }),
-    list_thread_pull_requests: () =>
+    list_thread_pull_requests: (input) =>
-      requireThread(PullRequestListFailedError).pipe(Effect.map(listThreadPullRequests)),
+      requireThread(PullRequestListFailedError, input.threadId).pipe(
+        Effect.map(listThreadPullRequests),
+      ),
     watch_pull_request: (input) => setWatching(input, true),
     unwatch_pull_request: (input) => setWatching(input, false),
   });

apps/server/src/mcp/toolkits/pullRequests/tools.ts+32-1

...	@@ -4,6 +4,7 @@ import {	...	@@ -4,6 +4,7 @@ import {
4	PullRequestState,	4	PullRequestState,
5	ThreadPullRequestLinkSource,	5	ThreadPullRequestLinkSource,
6	TrimmedNonEmptyString,	6	TrimmedNonEmptyString,
		7	ThreadId,
7	} from "@t3tools/contracts";	8	} from "@t3tools/contracts";
8	import * as Schema from "effect/Schema";	9	import * as Schema from "effect/Schema";
9	import * as Tool from "effect/unstable/ai/Tool";	10	import * as Tool from "effect/unstable/ai/Tool";
...	@@ -28,6 +29,11 @@ const REGISTER_EVERY_PR =	...	@@ -28,6 +29,11 @@ const REGISTER_EVERY_PR =
28	* the host CLI handed back.	29	* the host CLI handed back.
29	*/	30	*/
30	export const PullRequestTargetInput = Schema.Struct({	31	export const PullRequestTargetInput = Schema.Struct({
		32	threadId: Schema.optional(
		33	ThreadId.annotate({
		34	description: "Thread to act on. Omit for this thread.",
		35	}),
		36	),
31	url: Schema.optional(	37	url: Schema.optional(
32	TrimmedNonEmptyString.annotate({	38	TrimmedNonEmptyString.annotate({
33	description:	39	description:
...	@@ -81,6 +87,24 @@ export class PullRequestHostRequiredError extends Schema.TaggedError<PullRequest	...	@@ -81,6 +87,24 @@ export class PullRequestHostRequiredError extends Schema.TaggedError<PullRequest
81	}	87	}
82	}	88	}
83		89
		90	export class PullRequestThreadRequiredError extends Schema.TaggedError<PullRequestThreadRequiredError>()(
		91	"PullRequestThreadRequiredError",
		92	{},
		93	) {
		94	override get message(): string {
		95	return "Pass threadId: this MCP client is not running inside a T3 thread.";
		96	}
		97	}
		98
		99	export class PullRequestThreadAboveLimitsError extends Schema.TaggedError<PullRequestThreadAboveLimitsError>()(
		100	"PullRequestThreadAboveLimitsError",
		101	{ threadId: Schema.String },
		102	) {
		103	override get message(): string {
		104	return `Thread ${this.threadId} cannot be changed from here: it runs with broader permissions than this caller, or the calling thread has no active run.`;
		105	}
		106	}
		107
84	export class PullRequestThreadNotFoundError extends Schema.TaggedError<PullRequestThreadNotFoundError>()(	108	export class PullRequestThreadNotFoundError extends Schema.TaggedError<PullRequestThreadNotFoundError>()(
85	"PullRequestThreadNotFoundError",	109	"PullRequestThreadNotFoundError",
86	{ threadId: Schema.String },	110	{ threadId: Schema.String },
...	@@ -140,6 +164,8 @@ export const PullRequestToolError = Schema.Union([	...	@@ -140,6 +164,8 @@ export const PullRequestToolError = Schema.Union([
140	PullRequestUrlInvalidError,	164	PullRequestUrlInvalidError,
141	PullRequestTargetIncompleteError,	165	PullRequestTargetIncompleteError,
142	PullRequestHostRequiredError,	166	PullRequestHostRequiredError,
		167	PullRequestThreadRequiredError,
		168	PullRequestThreadAboveLimitsError,
143	PullRequestThreadNotFoundError,	169	PullRequestThreadNotFoundError,
144	PullRequestLinkFailedError,	170	PullRequestLinkFailedError,
145	PullRequestUnlinkFailedError,	171	PullRequestUnlinkFailedError,
...	@@ -245,7 +271,12 @@ const UnlinkPullRequestTool = Tool.make("unlink_pull_request", {	...	@@ -245,7 +271,12 @@ const UnlinkPullRequestTool = Tool.make("unlink_pull_request", {
245	.annotate(Tool.OpenWorld, false);	271	.annotate(Tool.OpenWorld, false);
246		272
247	const ListThreadPullRequestsTool = Tool.make("list_thread_pull_requests", {	273	const ListThreadPullRequestsTool = Tool.make("list_thread_pull_requests", {
248	description: `List the pull requests linked to this thread with their last known host state, and how they chain into stacks (bottom to top). ${REGISTER_EVERY_PR}`,	274	description: `List the pull requests linked to a thread (omit threadId for this thread) with their last known host state, and how they chain into stacks (bottom to top). ${REGISTER_EVERY_PR}`,
		275	parameters: Schema.Struct({
		276	threadId: Schema.optional(
		277	ThreadId.annotate({ description: "Thread to list. Omit for this thread." }),
		278	),
		279	}),
249	success: ListThreadPullRequestsResult,	280	success: ListThreadPullRequestsResult,
250	failure: PullRequestToolError,	281	failure: PullRequestToolError,
251	dependencies,	282	dependencies,

apps/server/src/mcp/toolkits/thread/handlers.ts+23-20

 @@ -13,7 +13,7 @@ import { modelSelectionCommandType } from "@t3tools/shared/model";
 import {
   newCommandId,
   readCaller,
-  readMutationCaller,
+  readFullAccessCaller,
   readThread,
   readWritableThread,
   unavailable,
 @@ -78,22 +78,15 @@ const readQuestion = Effect.fn("mcp.readQuestion")(function* (
 export const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
   run_scheduled_task_now: (input) =>
     Effect.gen(function* () {
-      const { caller } = yield* readMutationCaller();
+      yield* readFullAccessCaller(
-      if (
+        "Running a scheduled task requires a live full-access/default thread or a full-access client.",
-        caller.archivedAt !== null ||
+      );
-        caller.runtimeMode !== "full-access" ||
-        caller.interactionMode !== "default"
-      )
-        return yield* new OrchestratorMcpFailure({
-          code: "capability_denied",
-          message: "Running a scheduled task requires a live full-access/default thread.",
-        });
       const scheduler = yield* ScheduledTasks.ScheduledTaskService;
       const { tasks } = yield* scheduler.list().pipe(Effect.mapError(unavailable));
-      if (!tasks.some((task) => task.id === input.taskId && task.projectId === caller.projectId))
+      if (!tasks.some((task) => task.id === input.taskId))
         return yield* new OrchestratorMcpFailure({
           code: "invalid_request",
-          message: "The task was not found in the calling project.",
+          message: "The scheduled task was not found.",
         });
       const { task } = yield* scheduler
         .runNow({ id: input.taskId })
 @@ -109,13 +102,22 @@ export const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
   t3_thread_search: (input) =>
     Effect.gen(function* () {
       const { caller } = yield* readCaller();
+      const { projectId: requested, ...query } = input;
+      // Like the other project tools, an omitted project means the caller's own; a client
+      // outside a thread searches every project.
+      const projectId = requested ?? caller?.projectId;
       const threadSearch = yield* ThreadSearch.ThreadSearch;
-      const result = yield* threadSearch.search(input).pipe(Effect.mapError(unavailable));
+      const result = yield* threadSearch.search(query).pipe(Effect.mapError(unavailable));
-      return { matches: result.matches.filter((match) => match.projectId === caller.projectId) };
+      return {
+        matches:
+          projectId === undefined
+            ? result.matches
+            : result.matches.filter((match) => match.projectId === projectId),
+      };
     }),
   t3_thread_fork: (input) =>
     Effect.gen(function* () {
-      const { threads, projection } = yield* readWritableThread();
+      const { threads, projection } = yield* readWritableThread(input.threadId);
       const commandId = yield* newCommandId();
       const targetThreadId = ThreadId.make(`${commandId}:fork`);
       const result = yield* threads
 @@ -134,12 +136,13 @@ export const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
     }),
   t3_thread_merge_back: (input) =>
     Effect.gen(function* () {
-      const { threads, caller } = yield* readWritableThread(input.targetThreadId);
+      const context = yield* readWritableThread(input.targetThreadId);
-      const result = yield* threads
+      const source = yield* readWritableThread(input.sourceThreadId);
+      const result = yield* context.threads
         .dispatch({
           type: "thread.merge_back",
           commandId: yield* newCommandId(),
-          sourceThreadId: caller.id,
+          sourceThreadId: source.projection.thread.id,
           targetThreadId: input.targetThreadId,
           sourcePoint: input.sourcePoint,
           createdBy: "agent",
 @@ -179,7 +182,7 @@ export const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
       const {
         threads,
         projection: { thread },
-      } = yield* readWritableThread();
+      } = yield* readWritableThread(input.threadId);
       const type = modelSelectionCommandType(thread.providerInstanceId, input.modelSelection);
       const result = yield* threads
         .dispatch({

apps/server/src/mcp/toolkits/thread/tools.ts+21-12

...	@@ -17,6 +17,7 @@ import {	...	@@ -17,6 +17,7 @@ import {
17	ThreadId,	17	ThreadId,
18	RunId,	18	RunId,
19	NonNegativeInt,	19	NonNegativeInt,
		20	ProjectId,
20	} from "@t3tools/contracts";	21	} from "@t3tools/contracts";
21	import * as Crypto from "effect/Crypto";	22	import * as Crypto from "effect/Crypto";
22	import * as Schema from "effect/Schema";	23	import * as Schema from "effect/Schema";
...	@@ -29,7 +30,7 @@ import * as McpInvocationContext from "../../McpInvocationContext.ts";	...	@@ -29,7 +30,7 @@ import * as McpInvocationContext from "../../McpInvocationContext.ts";
29		30
30	const ThreadOrganizeTool = Tool.make("t3_thread_organize", {	31	const ThreadOrganizeTool = Tool.make("t3_thread_organize", {
31	description:	32	description:
32	"Pin, snooze, settle, archive, or mark a thread unread in the calling project. Omit threadId for this thread. snooze requires snoozedUntil. Existing thread lifecycle rules apply; this does not schedule a future action.",	33	"Pin, snooze, settle, archive, or mark a thread unread. Omit threadId for this thread. snooze requires snoozedUntil. Existing thread lifecycle rules apply; this does not schedule a future action.",
33	parameters: Schema.Struct({	34	parameters: Schema.Struct({
34	threadId: Schema.optional(ThreadId),	35	threadId: Schema.optional(ThreadId),
35	action: Schema.Literals([	36	action: Schema.Literals([
...	@@ -91,7 +92,7 @@ const QueueListTool = Tool.make("t3_queue_list", {	...	@@ -91,7 +92,7 @@ const QueueListTool = Tool.make("t3_queue_list", {
91	.annotate(Tool.Destructive, false);	92	.annotate(Tool.Destructive, false);
92	const QueueReadTool = Tool.make("t3_queue_read", {	93	const QueueReadTool = Tool.make("t3_queue_read", {
93	...commandTool,	94	...commandTool,
94	description: "Read up to 16,000 characters of a queued message in the calling project.",	95	description: "Read up to 16,000 characters of a queued message. Omit threadId for this thread.",
95	parameters: Schema.Struct(queueTarget),	96	parameters: Schema.Struct(queueTarget),
96	success: queueEntry,	97	success: queueEntry,
97	})	98	})
...	@@ -146,7 +147,7 @@ const pendingRequest = Schema.Struct({	...	@@ -146,7 +147,7 @@ const pendingRequest = Schema.Struct({
146	const PendingRequestListTool = Tool.make("t3_pending_request_list", {	147	const PendingRequestListTool = Tool.make("t3_pending_request_list", {
147	...commandTool,	148	...commandTool,
148	description:	149	description:
149	"List pending user questions in a thread in the calling project. Approval requests are not included.",	150	"List pending user questions in a thread. Omit threadId for this thread. Approval requests are not included.",
150	parameters: Schema.Struct({ threadId: Schema.optional(ThreadId) }),	151	parameters: Schema.Struct({ threadId: Schema.optional(ThreadId) }),
151	success: Schema.Struct({ requestIds: Schema.Array(RuntimeRequestId) }),	152	success: Schema.Struct({ requestIds: Schema.Array(RuntimeRequestId) }),
152	})	153	})
...	@@ -173,7 +174,7 @@ const PendingRequestRespondTool = Tool.make("t3_pending_request_respond", {	...	@@ -173,7 +174,7 @@ const PendingRequestRespondTool = Tool.make("t3_pending_request_respond", {
173	const ThreadConfigurationTool = Tool.make("t3_thread_configuration", {	174	const ThreadConfigurationTool = Tool.make("t3_thread_configuration", {
174	...commandTool,	175	...commandTool,
175	description:	176	description:
176	"Read a thread's provider/model selection and modes in the calling project. orchestrator_capabilities lists available providers and models.",	177	"Read a thread's provider/model selection and modes. Omit threadId for this thread. orchestrator_capabilities lists available providers and models.",
177	parameters: Schema.Struct({ threadId: Schema.optional(ThreadId) }),	178	parameters: Schema.Struct({ threadId: Schema.optional(ThreadId) }),
178	success: Schema.Struct({	179	success: Schema.Struct({
179	threadId: ThreadId,	180	threadId: ThreadId,
...	@@ -187,16 +188,20 @@ const ThreadConfigurationTool = Tool.make("t3_thread_configuration", {	...	@@ -187,16 +188,20 @@ const ThreadConfigurationTool = Tool.make("t3_thread_configuration", {
187	const ThreadConfigureTool = Tool.make("t3_thread_configure", {	188	const ThreadConfigureTool = Tool.make("t3_thread_configure", {
188	...commandTool,	189	...commandTool,
189	description:	190	description:
190	"Set this calling thread's provider, model and options with the existing selection command. This does not change permission modes or other threads. Use orchestrator_capabilities to choose a selection.",	191	"Set a thread's provider, model and options with the existing selection command. Omit threadId for this thread. This does not change permission modes. Use orchestrator_capabilities to choose a selection.",
191	parameters: Schema.Struct({ modelSelection: ModelSelection }),	192	parameters: Schema.Struct({
		193	threadId: Schema.optional(ThreadId),
		194	modelSelection: ModelSelection,
		195	}),
192	}).annotate(Tool.Destructive, true);	196	}).annotate(Tool.Destructive, true);
193		197
194	const transferResult = Schema.Struct({ sequence: NonNegativeInt, targetThreadId: ThreadId });	198	const transferResult = Schema.Struct({ sequence: NonNegativeInt, targetThreadId: ThreadId });
195	const ThreadForkTool = Tool.make("t3_thread_fork", {	199	const ThreadForkTool = Tool.make("t3_thread_fork", {
196	...commandTool,	200	...commandTool,
197	description:	201	description:
198	"Fork this thread from a stable run or checkpoint using the existing fork command. The fork inherits the source configuration. Acceptance does not mean a provider turn has completed.",	202	"Fork a thread from a stable run or checkpoint using the existing fork command. Omit threadId to fork this thread. The fork inherits the source configuration. Acceptance does not mean a provider turn has completed.",
199	parameters: Schema.Struct({	203	parameters: Schema.Struct({
		204	threadId: Schema.optional(ThreadId),
200	sourcePoint: OrchestrationV2ThreadForkSourcePoint,	205	sourcePoint: OrchestrationV2ThreadForkSourcePoint,
201	title: Schema.optional(TrimmedNonEmptyString),	206	title: Schema.optional(TrimmedNonEmptyString),
202	}),	207	}),
...	@@ -205,8 +210,9 @@ const ThreadForkTool = Tool.make("t3_thread_fork", {	...	@@ -205,8 +210,9 @@ const ThreadForkTool = Tool.make("t3_thread_fork", {
205	const ThreadMergeBackTool = Tool.make("t3_thread_merge_back", {	210	const ThreadMergeBackTool = Tool.make("t3_thread_merge_back", {
206	...commandTool,	211	...commandTool,
207	description:	212	description:
208	"Merge context from this thread back to a related thread in the same project. Existing lineage and transfer rules apply.",	213	"Merge context from a thread back to a related thread in the same project. Omit sourceThreadId to merge from this thread. Existing lineage and transfer rules apply.",
209	parameters: Schema.Struct({	214	parameters: Schema.Struct({
		215	sourceThreadId: Schema.optional(ThreadId),
210	targetThreadId: ThreadId,	216	targetThreadId: ThreadId,
211	sourcePoint: OrchestrationV2ThreadForkSourcePoint,	217	sourcePoint: OrchestrationV2ThreadForkSourcePoint,
212	}),	218	}),
...	@@ -214,7 +220,7 @@ const ThreadMergeBackTool = Tool.make("t3_thread_merge_back", {	...	@@ -214,7 +220,7 @@ const ThreadMergeBackTool = Tool.make("t3_thread_merge_back", {
214	}).annotate(Tool.Destructive, true);	220	}).annotate(Tool.Destructive, true);
215	const ThreadTransfersTool = Tool.make("t3_thread_transfers", {	221	const ThreadTransfersTool = Tool.make("t3_thread_transfers", {
216	...commandTool,	222	...commandTool,
217	description: "Read context transfer status for a thread in the calling project.",	223	description: "Read context transfer status for a thread. Omit threadId for this thread.",
218	parameters: Schema.Struct({ threadId: Schema.optional(ThreadId) }),	224	parameters: Schema.Struct({ threadId: Schema.optional(ThreadId) }),
219	success: Schema.Struct({	225	success: Schema.Struct({
220	transfers: Schema.Array(	226	transfers: Schema.Array(
...	@@ -233,8 +239,11 @@ const ThreadTransfersTool = Tool.make("t3_thread_transfers", {	...	@@ -233,8 +239,11 @@ const ThreadTransfersTool = Tool.make("t3_thread_transfers", {
233	const ThreadSearchTool = Tool.make("t3_thread_search", {	239	const ThreadSearchTool = Tool.make("t3_thread_search", {
234	...commandTool,	240	...commandTool,
235	description:	241	description:
236	"Search active thread titles and content with the app's existing bounded search. Returns matches in the calling project from the global top matches; other-project matches are omitted, so this may return fewer than limit. No pagination or exhaustive-result guarantee.",	242	"Search active thread titles and content with the app's existing bounded search. Matches are limited to one project (projectId, else the calling thread's project) out of the global top matches, so this may return fewer than limit. A caller outside a T3 thread that omits projectId searches every project. No pagination or exhaustive-result guarantee.",
237	parameters: OrchestrationSearchThreadsInput,	243	parameters: Schema.Struct({
		244	...OrchestrationSearchThreadsInput.fields,
		245	projectId: Schema.optional(ProjectId),
		246	}),
238	success: OrchestrationSearchThreadsResult,	247	success: OrchestrationSearchThreadsResult,
239	dependencies: [...commandTool.dependencies, ThreadSearch.ThreadSearch],	248	dependencies: [...commandTool.dependencies, ThreadSearch.ThreadSearch],
240	})	249	})
...	@@ -244,7 +253,7 @@ const ThreadSearchTool = Tool.make("t3_thread_search", {	...	@@ -244,7 +253,7 @@ const ThreadSearchTool = Tool.make("t3_thread_search", {
244	const ScheduledTaskRunTool = Tool.make("run_scheduled_task_now", {	253	const ScheduledTaskRunTool = Tool.make("run_scheduled_task_now", {
245	...commandTool,	254	...commandTool,
246	description:	255	description:
247	"Run a scheduled task in the calling project now through the existing scheduler. Requires a full-access/default caller. Each call is a new manual run; completion means dispatch/bookkeeping completed, not that the provider turn finished.",	256	"Run a scheduled task now through the existing scheduler. Requires a full-access/default caller. Each call is a new manual run; completion means dispatch/bookkeeping completed, not that the provider turn finished.",
248	parameters: Schema.Struct({ taskId: ScheduledTaskId }),	257	parameters: Schema.Struct({ taskId: ScheduledTaskId }),
249	success: Schema.Struct({	258	success: Schema.Struct({
250	taskId: ScheduledTaskId,	259	taskId: ScheduledTaskId,

apps/server/src/mcp/toolkits/worktree/handlers.ts+7-4

apps/server/src/mcp/toolkits/worktree/tools.ts+5-3

apps/server/src/orchestration-v2/ProviderSessionManager.test.ts+6-6

apps/server/src/orchestration-v2/ProviderSessionManager.ts+2-2

...	@@ -468,8 +468,8 @@ export const layerWithOptions = (	...	@@ -468,8 +468,8 @@ export const layerWithOptions = (
468	const resolved = yield* mcpSessionRegistry.resolve(rawToken);	468	const resolved = yield* mcpSessionRegistry.resolve(rawToken);
469	if (	469	if (
470	resolved !== undefined &&	470	resolved !== undefined &&
471	resolved.threadId === threadId &&	471	resolved.thread.threadId === threadId &&
472	resolved.providerInstanceId === providerInstanceId &&	472	resolved.thread.providerInstanceId === providerInstanceId &&
473	// A flipped browser-access setting must not survive through	473	// A flipped browser-access setting must not survive through
474	// credential reuse: rotate so the new scope reflects it.	474	// credential reuse: rotate so the new scope reflects it.
475	resolved.capabilities.has("preview") === browserToolsAvailable &&	475	resolved.capabilities.has("preview") === browserToolsAvailable &&

packages/contracts/src/orchestratorMcp.ts+29-4

 @@ -280,7 +280,15 @@ export const OrchestratorMcpThreadStatus = Schema.Union([
 ]);
 export type OrchestratorMcpThreadStatus = typeof OrchestratorMcpThreadStatus.Type;
+const OrchestratorMcpProjectTarget = Schema.optional(
+  ProjectId.annotate({
+    description:
+      "Project to act on. Omit for the calling thread's project; required when the caller is not a T3 thread.",
+  }),
+);
 export const OrchestratorMcpThreadListInput = Schema.Struct({
+  projectId: OrchestratorMcpProjectTarget,
   statuses: Schema.optional(
     Schema.Array(OrchestratorMcpThreadStatus).check(Schema.isMaxLength(10)),
   ),
 @@ -316,7 +324,8 @@ export type OrchestratorMcpThreadListItem = typeof OrchestratorMcpThreadListItem
 export const OrchestratorMcpThreadListResult = Schema.Struct({
   projectId: ProjectId,
-  currentThreadId: ThreadId,
+  /** The calling thread, or null when the caller is not a T3 thread. */
+  currentThreadId: Schema.NullOr(ThreadId),
   threads: Schema.Array(OrchestratorMcpThreadListItem),
   nextCursor: Schema.NullOr(NonNegativeInt),
   total: NonNegativeInt,
 @@ -475,9 +484,11 @@ export const OrchestratorMcpProviderCapability = Schema.Struct({
 export type OrchestratorMcpProviderCapability = typeof OrchestratorMcpProviderCapability.Type;
 export const OrchestratorMcpCapabilitiesResult = Schema.Struct({
-  parentThreadId: ThreadId,
+  /** The calling thread, or null when the caller is not a T3 thread. */
-  inheritedProviderInstanceId: ProviderInstanceId,
+  parentThreadId: Schema.NullOr(ThreadId),
-  inheritedModel: Schema.String,
+  /** The calling thread's selection, or null when the caller is not a T3 thread. */
+  inheritedProviderInstanceId: Schema.NullOr(ProviderInstanceId),
+  inheritedModel: Schema.NullOr(Schema.String),
   runtimeMode: RuntimeMode,
   interactionMode: ProviderInteractionMode,
   providers: Schema.Array(OrchestratorMcpProviderCapability),
 @@ -495,6 +506,7 @@ export const OrchestratorMcpCapabilitiesResult = Schema.Struct({
 export type OrchestratorMcpCapabilitiesResult = typeof OrchestratorMcpCapabilitiesResult.Type;
 export const OrchestratorMcpScheduleTaskInput = Schema.Struct({
+  projectId: OrchestratorMcpProjectTarget,
   prompt: OrchestratorMcpPrompt.annotate({
     description: "Prompt executed on every scheduled run.",
   }),
 @@ -535,6 +547,17 @@ export type OrchestratorMcpScheduledTask = typeof OrchestratorMcpScheduledTask.T
 export const OrchestratorMcpScheduleTaskResult = OrchestratorMcpScheduledTask;
 export type OrchestratorMcpScheduleTaskResult = typeof OrchestratorMcpScheduleTaskResult.Type;
+export const OrchestratorMcpListScheduledTasksInput = Schema.Struct({
+  projectId: Schema.optional(
+    ProjectId.annotate({
+      description:
+        "Only list this project's tasks. Omit for the calling thread's project, or for every project when the caller is not a T3 thread.",
+    }),
+  ),
+});
+export type OrchestratorMcpListScheduledTasksInput =
+  typeof OrchestratorMcpListScheduledTasksInput.Type;
 export const OrchestratorMcpListScheduledTasksResult = Schema.Struct({
   tasks: Schema.Array(OrchestratorMcpScheduledTask),
 });
 @@ -583,6 +606,8 @@ export class OrchestratorMcpFailure extends Schema.TaggedError<OrchestratorMcpFa
       "thread_not_interruptible",
       "invalid_request",
       "orchestration_error",
+      "thread_credential_required",
+      "target_required",
     ]),
     message: Schema.String,
   },

packages/contracts/src/previewAutomation.ts+4-3

 @@ -642,11 +642,12 @@ export const PreviewAutomationResponse = Schema.Struct({
 });
 export type PreviewAutomationResponse = typeof PreviewAutomationResponse.Type;
+// Thread fields are absent when the caller signed in from outside a T3 thread.
 const McpCapabilityErrorFields = {
   environmentId: EnvironmentId,
-  threadId: ThreadId,
+  threadId: Schema.optional(ThreadId),
-  providerSessionId: TrimmedNonEmptyString,
+  providerSessionId: Schema.optional(TrimmedNonEmptyString),
-  providerInstanceId: ProviderInstanceId,
+  providerInstanceId: Schema.optional(ProviderInstanceId),
 };
 /** Agents read this message, so it names the next step and not only the failure. */

packages/contracts/src/threadMetadataMcp.ts+1-1

...	@@ -80,7 +80,7 @@ export type ThreadMetadataMcpPullRequest = typeof ThreadMetadataMcpPullRequest.T	...	@@ -80,7 +80,7 @@ export type ThreadMetadataMcpPullRequest = typeof ThreadMetadataMcpPullRequest.T
80		80
81	export const ThreadMetadataMcpUpdateInput = Schema.Struct({	81	export const ThreadMetadataMcpUpdateInput = Schema.Struct({
82	threadId: Schema.optional(ThreadId).annotate({	82	threadId: Schema.optional(ThreadId).annotate({
83	description: "Thread in the calling project. Omit to update the calling thread.",	83	description: "Thread to update. Omit to update the calling thread.",
84	}),	84	}),
85	action: ThreadMetadataMcpAction,	85	action: ThreadMetadataMcpAction,
86	title: Schema.optional(ThreadMetadataTitle),	86	title: Schema.optional(ThreadMetadataTitle),

packages/contracts/src/worktreeMcp.ts+1

...	@@ -121,6 +121,7 @@ export class WorktreeMcpFailure extends Schema.TaggedError<WorktreeMcpFailure>()	...	@@ -121,6 +121,7 @@ export class WorktreeMcpFailure extends Schema.TaggedError<WorktreeMcpFailure>()
121	"handoff_in_progress",	121	"handoff_in_progress",
122	"invalid_request",	122	"invalid_request",
123	"operation_failed",	123	"operation_failed",
		124	"thread_credential_required",
124	]),	125	]),
125	message: Schema.String,	126	message: Schema.String,
126	},	127	},

author	Julius Marminge <julius0216@outlook.com> 2026-10-04 22:32:55-07:00
committer	GitHub <noreply@github.com> 2026-10-04 22:32:55-07:00
log	06e627448bc1ee58487c1a2a9d6bf8d5ef479af3
tree	8bc704e49af7ebd5eac4dbe3cc31c82bc4ac1627
parent	37de6cbde65c7cf9ba90a2557c232e63b7e16988
signature	Signed by PGP key B5690EEEBB952194

...	@@ -60,7 +60,7 @@ const invoke = Effect.fn("PreviewToolkit.invoke")(function* <A>(	...	@@ -60,7 +60,7 @@ const invoke = Effect.fn("PreviewToolkit.invoke")(function* <A>(
60	import("@t3tools/contracts").PreviewAutomationError,	60	import("@t3tools/contracts").PreviewAutomationError,
61	McpInvocationContext.McpInvocationContext \| PreviewAutomationBroker.PreviewAutomationBroker	61	McpInvocationContext.McpInvocationContext \| PreviewAutomationBroker.PreviewAutomationBroker
62	> {	62	> {
63	const scope = yield* McpInvocationContext.requireMcpCapability("preview");	63	const scope = yield* McpInvocationContext.requireThreadMcpCapability("preview");
64	const broker = yield* PreviewAutomationBroker.PreviewAutomationBroker;	64	const broker = yield* PreviewAutomationBroker.PreviewAutomationBroker;
65	let targetTabId = tabId;	65	let targetTabId = tabId;
66	const result = yield* broker.invoke<A>({	66	const result = yield* broker.invoke<A>({
...	@@ -218,7 +218,7 @@ const handlers = {	...	@@ -218,7 +218,7 @@ const handlers = {
218	invokeTargeted<PreviewAutomationRecordingStatus>("recordingStart", input ?? {}),	218	invokeTargeted<PreviewAutomationRecordingStatus>("recordingStart", input ?? {}),
219	preview_recording_stop: (input) =>	219	preview_recording_stop: (input) =>
220	Effect.gen(function* () {	220	Effect.gen(function* () {
221	const scope = yield* McpInvocationContext.requireMcpCapability("preview");	221	const scope = yield* McpInvocationContext.requireThreadMcpCapability("preview");
222	const { tabId, ...operationInput } = input;	222	const { tabId, ...operationInput } = input;
223	const response = yield* invoke<unknown>(	223	const response = yield* invoke<unknown>(
224	"recordingStop",	224	"recordingStop",
...	@@ -226,7 +226,7 @@ const handlers = {	...	@@ -226,7 +226,7 @@ const handlers = {
226	PREVIEW_RECORDING_STOP_TIMEOUT_MS,	226	PREVIEW_RECORDING_STOP_TIMEOUT_MS,
227	tabId,	227	tabId,
228	);	228	);
229	const artifact = yield* claimPreviewRecording(scope.threadId, response.result);	229	const artifact = yield* claimPreviewRecording(scope.thread.threadId, response.result);
230	return { ...artifact, ...(response.toolIcon ? { toolIcon: response.toolIcon } : {}) };	230	return { ...artifact, ...(response.toolIcon ? { toolIcon: response.toolIcon } : {}) };
231	}),	231	}),
232	} satisfies Parameters<typeof PreviewToolkit.toLayer>[0];	232	} satisfies Parameters<typeof PreviewToolkit.toLayer>[0];

...	@@ -1,19 +1,19 @@	...	@@ -1,19 +1,19 @@
1	import * as Effect from "effect/Effect";	1	import * as Effect from "effect/Effect";
2	import * as Preview from "../../../preview/Manager.ts";	2	import * as Preview from "../../../preview/Manager.ts";
3	import { requireMcpCapability } from "../../McpInvocationContext.ts";	3	import { requireThreadMcpCapability } from "../../McpInvocationContext.ts";
4	import { unavailable } from "../../threadAccess.ts";	4	import { unavailable } from "../../threadAccess.ts";
5	import { PreviewControlsToolkit } from "./tools.ts";	5	import { PreviewControlsToolkit } from "./tools.ts";
6		6
7	const access = Effect.gen(function* () {	7	const access = Effect.gen(function* () {
8	// The preview capability already reflects the calling project's access setting.	8	// The preview capability already reflects the calling project's access setting.
9	const scope = yield* requireMcpCapability("preview");	9	const scope = yield* requireThreadMcpCapability("preview");
10	return { scope, manager: yield* Preview.PreviewManager };	10	return { scope, manager: yield* Preview.PreviewManager };
11	});	11	});
12	export const PreviewControlsHandlersLive = PreviewControlsToolkit.toLayer({	12	export const PreviewControlsHandlersLive = PreviewControlsToolkit.toLayer({
13	t3_preview_list: (input) =>	13	t3_preview_list: (input) =>
14	Effect.gen(function* () {	14	Effect.gen(function* () {
15	const { scope, manager } = yield* access;	15	const { scope, manager } = yield* access;
16	const result = yield* manager.list({ threadId: scope.threadId });	16	const result = yield* manager.list({ threadId: scope.thread.threadId });
17	const start = input.cursor ?? 0;	17	const start = input.cursor ?? 0;
18	const end = start + (input.limit ?? 20);	18	const end = start + (input.limit ?? 20);
19	return {	19	return {
...	@@ -26,7 +26,7 @@ export const PreviewControlsHandlersLive = PreviewControlsToolkit.toLayer({	...	@@ -26,7 +26,7 @@ export const PreviewControlsHandlersLive = PreviewControlsToolkit.toLayer({
26	Effect.gen(function* () {	26	Effect.gen(function* () {
27	const { scope, manager } = yield* access;	27	const { scope, manager } = yield* access;
28	yield* manager	28	yield* manager
29	.close({ threadId: scope.threadId, tabId: input.tabId })	29	.close({ threadId: scope.thread.threadId, tabId: input.tabId })
30	.pipe(Effect.mapError(unavailable));	30	.pipe(Effect.mapError(unavailable));
31	return {};	31	return {};
32	}),	32	}),

...	@@ -2,7 +2,7 @@ import { OrchestratorMcpFailure } from "@t3tools/contracts";	...	@@ -2,7 +2,7 @@ import { OrchestratorMcpFailure } from "@t3tools/contracts";
2	import * as Option from "effect/Option";	2	import * as Option from "effect/Option";
3	import * as GitWorkflow from "../../../git/GitWorkflowService.ts";	3	import * as GitWorkflow from "../../../git/GitWorkflowService.ts";
4	import * as Project from "../../../project/ProjectService.ts";	4	import * as Project from "../../../project/ProjectService.ts";
5	import { readCaller, unavailable } from "../../threadAccess.ts";	5	import { readThread, unavailable } from "../../threadAccess.ts";
6	import * as Effect from "effect/Effect";	6	import * as Effect from "effect/Effect";
7		7
8	import * as McpInvocationContext from "../../McpInvocationContext.ts";	8	import * as McpInvocationContext from "../../McpInvocationContext.ts";
...	@@ -18,9 +18,12 @@ const handlers = {	...	@@ -18,9 +18,12 @@ const handlers = {
18	code: "capability_denied",	18	code: "capability_denied",
19	message: "This credential cannot inspect worktrees.",	19	message: "This credential cannot inspect worktrees.",
20	});	20	});
21	const { caller } = yield* readCaller();	21	const { threadId, ...refs } = input;
		22	const {
		23	projection: { thread },
		24	} = yield* readThread(threadId);
22	const projects = yield* Project.ProjectService;	25	const projects = yield* Project.ProjectService;
23	const project = yield* projects.getById(caller.projectId).pipe(Effect.mapError(unavailable));	26	const project = yield* projects.getById(thread.projectId).pipe(Effect.mapError(unavailable));
24	if (Option.isNone(project))	27	if (Option.isNone(project))
25	return yield* new OrchestratorMcpFailure({	28	return yield* new OrchestratorMcpFailure({
26	code: "invalid_request",	29	code: "invalid_request",
...	@@ -28,7 +31,7 @@ const handlers = {	...	@@ -28,7 +31,7 @@ const handlers = {
28	});	31	});
29	const git = yield* GitWorkflow.GitWorkflowService;	32	const git = yield* GitWorkflow.GitWorkflowService;
30	return yield* git	33	return yield* git
31	.listRefs({ ...input, cwd: caller.worktreePath ?? project.value.workspaceRoot })	34	.listRefs({ ...refs, cwd: thread.worktreePath ?? project.value.workspaceRoot })
32	.pipe(Effect.mapError(unavailable));	35	.pipe(Effect.mapError(unavailable));
33	}),	36	}),
34	t3_worktree_handoff: (input) =>	37	t3_worktree_handoff: (input) =>

...	@@ -6,6 +6,7 @@ import {	...	@@ -6,6 +6,7 @@ import {
6	WorktreeMcpHandoffInput,	6	WorktreeMcpHandoffInput,
7	WorktreeMcpHandoffResult,	7	WorktreeMcpHandoffResult,
8	WorktreeMcpStatusResult,	8	WorktreeMcpStatusResult,
		9	ThreadId,
9	} from "@t3tools/contracts";	10	} from "@t3tools/contracts";
10	import * as Schema from "effect/Schema";	11	import * as Schema from "effect/Schema";
11	import * as GitWorkflowService from "../../../git/GitWorkflowService.ts";	12	import * as GitWorkflowService from "../../../git/GitWorkflowService.ts";
...	@@ -23,7 +24,7 @@ const dependencies = [	...	@@ -23,7 +24,7 @@ const dependencies = [
23		24
24	const WorktreeHandoffTool = Tool.make("t3_worktree_handoff", {	25	const WorktreeHandoffTool = Tool.make("t3_worktree_handoff", {
25	description:	26	description:
26	"Move this agent thread into a new git worktree. To launch a separate agent already bound to a new or existing worktree, use t3_thread_launch with workspaceStrategy instead. Creates the worktree branch (optionally from origin), re-points the thread at the worktree, and by default runs the project's setup script there. Changing the workspace detaches the live provider session, so the current turn ends shortly after the handoff is recorded; call this as the last action of the turn. To keep working after the handoff, pass continuationPrompt with the remaining work: it is queued as the thread's next message and starts a new turn inside the worktree with the conversation preserved. Without it the thread stays idle until the next message. The worktree is not removed automatically when the thread is deleted. Fails if the thread is already attached to a worktree.",	27	"Needs an agent running inside a T3 thread. Move this agent thread into a new git worktree. To launch a separate agent already bound to a new or existing worktree, use t3_thread_launch with workspaceStrategy instead. Creates the worktree branch (optionally from origin), re-points the thread at the worktree, and by default runs the project's setup script there. Changing the workspace detaches the live provider session, so the current turn ends shortly after the handoff is recorded; call this as the last action of the turn. To keep working after the handoff, pass continuationPrompt with the remaining work: it is queued as the thread's next message and starts a new turn inside the worktree with the conversation preserved. Without it the thread stays idle until the next message. The worktree is not removed automatically when the thread is deleted. Fails if the thread is already attached to a worktree.",
27	parameters: WorktreeMcpHandoffInput,	28	parameters: WorktreeMcpHandoffInput,
28	success: WorktreeMcpHandoffResult,	29	success: WorktreeMcpHandoffResult,
29	failure: WorktreeMcpFailure,	30	failure: WorktreeMcpFailure,
...	@@ -38,7 +39,7 @@ const WorktreeHandoffTool = Tool.make("t3_worktree_handoff", {	...	@@ -38,7 +39,7 @@ const WorktreeHandoffTool = Tool.make("t3_worktree_handoff", {
38		39
39	const WorktreeStatusTool = Tool.make("t3_worktree_status", {	40	const WorktreeStatusTool = Tool.make("t3_worktree_status", {
40	description:	41	description:
41	"Report this agent thread's worktree binding: whether it is attached to a git worktree, the worktree path and branch, the project's main workspace root, and the server default for t3_worktree_handoff's startFromOrigin. Call this before t3_worktree_handoff to check whether a handoff is possible or has already happened.",	42	"Needs an agent running inside a T3 thread. Report this agent thread's worktree binding: whether it is attached to a git worktree, the worktree path and branch, the project's main workspace root, and the server default for t3_worktree_handoff's startFromOrigin. Call this before t3_worktree_handoff to check whether a handoff is possible or has already happened.",
42	// No `parameters`: Tool.make defaults to Tool.EmptyParams, which serializes	43	// No `parameters`: Tool.make defaults to Tool.EmptyParams, which serializes
43	// to a top-level `type: "object"` JSON Schema. An explicit empty	44	// to a top-level `type: "object"` JSON Schema. An explicit empty
44	// Schema.Struct({}) serializes to `anyOf: [object, array]`, which is not a	45	// Schema.Struct({}) serializes to `anyOf: [object, array]`, which is not a
...	@@ -56,8 +57,9 @@ const WorktreeStatusTool = Tool.make("t3_worktree_status", {	...	@@ -56,8 +57,9 @@ const WorktreeStatusTool = Tool.make("t3_worktree_status", {
56		57
57	const WorktreeListTool = Tool.make("t3_worktree_list", {	58	const WorktreeListTool = Tool.make("t3_worktree_list", {
58	description:	59	description:
59	"List branch refs and their associated checkout paths for this thread's workspace using the app's ref inventory. Detached worktrees without a branch are not included. Use t3_worktree_status for the thread binding and t3_worktree_handoff to create a new worktree.",	60	"List branch refs and their associated checkout paths for a thread's workspace (omit threadId for this thread) using the app's ref inventory. Detached worktrees without a branch are not included. Use t3_worktree_status for the thread binding and t3_worktree_handoff to create a new worktree.",
60	parameters: Schema.Struct({	61	parameters: Schema.Struct({
		62	threadId: Schema.optional(ThreadId),
61	query: VcsListRefsInput.fields.query,	63	query: VcsListRefsInput.fields.query,
62	cursor: VcsListRefsInput.fields.cursor,	64	cursor: VcsListRefsInput.fields.cursor,
63	limit: VcsListRefsInput.fields.limit,	65	limit: VcsListRefsInput.fields.limit,

...	@@ -1082,7 +1082,7 @@ it.effect(	...	@@ -1082,7 +1082,7 @@ it.effect(
1082	const token = captured?.authorizationHeader.replace(/^Bearer\s+/, "");	1082	const token = captured?.authorizationHeader.replace(/^Bearer\s+/, "");
1083	assert.isDefined(token);	1083	assert.isDefined(token);
1084	const resolved = yield* registry.resolve(token!);	1084	const resolved = yield* registry.resolve(token!);
1085	assert.equal(resolved?.threadId, threadId);	1085	assert.equal(resolved?.thread.threadId, threadId);
1086	assert.deepEqual(	1086	assert.deepEqual(
1087	resolved?.capabilities,	1087	resolved?.capabilities,
1088	new Set(["preview", "orchestration", "worktree", "pull-requests"]),	1088	new Set(["preview", "orchestration", "worktree", "pull-requests"]),
...	@@ -1317,7 +1317,7 @@ it.effect("ProviderSessionManagerV2 duplicate detach preserves replacement MCP c	...	@@ -1317,7 +1317,7 @@ it.effect("ProviderSessionManagerV2 duplicate detach preserves replacement MCP c
1317	McpProviderSession.readMcpProviderSession(threadId)?.providerSessionId,	1317	McpProviderSession.readMcpProviderSession(threadId)?.providerSessionId,
1318	replacement?.providerSessionId,	1318	replacement?.providerSessionId,
1319	);	1319	);
1320	assert.equal((yield* registry.resolve(replacementToken!))?.threadId, threadId);	1320	assert.equal((yield* registry.resolve(replacementToken!))?.thread.threadId, threadId);
1321	});	1321	});
1322		1322
1323	yield* effect.pipe(	1323	yield* effect.pipe(
...	@@ -1393,7 +1393,7 @@ it.effect(	...	@@ -1393,7 +1393,7 @@ it.effect(
1393	McpProviderSession.readMcpProviderSession(threadId)?.providerSessionId,	1393	McpProviderSession.readMcpProviderSession(threadId)?.providerSessionId,
1394	replacement?.providerSessionId,	1394	replacement?.providerSessionId,
1395	);	1395	);
1396	assert.equal((yield* registry.resolve(replacementToken!))?.threadId, threadId);	1396	assert.equal((yield* registry.resolve(replacementToken!))?.thread.threadId, threadId);
1397	});	1397	});
1398		1398
1399	yield* effect.pipe(	1399	yield* effect.pipe(
...	@@ -1449,7 +1449,7 @@ it.effect(	...	@@ -1449,7 +1449,7 @@ it.effect(
1449	// process's MCP client keeps using the credential it was started with.	1449	// process's MCP client keeps using the credential it was started with.
1450	yield* manager.detach({ providerSessionId, threadId, detail: "Workspace changed." });	1450	yield* manager.detach({ providerSessionId, threadId, detail: "Workspace changed." });
1451	assert.equal(	1451	assert.equal(
1452	(yield* registry.resolve(originalToken!))?.threadId,	1452	(yield* registry.resolve(originalToken!))?.thread.threadId,
1453	threadId,	1453	threadId,
1454	"detach must not revoke the credential the live provider process still holds",	1454	"detach must not revoke the credential the live provider process still holds",
1455	);	1455	);
...	@@ -1468,7 +1468,7 @@ it.effect(	...	@@ -1468,7 +1468,7 @@ it.effect(
1468	original?.providerSessionId,	1468	original?.providerSessionId,
1469	"re-attach must reuse the existing credential, not rotate it",	1469	"re-attach must reuse the existing credential, not rotate it",
1470	);	1470	);
1471	assert.equal((yield* registry.resolve(originalToken!))?.threadId, threadId);	1471	assert.equal((yield* registry.resolve(originalToken!))?.thread.threadId, threadId);
1472		1472
1473	// Releasing the session (provider process gone) still revokes.	1473	// Releasing the session (provider process gone) still revokes.
1474	yield* manager.close(providerSessionId);	1474	yield* manager.close(providerSessionId);
...	@@ -1592,7 +1592,7 @@ it.effect(	...	@@ -1592,7 +1592,7 @@ it.effect(
1592	"the credential the adapter was configured with must remain current",	1592	"the credential the adapter was configured with must remain current",
1593	);	1593	);
1594	assert.equal(	1594	assert.equal(
1595	(yield* registry.resolve(originalToken!))?.threadId,	1595	(yield* registry.resolve(originalToken!))?.thread.threadId,
1596	threadId,	1596	threadId,
1597	"the predecessor release must not revoke a credential reserved by an in-flight open",	1597	"the predecessor release must not revoke a credential reserved by an in-flight open",
1598	);	1598	);

feat(server): T3 MCP tools take explicit thread and project targets (#15219)