@akira-tl/forgerelay 0.6.0 → 0.6.2

package/dist/server.js

@@ -45,6 +45,9 @@ import { createCoreOperationExecutor, } from "./operations/core-operation-execut
 import { McpTransportRegistry, } from "./mcp-sessions.js";
 import { ProcessManager, resolveProcessId, } from "./process-sessions.js";
 import { createReviewCheckpointManager } from "./review-checkpoints.js";
+import { CompositeActivityCoordinator } from "./composite-activity.js";
+import { CompositeWorkspaceRegistry } from "./composite-workspaces.js";
+import { RemoteWorkspaceRelay } from "./remote-workspace-relay.js";
 import { hostConversationScopeId, openAiConversationScopeId } from "./request-meta.js";
 import { ACTIVITY_PANEL_APP_LEGACY_URI, ACTIVITY_PANEL_APP_URI_TEMPLATE, MCP_APP_RESOURCE_TEMPLATE_REVISION, readActivityPanelAppManifestEntry, readWorkspaceAppManifestEntry, readWorkspaceLifecycleAppManifestEntry, resolveActivityPanelAppIdentity, resolveWorkspaceAppIdentity, resolveWorkspaceLifecycleAppIdentity, WORKSPACE_APP_LEGACY_URI, WORKSPACE_APP_URI_TEMPLATE, WORKSPACE_LIFECYCLE_APP_LEGACY_URI, WORKSPACE_LIFECYCLE_APP_URI_TEMPLATE, } from "./mcp-app-template.js";
 import { shutdownHttpServer } from "./server-shutdown.js";
@@ -875,6 +878,39 @@ function toolResultContent(result) {
     const content = result.content;
     return Array.isArray(content) ? content : [];
 }
+function remapCompositeToolResult(result, executionWorkspaceId, compositeWorkspaceId, member) {
+    if (typeof result !== "object" || result === null)
+        return result;
+    const record = result;
+    const remapped = replaceWorkspaceIdentity(record, executionWorkspaceId, compositeWorkspaceId);
+    const meta = typeof remapped._meta === "object" && remapped._meta !== null
+        ? { ...remapped._meta }
+        : undefined;
+    if (meta) {
+        const card = typeof meta.card === "object" && meta.card !== null
+            ? { ...meta.card, workspaceId: compositeWorkspaceId, member }
+            : undefined;
+        if (card)
+            meta.card = card;
+        remapped._meta = meta;
+    }
+    const structured = typeof remapped.structuredContent === "object" && remapped.structuredContent !== null
+        ? { ...remapped.structuredContent, member }
+        : undefined;
+    if (structured)
+        remapped.structuredContent = structured;
+    return remapped;
+}
+function replaceWorkspaceIdentity(value, from, to) {
+    if (typeof value === "string")
+        return value.split(from).join(to);
+    if (Array.isArray(value))
+        return value.map((entry) => replaceWorkspaceIdentity(entry, from, to));
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .map(([key, entry]) => [key, replaceWorkspaceIdentity(entry, from, to)]));
+}
 function toolResultAgentsFiles(result) {
     if (typeof result !== "object" || result === null)
         return [];
@@ -955,6 +991,14 @@ function activityRelationFor(context) {
         ...(context.turnId ? { turnId: context.turnId } : {}),
     };
 }
+function activityRequestFor(input, context) {
+    if (!context.activityMember || !input || typeof input !== "object" || Array.isArray(input))
+        return input;
+    return {
+        ...input,
+        member: context.activityMember,
+    };
+}
 function runActivityTool(lifecycle, workspace, conversationScopeId, tool, request, operation, outcome = standardActivityOutcome, relation = {}) {
     return lifecycle.run({
         tool,
@@ -969,13 +1013,14 @@ function runActivityTool(lifecycle, workspace, conversationScopeId, tool, reques
 function runActivityToolWithHooks(lifecycle, hooks, workspace, conversationScopeId, request, hookOptions, relation = {}) {
     return runActivityTool(lifecycle, workspace, conversationScopeId, hookOptions.tool, request, () => runToolWithHooks(hooks, hookOptions), standardActivityOutcome, relation);
 }
-function registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle, bashOutputStore, shellRun) {
+function registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle, bashOutputStore, shellRun, routing) {
     if (config.toolMode === "codex") {
         registerAppTool(server, "exec_command", {
             title: "Execute command",
             description: `Run a command inside an open workspace. Returns its result when it exits during the yield window, otherwise returns a processId for write_stdin. Use this for file inspection, tests, builds, package scripts, generators, formatters, and long-running processes. ${buildShellMutationPolicy()} Call open_workspace first and pass workspaceId.`,
             inputSchema: {
                 workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+                member: z.string().optional().describe("Required for a Composite Workspace; explicit member name that owns this process."),
                 cmd: z.string().min(1).describe("Shell command to execute."),
                 tty: z
                     .boolean()
@@ -1012,22 +1057,34 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
             outputSchema: processOutputSchema(),
             ...toolWidgetDescriptorMeta(config, "shell"),
             annotations: SHELL_TOOL_ANNOTATIONS,
-        }, async ({ workspaceId, cmd, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens }, extra) => shellRun({
-            workspaceId,
-            command: cmd,
-            surface: "exec_command",
-            tty,
-            columns,
-            rows,
-            workingDirectory,
-            yieldTimeMs,
-            timeoutMs,
-            maxOutputTokens,
-        }, {
-            requestMeta: extra._meta,
-            signal: extra.signal,
-            sessionId: extra.sessionId,
-        }));
+        }, async ({ workspaceId, member, cmd, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens }, extra) => {
+            const target = routing.resolve(workspaceId, member);
+            const context = await routing.prepare(target, extra._meta, extra.signal, extra.sessionId);
+            if (routing.isRemote(target.executionWorkspaceId)) {
+                return routing.present(await routing.execCommandRemote(target.executionWorkspaceId, {
+                    cmd,
+                    ...(tty !== undefined ? { tty } : {}),
+                    ...(columns !== undefined ? { columns } : {}),
+                    ...(rows !== undefined ? { rows } : {}),
+                    ...(workingDirectory !== undefined ? { workingDirectory } : {}),
+                    ...(yieldTimeMs !== undefined ? { yieldTimeMs } : {}),
+                    ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+                    ...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
+                }, routing.hostScopeIdFor(extra._meta, extra.sessionId)), target);
+            }
+            return routing.present(await shellRun({
+                workspaceId: target.executionWorkspaceId,
+                command: cmd,
+                surface: "exec_command",
+                tty,
+                columns,
+                rows,
+                workingDirectory,
+                yieldTimeMs,
+                timeoutMs,
+                maxOutputTokens,
+            }, context), target);
+        });
     }
     if (config.toolMode !== "codex")
         return;
@@ -1036,6 +1093,7 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
         description: "Poll or write characters to a running process returned by exec_command, or retrieve complete durable process output by outputId. Omit chars or pass an empty string to poll. Waiting never kills the process; pass \\u0003 to explicitly send Ctrl-C.",
         inputSchema: {
             workspaceId: z.string().describe("Workspace identifier used to start the process."),
+            member: z.string().optional().describe("Required for a Composite Workspace; explicit member name that owns the process."),
             processId: z.number().int().positive().optional().describe("Canonical process identifier returned by bash or exec_command."),
             sessionId: z.number().int().positive().optional().describe("Deprecated alias for processId. Retained for compatibility."),
             outputId: z.string().optional().describe("Stable output identifier returned by exec_command. When supplied, retrieve the complete durable output instead of controlling a process."),
@@ -1060,8 +1118,23 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
         outputSchema: processOutputSchema(),
         ...toolWidgetDescriptorMeta(config, "shell"),
         annotations: SHELL_TOOL_ANNOTATIONS,
-    }, async ({ workspaceId, processId, sessionId, outputId, chars, columns, rows, yieldTimeMs, maxOutputTokens }, extra) => {
-        const workspace = workspaces.getWorkspace(workspaceId);
+    }, async ({ workspaceId, member, processId, sessionId, outputId, chars, columns, rows, yieldTimeMs, maxOutputTokens }, extra) => {
+        const target = routing.resolve(workspaceId, member);
+        await routing.prepare(target, extra._meta, extra.signal, extra.sessionId);
+        if (routing.isRemote(target.executionWorkspaceId)) {
+            return routing.present(await routing.writeStdinRemote(target.executionWorkspaceId, {
+                ...(processId !== undefined ? { processId } : {}),
+                ...(sessionId !== undefined ? { sessionId } : {}),
+                ...(outputId !== undefined ? { outputId } : {}),
+                ...(chars !== undefined ? { chars } : {}),
+                ...(columns !== undefined ? { columns } : {}),
+                ...(rows !== undefined ? { rows } : {}),
+                ...(yieldTimeMs !== undefined ? { yieldTimeMs } : {}),
+                ...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
+            }, routing.hostScopeIdFor(extra._meta, extra.sessionId)), target);
+        }
+        const executionWorkspaceId = target.executionWorkspaceId;
+        const workspace = workspaces.getWorkspace(executionWorkspaceId);
         if (outputId !== undefined) {
             if (processId !== undefined || sessionId !== undefined || chars !== undefined || columns !== undefined ||
                 rows !== undefined || yieldTimeMs !== undefined || maxOutputTokens !== undefined) {
@@ -1072,7 +1145,7 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
                 tool: "write_stdin",
                 invocation: workspaceHookInvocation(workspace),
                 payload: { outputId },
-                operation: async () => durableOutputResponse("write_stdin", workspaceId, readWorkspaceBashOutput(bashOutputStore, workspaceId, outputId)),
+                operation: async () => durableOutputResponse("write_stdin", executionWorkspaceId, readWorkspaceBashOutput(bashOutputStore, executionWorkspaceId, outputId)),
             });
         }
         const resolvedProcessId = resolveProcessId(processId, sessionId);
@@ -1089,7 +1162,7 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
             operation: async () => {
                 const startedAt = performance.now();
                 const snapshot = await processSessions.write({
-                    workspaceId,
+                    workspaceId: executionWorkspaceId,
                     processId: resolvedProcessId,
                     chars,
                     columns,
@@ -1107,7 +1180,7 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
                     success: snapshot.running || snapshot.exitCode === 0,
                     durationMs: Math.round(performance.now() - startedAt),
                 });
-                const response = processToolResponse("write_stdin", workspaceId, snapshot, {
+                const response = processToolResponse("write_stdin", executionWorkspaceId, snapshot, {
                     processId: resolvedProcessId,
                     charactersWritten: chars?.length ?? 0,
                     running: snapshot.running,
@@ -1119,12 +1192,57 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
                 }
                 return response;
             },
-        });
+        }).then((result) => routing.present(result, target));
     });
 }
 export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries) {
     const connectionScopeId = `mcp-connection:${randomUUID()}`;
+    const remoteWorkspaces = new RemoteWorkspaceRelay(config.configDir, config.stateDir);
+    const compositeWorkspaces = new CompositeWorkspaceRegistry(config.stateDir);
+    const compositeActivity = new CompositeActivityCoordinator(compositeWorkspaces, activityQueries, remoteWorkspaces);
+    const resolveExecutionTarget = (workspaceId, memberName) => {
+        if (!compositeWorkspaces.has(workspaceId)) {
+            if (memberName !== undefined) {
+                throw new Error(`Workspace ${workspaceId} is not composite and does not accept member.`);
+            }
+            return { executionWorkspaceId: workspaceId };
+        }
+        if (!memberName) {
+            throw new Error(`Composite Workspace ${workspaceId} requires member for this operation.`);
+        }
+        const member = compositeWorkspaces.member(workspaceId, memberName);
+        try {
+            if (!remoteWorkspaces.has(member.workspaceId))
+                workspaces.getWorkspace(member.workspaceId);
+        }
+        catch (error) {
+            throw new Error(`Composite Workspace ${workspaceId} member ${member.name} is unavailable: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return {
+            executionWorkspaceId: member.workspaceId,
+            compositeWorkspaceId: workspaceId,
+            memberName: member.name,
+        };
+    };
+    const presentExecutionResult = (result, target) => {
+        if (!target.compositeWorkspaceId || !target.memberName)
+            return result;
+        return remapCompositeToolResult(result, target.executionWorkspaceId, target.compositeWorkspaceId, target.memberName);
+    };
     const hostScopeIdFor = (requestMeta, transportSessionId) => hostConversationScopeId(requestMeta, transportSessionId, connectionScopeId);
+    const prepareExecutionContext = async (target, requestMeta, signal, sessionId) => {
+        const conversationScopeId = hostScopeIdFor(requestMeta, sessionId);
+        const turnId = target.compositeWorkspaceId && target.memberName
+            ? await compositeActivity.prepareMember(target.compositeWorkspaceId, target.memberName, target.executionWorkspaceId, conversationScopeId)
+            : undefined;
+        return {
+            requestMeta,
+            signal,
+            sessionId,
+            ...(turnId ? { turnId } : {}),
+            ...(target.memberName ? { activityMember: target.memberName } : {}),
+        };
+    };
     const toolDescriptions = buildToolDescriptions(config);
     const hooks = new HookRunner(config.hooks, config.logging, process.env, (workspaceId, result) => attachCompletedProcessNotices(processSessions, workspaceId, result, (snapshot) => recordBashCompletion(activityLifecycle, bashOutputStore, snapshot.outputId)));
     const incomingArtifactRegistry = new IncomingArtifactAdapterRegistry(incomingArtifactAdapters);
@@ -1222,11 +1340,59 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             },
         },
     });
+    const loadCompositeMemberContext = async (compositeWorkspaceId, memberName, contextPolicy, conversationScopeId, protectedWorkspaceIds) => {
+        const target = resolveExecutionTarget(compositeWorkspaceId, memberName);
+        if (remoteWorkspaces.has(target.executionWorkspaceId)) {
+            const resumed = await remoteWorkspaces.resumeWorkspace(target.executionWorkspaceId, contextPolicy, conversationScopeId);
+            const presented = presentExecutionResult(resumed, target);
+            return {
+                member: memberName,
+                ...(presented.structuredContent ?? {}),
+            };
+        }
+        const opened = await workspaces.openWorkspace({ workspaceId: target.executionWorkspaceId, context: contextPolicy }, { conversationScopeId, protectedWorkspaceIds });
+        const workspace = opened.workspace;
+        const capabilityFingerprint = buildCapabilityFingerprint(config, FORGERELAY_VERSION, {
+            artifactDownloadSupported: isArtifactDownloadSupportedPlatform(),
+        });
+        const capabilityCatalog = capabilityRegistry.catalog(capabilityContextFor(workspace));
+        const agentsFiles = opened.agentsFiles.map((file) => ({
+            path: formatAgentsPath(file.path, workspace.root),
+            content: file.content,
+        }));
+        const availableAgentsFiles = opened.availableAgentsFiles.map((file) => ({
+            path: formatAgentsPath(file.path, workspace.root),
+        }));
+        const skills = workspace.skills
+            .filter((skill) => !skill.disableModelInvocation)
+            .map((skill) => ({ name: skill.name, description: skill.description }));
+        return {
+            member: memberName,
+            workspaceId: compositeWorkspaceId,
+            root: workspace.root,
+            mode: workspace.mode,
+            contextFingerprint: opened.contextFingerprint,
+            capabilityFingerprint,
+            capabilityCatalog,
+            includeBootstrapContext: opened.includeBootstrapContext,
+            ...(opened.includeBootstrapContext
+                ? {
+                    agentsFiles,
+                    availableAgentsFiles,
+                    skills,
+                    skillDiagnostics: redactSkillDiagnosticPaths(workspace.skillDiagnostics),
+                }
+                : {}),
+            instruction: opened.includeBootstrapContext
+                ? `Bootstrap context for Composite member ${memberName}. Keep using Composite workspaceId ${compositeWorkspaceId} and pass member=${memberName} for work operations.`
+                : `Composite member ${memberName} context was already delivered for this Host context; keep using Composite workspaceId ${compositeWorkspaceId} with member=${memberName}.`,
+        };
+    };
     const coreOperations = createCoreOperationExecutor({
         read: async (input, context) => {
             const { workspaceId, ...readInput } = input;
             const workspace = workspaces.getWorkspace(workspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), input, {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.read,
                 invocation: workspaceHookInvocation(workspace),
@@ -1298,7 +1464,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         write: async (input, context) => {
             const { workspaceId, ...writeInput } = input;
             const workspace = workspaces.getWorkspace(workspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), input, {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.write,
                 invocation: workspaceHookInvocation(workspace),
@@ -1359,7 +1525,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         edit: async (input, context) => {
             const { workspaceId, ...editInput } = input;
             const workspace = workspaces.getWorkspace(workspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), input, {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.edit,
                 invocation: workspaceHookInvocation(workspace),
@@ -1421,7 +1587,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         rename: async (input, context) => {
             const { workspaceId, path, newPath } = input;
             const workspace = workspaces.getWorkspace(workspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), input, {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.rename,
                 invocation: workspaceHookInvocation(workspace),
@@ -1480,7 +1646,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         delete: async (input, context) => {
             const { workspaceId, path, recursive } = input;
             const workspace = workspaces.getWorkspace(workspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), input, {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.delete,
                 invocation: workspaceHookInvocation(workspace),
@@ -1564,7 +1730,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     maxOutputTokens,
                 };
             let undeliveredProcessId;
-            const activityResult = await runActivityTool(activityLifecycle, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), surface, activityRequest, async (activityContext) => {
+            const activityResult = await runActivityTool(activityLifecycle, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), surface, activityRequestFor(activityRequest, context), async (activityContext) => {
                 try {
                     const result = await runToolWithHooks(hooks, {
                         signal: context.signal,
@@ -1638,7 +1804,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             const { workspaceId, name, arguments: capabilityArguments, file } = input;
             const workspace = workspaces.getWorkspace(workspaceId);
             let changedPaths = [];
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), { workspaceId, name, action: "run", arguments: capabilityArguments, file }, {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), activityRequestFor({ workspaceId, name, action: "run", arguments: capabilityArguments, file }, context), {
                 signal: context.signal,
                 tool: toolNames.capability,
                 invocation: workspaceHookInvocation(workspace),
@@ -1735,6 +1901,26 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         instructions: buildServerInstructions(config),
     });
     const workspacePanelStates = new Map();
+    const workspacePanelState = (workspaceId) => {
+        const remembered = workspacePanelStates.get(workspaceId);
+        if (remembered)
+            return remembered;
+        try {
+            const workspace = workspaces.getWorkspace(workspaceId);
+            return {
+                workspaceId: workspace.id,
+                root: workspace.root,
+                path: workspace.root,
+                mode: workspace.mode,
+                sourceRoot: workspace.sourceRoot,
+                instruction: `Use workspaceId ${workspace.id} for subsequent calls.`,
+                summary: { mode: workspace.mode },
+            };
+        }
+        catch {
+            return undefined;
+        }
+    };
     const rememberWorkspacePanelState = (workspaceId, response) => {
         if (typeof response._meta !== "object" || response._meta === null)
             return;
@@ -1772,16 +1958,48 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     server.registerResource("ForgeRelay Activity Panel compatibility", new ResourceTemplate(ACTIVITY_PANEL_APP_URI_TEMPLATE, { list: undefined }), { ...activityPanelResourceMetadata, mimeType: RESOURCE_MIME_TYPE }, async (uri, _variables, extra) => readActivityPanelAppResource(config, uri.toString(), extra.sessionId));
     registerAppTool(server, "open_workspace", {
         title: "Open workspace",
-        description: "Open or resume a local coding workspace. Reuse the returned workspaceId for later calls. Default to checkout; use mode=\"worktree\" only when the user explicitly requests isolated or parallel Git work. Every call returns lightweight workspace metadata; bootstrap context is delivered automatically only when needed and can be explicitly suppressed or refreshed.",
+        description: "Open or resume a ForgeRelay Workspace. Ordinary workspaces default to local execution; relay may name a registered remote ForgeRelay. Composite Workspaces use the same open lifecycle but have kind=\"composite\" and a name instead of a mounted root. Reuse the returned workspaceId for later calls. Bootstrap context is delivered automatically only when needed and can be suppressed or refreshed.",
         inputSchema: {
             action: z
-                .enum(["open", "list"])
+                .enum(["open", "list", "member"])
+                .optional()
+                .describe("Defaults to open. Use list to inspect logical workspaces. Use member to add/remove a named execution member on an existing Composite Workspace."),
+            memberAction: z
+                .enum(["add", "update", "remove"])
                 .optional()
-                .describe("Defaults to open. Use list only when you need to inspect or choose logical workspaces before resuming or cleaning them up."),
+                .describe("Required with action=member."),
+            member: z.object({
+                name: z.string().describe("Stable member name such as code or compute. For update/remove this identifies the existing member."),
+                newName: z.string().optional().describe("Optional replacement member name for memberAction=update."),
+                purpose: z.string().optional().describe("Agent-facing purpose. Required when adding a member; optional replacement when updating."),
+                workspaceId: z.string().optional().describe("Existing ordinary or relayed Workspace to mount. Mutually exclusive with path."),
+                path: z.string().optional().describe("Workspace path to open internally and mount. Mutually exclusive with workspaceId."),
+                relay: z.string().optional().describe("Optional registered remote ForgeRelay alias for a path-backed member."),
+                mode: z.enum(["checkout", "worktree"]).optional(),
+                baseRef: z.string().optional(),
+                newWorktree: z.boolean().optional(),
+                newWorkspace: z.boolean().optional(),
+            }).optional().describe("Composite member definition used by action=member."),
+            kind: z
+                .enum(["workspace", "composite"])
+                .optional()
+                .describe("Workspace kind for action=open. Defaults to workspace. Use composite with name and no path to create or reopen a named Composite Workspace."),
+            name: z
+                .string()
+                .optional()
+                .describe("Composite Workspace name. Used only with kind=\"composite\" when creating/opening by name."),
+            memberName: z
+                .string()
+                .optional()
+                .describe("For action=open on a Composite Workspace, load bootstrap context for this named member without making it an implicit current member."),
             path: z
                 .string()
                 .optional()
-                .describe("Project path to open. Required for action=open unless workspaceId is supplied. With mode=\"worktree\", this may also be a managed worktree path previously returned by ForgeRelay."),
+                .describe("Project path to open for an ordinary Workspace. Required for action=open unless workspaceId is supplied or kind=\"composite\" with name is used. With mode=\"worktree\", this may also be a managed worktree path previously returned by ForgeRelay."),
+            relay: z
+                .string()
+                .optional()
+                .describe("Optional registered remote ForgeRelay alias. When supplied for action=open, the workspace is opened and executed on that remote instance while this Gateway returns its own workspaceId."),
             workspaceId: z
                 .string()
                 .optional()
@@ -1837,8 +2055,17 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 .describe("For action=list, maximum records to return. Defaults to 50; maximum 100."),
         },
         outputSchema: {
-            action: z.enum(["open", "list"]),
+            action: z.enum(["open", "list", "member"]),
             workspaceId: z.string().optional(),
+            memberAction: z.enum(["add", "update", "remove"]).optional(),
+            kind: z.enum(["workspace", "composite"]).optional(),
+            name: z.string().optional(),
+            members: z.array(z.object({
+                name: z.string(),
+                purpose: z.string(),
+                workspaceId: z.string(),
+            })).optional(),
+            memberContext: z.unknown().optional(),
             root: z.string().optional(),
             mode: z.enum(["checkout", "worktree"]).optional(),
             sourceRoot: z.string().optional(),
@@ -1885,6 +2112,18 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             agents: z.array(workspaceLocalAgentOutputSchema).optional(),
             skillDiagnostics: z.array(workspaceSkillDiagnosticOutputSchema).optional(),
             workspaces: z.array(workspaceInventoryEntryOutputSchema).optional(),
+            compositeWorkspaces: z.array(z.object({
+                workspaceId: z.string(),
+                kind: z.literal("composite"),
+                name: z.string(),
+                members: z.array(z.object({
+                    name: z.string(),
+                    purpose: z.string(),
+                    workspaceId: z.string(),
+                })),
+                createdAt: z.string(),
+                lastUsedAt: z.string(),
+            })).optional(),
             summary: workspaceInventorySummaryOutputSchema.optional(),
             page: workspaceInventoryPageOutputSchema.optional(),
             instruction: z.string(),
@@ -1896,26 +2135,198 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             idempotentHint: false,
             openWorldHint: false,
         },
-    }, async ({ action = "open", path, workspaceId, mode, baseRef, newWorktree, newWorkspace, context, root, status, state, staleOnly, offset, limit, }, { _meta, sessionId }) => {
+    }, async ({ action = "open", memberAction, member, kind, name, memberName, path, relay, workspaceId, mode, baseRef, newWorktree, newWorkspace, context, root, status, state, staleOnly, offset, limit, }, { _meta, sessionId }) => {
         const startedAt = performance.now();
         const conversationScopeId = openAiConversationScopeId(_meta);
         const protectedWorkspaceIds = processSessions.activeWorkspaceIds();
+        if (action === "member") {
+            if (!workspaceId || !compositeWorkspaces.has(workspaceId)) {
+                throw new Error("open_workspace action=member requires an existing Composite Workspace workspaceId.");
+            }
+            if (!memberAction || !member) {
+                throw new Error("open_workspace action=member requires memberAction and member.");
+            }
+            if (kind !== undefined || name !== undefined || memberName !== undefined || path !== undefined || relay !== undefined || mode !== undefined ||
+                baseRef !== undefined || newWorktree !== undefined || newWorkspace !== undefined || context !== undefined ||
+                root !== undefined || status !== undefined || state !== undefined || staleOnly !== undefined ||
+                offset !== undefined || limit !== undefined) {
+                throw new Error("open_workspace action=member accepts workspaceId, memberAction, and member only. Put any Workspace open definition inside member.");
+            }
+            const resolveMemberTargetWorkspaceId = async () => {
+                const byWorkspaceId = typeof member.workspaceId === "string" && member.workspaceId.length > 0;
+                const byPath = typeof member.path === "string" && member.path.length > 0;
+                if (byWorkspaceId === byPath) {
+                    throw new Error("A Composite Workspace member target requires exactly one of member.workspaceId or member.path.");
+                }
+                if (byWorkspaceId) {
+                    const targetWorkspaceId = member.workspaceId;
+                    if (compositeWorkspaces.has(targetWorkspaceId)) {
+                        throw new Error("A Composite Workspace cannot be mounted as a Composite Workspace member.");
+                    }
+                    if (member.relay !== undefined || member.mode !== undefined || member.baseRef !== undefined ||
+                        member.newWorktree !== undefined || member.newWorkspace !== undefined) {
+                        throw new Error("member.workspaceId cannot be combined with relay/mode/baseRef/newWorktree/newWorkspace.");
+                    }
+                    if (!remoteWorkspaces.has(targetWorkspaceId))
+                        workspaces.getWorkspace(targetWorkspaceId);
+                    return targetWorkspaceId;
+                }
+                if (member.relay !== undefined) {
+                    const opened = await remoteWorkspaces.openWorkspace(member.relay, {
+                        path: member.path,
+                        ...(member.mode ? { mode: member.mode } : {}),
+                        ...(member.baseRef ? { baseRef: member.baseRef } : {}),
+                        ...(member.newWorktree !== undefined ? { newWorktree: member.newWorktree } : {}),
+                        ...(member.newWorkspace !== undefined ? { newWorkspace: member.newWorkspace } : {}),
+                        context: "none",
+                    });
+                    return opened.workspaceId;
+                }
+                const opened = await workspaces.openWorkspace({
+                    path: member.path,
+                    ...(member.mode ? { mode: member.mode } : {}),
+                    ...(member.baseRef ? { baseRef: member.baseRef } : {}),
+                    ...(member.newWorktree !== undefined ? { newWorktree: member.newWorktree } : {}),
+                    ...(member.newWorkspace !== undefined ? { newWorkspace: member.newWorkspace } : {}),
+                    context: "none",
+                }, { protectedWorkspaceIds });
+                return opened.workspace.id;
+            };
+            let composite;
+            if (memberAction === "add") {
+                if (member.newName !== undefined) {
+                    throw new Error("Adding a Composite Workspace member does not accept member.newName.");
+                }
+                const purpose = member.purpose?.trim();
+                if (!purpose)
+                    throw new Error("Adding a Composite Workspace member requires member.purpose.");
+                const targetWorkspaceId = await resolveMemberTargetWorkspaceId();
+                composite = compositeWorkspaces.addMember(workspaceId, {
+                    name: member.name,
+                    purpose,
+                    workspaceId: targetWorkspaceId,
+                });
+            }
+            else if (memberAction === "update") {
+                const targetFieldsPresent = member.workspaceId !== undefined || member.path !== undefined || member.relay !== undefined ||
+                    member.mode !== undefined || member.baseRef !== undefined || member.newWorktree !== undefined ||
+                    member.newWorkspace !== undefined;
+                if (member.newName === undefined && member.purpose === undefined && !targetFieldsPresent) {
+                    throw new Error("Updating a Composite Workspace member requires newName, purpose, or a replacement Workspace target.");
+                }
+                const targetWorkspaceId = targetFieldsPresent
+                    ? await resolveMemberTargetWorkspaceId()
+                    : undefined;
+                composite = compositeWorkspaces.updateMember(workspaceId, member.name, {
+                    ...(member.newName !== undefined ? { name: member.newName } : {}),
+                    ...(member.purpose !== undefined ? { purpose: member.purpose } : {}),
+                    ...(targetWorkspaceId !== undefined ? { workspaceId: targetWorkspaceId } : {}),
+                });
+            }
+            else {
+                if (member.newName !== undefined || member.purpose !== undefined || member.workspaceId !== undefined || member.path !== undefined ||
+                    member.relay !== undefined || member.mode !== undefined || member.baseRef !== undefined ||
+                    member.newWorktree !== undefined || member.newWorkspace !== undefined) {
+                    throw new Error("Removing a Composite Workspace member accepts only member.name.");
+                }
+                composite = compositeWorkspaces.removeMember(workspaceId, member.name);
+            }
+            const memberActionVerb = memberAction === "add"
+                ? "Added"
+                : memberAction === "update"
+                    ? "Updated"
+                    : "Removed";
+            const memberActionPreposition = memberAction === "remove" ? "from" : "in";
+            const instruction = [
+                `${memberActionVerb} member ${member.name} ${memberActionPreposition} Composite Workspace ${composite.name} (${composite.id}).`,
+                composite.members.length > 0
+                    ? `Members: ${composite.members.map((entry) => `${entry.name} — ${entry.purpose}`).join("; ")}.`
+                    : "This Composite Workspace currently has no members.",
+                "Use the Composite workspaceId as the top-level handle. Work operations on it require an explicit member name; ForgeRelay never infers a member from tool type or purpose.",
+            ].join("\n");
+            const response = {
+                content: [textBlock(instruction)],
+                _meta: {
+                    tool: "open_workspace",
+                    card: {
+                        workspaceId: composite.id,
+                        kind: "composite",
+                        name: composite.name,
+                        path: composite.name,
+                        members: composite.members,
+                        instruction,
+                        summary: { members: composite.members.length },
+                    },
+                },
+                structuredContent: {
+                    action: "member",
+                    workspaceId: composite.id,
+                    memberAction,
+                    kind: "composite",
+                    name: composite.name,
+                    members: composite.members,
+                    instruction,
+                },
+            };
+            rememberWorkspacePanelState(composite.id, response);
+            return response;
+        }
         if (action === "list") {
-            if (path !== undefined || baseRef !== undefined || newWorktree !== undefined ||
+            if (path !== undefined || relay !== undefined || name !== undefined || memberName !== undefined || baseRef !== undefined || newWorktree !== undefined ||
                 newWorkspace !== undefined || context !== undefined) {
-                throw new Error("open_workspace action=list does not accept path, baseRef, newWorktree, newWorkspace, or context. Use root/workspaceId/mode/status/state/staleOnly for inventory filters.");
+                throw new Error("open_workspace action=list does not accept path, relay, name, memberName, baseRef, newWorktree, newWorkspace, or context. Use kind/root/workspaceId/mode/status/state/staleOnly for inventory filters.");
+            }
+            if (kind === "composite") {
+                if (root !== undefined || mode !== undefined || status !== undefined || state !== undefined ||
+                    staleOnly !== undefined || offset !== undefined || limit !== undefined) {
+                    throw new Error("Composite Workspace inventory does not accept root/mode/status/state/staleOnly/offset/limit filters; use workspaceId when selecting one Composite Workspace.");
+                }
+                const composites = compositeWorkspaces.list()
+                    .filter((entry) => workspaceId === undefined || entry.id === workspaceId)
+                    .map((entry) => ({
+                    workspaceId: entry.id,
+                    kind: entry.kind,
+                    name: entry.name,
+                    members: entry.members,
+                    createdAt: entry.createdAt,
+                    lastUsedAt: entry.lastUsedAt,
+                }));
+                const instruction = "Resume a Composite Workspace with open_workspace(action=\"open\", workspaceId=...). Use close_workspace only when the user chooses to dissolve it.";
+                const result = [
+                    `Composite Workspace inventory: ${composites.length} matching record${composites.length === 1 ? "" : "s"}.`,
+                    ...composites.map((entry) => `${entry.name} [${entry.workspaceId}] members=${entry.members.length} last-used=${entry.lastUsedAt}`),
+                    instruction,
+                ].join("\n");
+                return {
+                    content: [textBlock(result)],
+                    structuredContent: {
+                        action: "list",
+                        compositeWorkspaces: composites,
+                        instruction,
+                    },
+                };
             }
             const inventory = await workspaces.listWorkspaces({ workspaceId, mode, root, status, state, staleOnly, offset, limit }, { conversationScopeId, protectedWorkspaceIds });
+            const composites = kind === "workspace"
+                ? []
+                : compositeWorkspaces.list().map((entry) => ({
+                    workspaceId: entry.id,
+                    kind: entry.kind,
+                    name: entry.name,
+                    members: entry.members,
+                    createdAt: entry.createdAt,
+                    lastUsedAt: entry.lastUsedAt,
+                }));
             const nextOffset = inventory.page.offset + inventory.page.limit;
             const instruction = [
                 "Resume a selected workspaceId with open_workspace(action=\"open\", workspaceId=...).",
-                "Use close_workspace only after the user chooses cleanup; never close inventory entries automatically.",
+                "Use close_workspace only after the user chooses cleanup or Composite dissolution; never close inventory entries automatically.",
                 inventory.page.hasMore
                     ? `More matching workspaces are available; continue with offset=${nextOffset}.`
                     : undefined,
             ].filter(Boolean).join(" ");
             const result = [
-                `Logical workspace inventory: ${inventory.summary.matching} matching of ${inventory.summary.total} stored records.`,
+                `Logical workspace inventory: ${inventory.summary.matching} matching ordinary records; ${composites.length} Composite Workspace record${composites.length === 1 ? "" : "s"}.`,
                 `States: active=${inventory.summary.active}, stale=${inventory.summary.stale}, invalid=${inventory.summary.invalid}, closed=${inventory.summary.closed}.`,
                 ...inventory.workspaces.map((entry) => [
                     entry.label,
@@ -1927,6 +2338,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     `root=${entry.root}`,
                     `last-used=${entry.lastUsedAt}`,
                 ].filter(Boolean).join(" ")),
+                ...composites.map((entry) => `${entry.name} [${entry.workspaceId}] kind=composite members=${entry.members.length}`),
                 instruction,
             ].join("\n");
             logToolCall(config, {
@@ -1941,6 +2353,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 structuredContent: {
                     action: "list",
                     ...inventory,
+                    ...(composites.length > 0 ? { compositeWorkspaces: composites } : {}),
                     instruction,
                 },
             };
@@ -1949,6 +2362,162 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             staleOnly !== undefined || offset !== undefined || limit !== undefined) {
             throw new Error("open_workspace inventory filters root, status, state, staleOnly, offset, and limit are only valid with action=list.");
         }
+        const openingComposite = kind === "composite" ||
+            (workspaceId !== undefined && compositeWorkspaces.has(workspaceId));
+        if (openingComposite) {
+            if (relay !== undefined || path !== undefined || mode !== undefined || baseRef !== undefined ||
+                newWorktree !== undefined || newWorkspace !== undefined) {
+                throw new Error("Composite Workspace open accepts name/workspaceId/context only; members are attached separately and keep their own Workspace definitions.");
+            }
+            if (workspaceId !== undefined && kind === "workspace") {
+                throw new Error(`${workspaceId} is a Composite Workspace, not an ordinary Workspace.`);
+            }
+            const composite = workspaceId !== undefined
+                ? compositeWorkspaces.open(workspaceId)
+                : compositeWorkspaces.create(name ?? "");
+            const memberContext = memberName
+                ? await loadCompositeMemberContext(composite.id, memberName, context ?? "auto", conversationScopeId, protectedWorkspaceIds)
+                : undefined;
+            const instruction = [
+                `This is Composite Workspace ${composite.name} (${composite.id}).`,
+                "It has no mounted working directory of its own. Use the Composite workspaceId as the top-level Workspace handle and explicitly select one named member for member-scoped work operations.",
+                composite.members.length > 0
+                    ? `Members: ${composite.members.map((member) => `${member.name} — ${member.purpose}`).join("; ")}.`
+                    : "This Composite Workspace currently has no members.",
+                "Member names and purposes are structural context and are always returned when this Composite Workspace is opened. context=auto/full/none controls only heavy member bootstrap context, not this Composite identity.",
+                composite.members.length > 0
+                    ? "Before first work on a member, reopen this Composite Workspace with memberName=<member> and context=auto to receive that member's project bootstrap without creating an implicit current member."
+                    : undefined,
+                "Use close_workspace only when the user chooses to dissolve this Composite Workspace; dissolution does not close or clean up member Workspaces.",
+            ].join("\n\n");
+            const response = {
+                content: [textBlock(instruction)],
+                _meta: {
+                    tool: "open_workspace",
+                    card: {
+                        workspaceId: composite.id,
+                        kind: "composite",
+                        name: composite.name,
+                        path: composite.name,
+                        members: composite.members,
+                        instruction,
+                        summary: { members: composite.members.length },
+                    },
+                },
+                structuredContent: {
+                    action: "open",
+                    workspaceId: composite.id,
+                    kind: "composite",
+                    name: composite.name,
+                    members: composite.members,
+                    ...(memberContext ? { memberContext } : {}),
+                    instruction,
+                },
+            };
+            logToolCall(config, {
+                tool: "open_workspace",
+                action: "composite",
+                success: true,
+                durationMs: Math.round(performance.now() - startedAt),
+            });
+            rememberWorkspacePanelState(composite.id, response);
+            return response;
+        }
+        if (name !== undefined || memberName !== undefined) {
+            throw new Error("open_workspace name/memberName are only valid for a Composite Workspace.");
+        }
+        if (relay !== undefined) {
+            if (workspaceId !== undefined) {
+                throw new Error("Relayed open_workspace requires a path; resuming a relayed workspace is not available in this tracer bullet.");
+            }
+            if (!path)
+                throw new Error("Relayed open_workspace requires path.");
+            const opened = await remoteWorkspaces.openWorkspace(relay, {
+                path,
+                mode,
+                baseRef,
+                newWorktree,
+                newWorkspace,
+                context,
+            }, hostScopeIdFor(_meta, sessionId));
+            const relayedSkills = Array.isArray(opened.skills)
+                ? opened.skills
+                : [];
+            const relayedCapabilities = Array.isArray(opened.capabilityCatalog)
+                ? opened.capabilityCatalog
+                : [];
+            const result = [
+                `Opened relayed workspace ${opened.workspaceId}.`,
+                `Execution remote: ${relay}`,
+                `Root: ${opened.root}`,
+                `Mode: ${opened.mode}`,
+                relayedSkills.length > 0
+                    ? `Available skills: ${relayedSkills.map((skill) => String(skill.name ?? "")).filter(Boolean).join(", ")}`
+                    : undefined,
+                relayedCapabilities.length > 0
+                    ? `Optional capabilities: ${relayedCapabilities.map((entry) => String(entry.name ?? "")).filter(Boolean).join(", ")}`
+                    : undefined,
+                opened.instruction,
+            ].filter(Boolean).join("\n");
+            const response = {
+                content: [textBlock(result)],
+                _meta: {
+                    tool: "open_workspace",
+                    card: {
+                        workspaceId: opened.workspaceId,
+                        kind: "workspace",
+                        root: opened.root,
+                        path: opened.root,
+                        mode: opened.mode,
+                        relay,
+                        instruction: opened.instruction,
+                        summary: { mode: opened.mode, relay },
+                    },
+                },
+                structuredContent: {
+                    action: "open",
+                    workspaceId: opened.workspaceId,
+                    kind: "workspace",
+                    root: opened.root,
+                    mode: opened.mode,
+                    ...(opened.sourceRoot ? { sourceRoot: opened.sourceRoot } : {}),
+                    ...(opened.contextFingerprint !== undefined
+                        ? { contextFingerprint: opened.contextFingerprint }
+                        : {}),
+                    ...(opened.capabilityFingerprint !== undefined
+                        ? { capabilityFingerprint: opened.capabilityFingerprint }
+                        : {}),
+                    ...(opened.capabilityCatalog !== undefined
+                        ? { capabilityCatalog: opened.capabilityCatalog }
+                        : {}),
+                    ...(opened.capabilityGuides !== undefined
+                        ? { capabilityGuides: opened.capabilityGuides }
+                        : {}),
+                    ...(opened.agentsFiles !== undefined ? { agentsFiles: opened.agentsFiles } : {}),
+                    ...(opened.availableAgentsFiles !== undefined
+                        ? { availableAgentsFiles: opened.availableAgentsFiles }
+                        : {}),
+                    ...(opened.skills !== undefined ? { skills: opened.skills } : {}),
+                    ...(opened.agentProviders !== undefined
+                        ? { agentProviders: opened.agentProviders }
+                        : {}),
+                    ...(opened.agents !== undefined ? { agents: opened.agents } : {}),
+                    ...(opened.skillDiagnostics !== undefined
+                        ? { skillDiagnostics: opened.skillDiagnostics }
+                        : {}),
+                    instruction: opened.instruction,
+                },
+            };
+            logToolCall(config, {
+                tool: "open_workspace",
+                action: "relay",
+                path: opened.root,
+                success: true,
+                durationMs: Math.round(performance.now() - startedAt),
+            });
+            rememberWorkspacePanelState(opened.workspaceId, response);
+            return response;
+        }
         const { workspace, agentsFiles, availableAgentsFiles, hookReports, workspaceReused, includeBootstrapContext, contextFingerprint, } = await workspaces.openWorkspace({ path, workspaceId, mode, baseRef, newWorktree, newWorkspace, context }, {
             conversationScopeId,
             protectedWorkspaceIds,
@@ -2086,6 +2655,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 tool: "open_workspace",
                 card: {
                     workspaceId: workspace.id,
+                    kind: "workspace",
                     root: workspace.root,
                     path: workspace.root,
                     mode: workspace.mode,
@@ -2118,6 +2688,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             structuredContent: {
                 action: "open",
                 workspaceId: workspace.id,
+                kind: "workspace",
                 root: workspace.root,
                 mode: workspace.mode,
                 sourceRoot: workspace.sourceRoot,
@@ -2144,12 +2715,41 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         rememberWorkspacePanelState(workspace.id, response);
         return response;
     });
-    registerActivityQueryTools(server, activityQueries, connectionScopeId, toolWidgetDescriptorMeta(config, "activity")._meta, config.activityPanelExpanded, config.logging, (workspaceId) => workspacePanelStates.get(workspaceId));
+    registerActivityQueryTools(server, activityQueries, connectionScopeId, toolWidgetDescriptorMeta(config, "activity")._meta, config.activityPanelExpanded, config.logging, workspacePanelState, {
+        panel: async (workspaceId, conversationScopeId) => {
+            if (compositeWorkspaces.has(workspaceId)) {
+                return compositeActivity.beginPanel(workspaceId, conversationScopeId);
+            }
+            return remoteWorkspaces.has(workspaceId)
+                ? remoteWorkspaces.activityPanel(workspaceId, conversationScopeId)
+                : undefined;
+        },
+        snapshot: async (input, conversationScopeId) => {
+            const compositeTurnId = input.turnId ?? (input.workspaceId && compositeWorkspaces.has(input.workspaceId)
+                ? compositeActivity.currentTurnId(conversationScopeId, input.workspaceId)
+                : undefined);
+            if (compositeTurnId) {
+                const composite = await compositeActivity.snapshot(compositeTurnId, input.knownRevision);
+                if (composite)
+                    return composite;
+            }
+            return remoteWorkspaces.activitySnapshot(input, conversationScopeId);
+        },
+        detail: async (turnId, activityId, conversationScopeId) => {
+            const composite = await compositeActivity.detail(turnId, activityId);
+            return composite ?? remoteWorkspaces.activityDetail(turnId, activityId, conversationScopeId);
+        },
+        output: async (turnId, outputId, conversationScopeId) => {
+            const composite = await compositeActivity.output(turnId, outputId);
+            return composite ?? remoteWorkspaces.activityOutput(turnId, outputId, conversationScopeId);
+        },
+    });
     registerAppTool(server, toolNames.capability, {
         title: "Use optional capability",
         description: "Describe or run one optional ForgeRelay capability advertised by open_workspace. Use describe when the capability contract is unfamiliar, then read its advertised guide if needed. Run dispatches only explicitly registered capabilities; it cannot invoke arbitrary shell commands, URLs, or methods.",
         inputSchema: {
             workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+            member: z.string().optional().describe("Required for a Composite Workspace; explicit member name whose capability surface is used."),
             name: z
                 .string()
                 .regex(/^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+$/)
@@ -2181,9 +2781,20 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             idempotentHint: false,
             openWorldHint: true,
         },
-    }, async ({ workspaceId, name, action, arguments: capabilityArguments, file }, extra) => {
+    }, async ({ workspaceId, member, name, action, arguments: capabilityArguments, file }, extra) => {
+        const target = resolveExecutionTarget(workspaceId, member);
+        const executionWorkspaceId = target.executionWorkspaceId;
+        const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+        if (remoteWorkspaces.has(executionWorkspaceId)) {
+            return presentExecutionResult(await remoteWorkspaces.capability(executionWorkspaceId, {
+                name,
+                action,
+                ...(capabilityArguments !== undefined ? { arguments: capabilityArguments } : {}),
+                ...(file !== undefined ? { file } : {}),
+            }, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+        }
         if (action === "run" && name === "batch.execute") {
-            const workspace = workspaces.getWorkspace(workspaceId);
+            const workspace = workspaces.getWorkspace(executionWorkspaceId);
             const startedAt = performance.now();
             try {
                 const execution = await capabilityRegistry.run(name, capabilityArguments ?? {}, capabilityContextFor(workspace), {
@@ -2204,7 +2815,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     success: true,
                     durationMs: Math.round(performance.now() - startedAt),
                 });
-                return result;
+                return presentExecutionResult(result, target);
             }
             catch (error) {
                 if (extra.signal.aborted)
@@ -2227,18 +2838,14 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     capability: name,
                     action,
                 }, result.content, startedAt);
-                return result;
+                return presentExecutionResult(result, target);
             }
         }
         if (action === "run") {
-            return coreOperations.capabilityRun({ workspaceId, name, arguments: capabilityArguments, file }, {
-                requestMeta: extra._meta,
-                signal: extra.signal,
-                sessionId: extra.sessionId,
-            });
+            return presentExecutionResult(await coreOperations.capabilityRun({ workspaceId: executionWorkspaceId, name, arguments: capabilityArguments, file }, executionContext), target);
         }
-        const workspace = workspaces.getWorkspace(workspaceId);
-        return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(extra._meta, extra.sessionId), { workspaceId, name, action, arguments: capabilityArguments, file }, {
+        const workspace = workspaces.getWorkspace(executionWorkspaceId);
+        return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(extra._meta, extra.sessionId), activityRequestFor({ workspaceId: executionWorkspaceId, name, action, arguments: capabilityArguments, file }, executionContext), {
             signal: extra.signal,
             tool: toolNames.capability,
             invocation: workspaceHookInvocation(workspace),
@@ -2291,11 +2898,11 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     return result;
                 }
             },
-        });
+        }, activityRelationFor(executionContext)).then((result) => presentExecutionResult(result, target));
     });
     registerAppTool(server, toolNames.closeWorkspace, {
         title: "Close workspace",
-        description: "Close one workspace after the user chooses cleanup. Checkout-backed workspaces release only the logical handle. Managed-worktree-backed workspaces finalize the existing safe worktree lifecycle, including hooks, commit/integration, and cleanup; provide commitMessage for that mode. Running processes prevent closure; completed background results are delivered with the close response when available.",
+        description: "Close one workspace after the user chooses cleanup. Composite Workspaces dissolve here: only the Composite identity and member links are removed; member Workspaces, files, processes, worktrees, and relay routes remain intact. Checkout-backed workspaces release only the logical handle. Managed-worktree-backed workspaces run the safe finalize lifecycle (hooks, commit, fast-forward integration, cleanup) and require commitMessage. Running processes block ordinary Workspace closure.",
         inputSchema: {
             workspaceId: z.string().describe("Workspace identifier to close."),
             commitMessage: z
@@ -2306,7 +2913,15 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         },
         outputSchema: resultOutputSchema({
             workspaceId: z.string(),
-            mode: z.enum(["checkout", "worktree"]),
+            kind: z.enum(["workspace", "composite"]).optional(),
+            mode: z.enum(["checkout", "worktree"]).optional(),
+            name: z.string().optional(),
+            members: z.array(z.object({
+                name: z.string(),
+                purpose: z.string(),
+                workspaceId: z.string(),
+            })).optional(),
+            dissolved: z.boolean().optional(),
             sourceRoot: z.string().optional(),
             branch: z.string().optional(),
             targetBranch: z.string().optional(),
@@ -2318,6 +2933,48 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         _meta: {},
         annotations: WRITE_TOOL_ANNOTATIONS,
     }, async ({ workspaceId, commitMessage }, extra) => {
+        if (compositeWorkspaces.has(workspaceId)) {
+            if (commitMessage !== undefined) {
+                throw new Error("close_workspace commitMessage is not valid when dissolving a Composite Workspace.");
+            }
+            const composite = compositeWorkspaces.dissolve(workspaceId);
+            compositeActivity.forgetComposite(workspaceId);
+            workspacePanelStates.delete(workspaceId);
+            const result = [
+                `Dissolved Composite Workspace ${composite.name} (${workspaceId}).`,
+                composite.members.length > 0
+                    ? `Preserved member Workspaces: ${composite.members.map((member) => `${member.name} [${member.workspaceId}]`).join(", ")}.`
+                    : "The Composite Workspace had no members.",
+                "Member Workspace handles, managed worktrees, processes, files, and Workspace Relay routes were not closed or cleaned up.",
+            ].join("\n");
+            return {
+                content: [textBlock(result)],
+                _meta: {
+                    tool: toolNames.closeWorkspace,
+                    card: {
+                        workspaceId,
+                        kind: "composite",
+                        name: composite.name,
+                        members: composite.members,
+                        dissolved: true,
+                        payload: { content: [textBlock(result)] },
+                    },
+                },
+                structuredContent: {
+                    result,
+                    workspaceId,
+                    kind: "composite",
+                    name: composite.name,
+                    members: composite.members,
+                    dissolved: true,
+                },
+            };
+        }
+        if (remoteWorkspaces.has(workspaceId)) {
+            const response = await remoteWorkspaces.closeWorkspace(workspaceId, commitMessage, hostScopeIdFor(extra._meta, extra.sessionId));
+            workspacePanelStates.delete(workspaceId);
+            return response;
+        }
         const workspace = workspaces.getWorkspace(workspaceId);
         const response = await runToolWithHooks(hooks, {
             signal: extra.signal,
@@ -2429,6 +3086,10 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             workspaceId: z
                 .string()
                 .describe("Workspace identifier returned by open_workspace."),
+            member: z
+                .string()
+                .optional()
+                .describe("Required for a Composite Workspace; explicit member name that owns this operation."),
             path: z
                 .string()
                 .optional()
@@ -2466,27 +3127,27 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         }),
         ...toolWidgetDescriptorMeta(config, "read"),
         annotations: { readOnlyHint: true },
-    }, async ({ workspaceId, path, paths, offset, limit }, extra) => {
+    }, async ({ workspaceId, member, path, paths, offset, limit }, extra) => {
         if ((path === undefined) === (paths === undefined)) {
             throw new Error("read requires exactly one of path or paths.");
         }
+        const target = resolveExecutionTarget(workspaceId, member);
+        const executionWorkspaceId = target.executionWorkspaceId;
+        const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+        if (remoteWorkspaces.has(executionWorkspaceId)) {
+            return presentExecutionResult(await remoteWorkspaces.read(executionWorkspaceId, { path, paths, offset, limit }, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+        }
         if (path !== undefined) {
-            return coreOperations.read({ workspaceId, path, offset, limit }, {
-                requestMeta: extra._meta,
-                signal: extra.signal,
-                sessionId: extra.sessionId,
-            });
+            return presentExecutionResult(await coreOperations.read({ workspaceId: executionWorkspaceId, path, offset, limit }, executionContext), target);
         }
-        const workspace = workspaces.getWorkspace(workspaceId);
+        const workspace = workspaces.getWorkspace(executionWorkspaceId);
         let response;
-        await runActivityTool(activityLifecycle, workspace, hostScopeIdFor(extra._meta, extra.sessionId), toolNames.read, { workspaceId, paths, offset, limit }, async (parentContext) => {
+        await runActivityTool(activityLifecycle, workspace, hostScopeIdFor(extra._meta, extra.sessionId), toolNames.read, activityRequestFor({ workspaceId: executionWorkspaceId, paths, offset, limit }, executionContext), async (parentContext) => {
             const execution = await executeBulkRead({
                 paths: paths,
                 signal: extra.signal,
-                run: (childPath) => coreOperations.read({ workspaceId, path: childPath, offset, limit }, {
-                    requestMeta: extra._meta,
-                    signal: extra.signal,
-                    sessionId: extra.sessionId,
+                run: (childPath) => coreOperations.read({ workspaceId: executionWorkspaceId, path: childPath, offset, limit }, {
+                    ...executionContext,
                     parentActivityId: parentContext.activityId,
                     turnId: parentContext.turnId,
                 }),
@@ -2527,10 +3188,10 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             };
         }, (summary) => summary.failed > 0
             ? { type: "failed", error: `${summary.failed} of ${summary.childCount} child Reads failed.` }
-            : { type: "succeeded" });
+            : { type: "succeeded" }, activityRelationFor(executionContext));
         if (!response)
             throw new Error("Bulk Read completed without a response.");
-        return response;
+        return presentExecutionResult(response, target);
     });
     if (config.toolMode !== "codex") {
         registerAppTool(server, toolNames.write, {
@@ -2540,6 +3201,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 workspaceId: z
                     .string()
                     .describe("Workspace identifier returned by open_workspace."),
+                member: z.string().optional().describe("Required for a Composite Workspace; explicit member name that owns this operation."),
                 path: z
                     .string()
                     .describe("File path to write, relative to the workspace root or absolute inside the OS temp directory."),
@@ -2548,11 +3210,15 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             outputSchema: resultOutputSchema(),
             ...toolWidgetDescriptorMeta(config, "write"),
             annotations: WRITE_TOOL_ANNOTATIONS,
-        }, async ({ workspaceId, ...input }, extra) => coreOperations.write({ workspaceId, ...input }, {
-            requestMeta: extra._meta,
-            signal: extra.signal,
-            sessionId: extra.sessionId,
-        }));
+        }, async ({ workspaceId, member, ...input }, extra) => {
+            const target = resolveExecutionTarget(workspaceId, member);
+            const executionWorkspaceId = target.executionWorkspaceId;
+            const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+            if (remoteWorkspaces.has(executionWorkspaceId)) {
+                return presentExecutionResult(await remoteWorkspaces.write(executionWorkspaceId, input, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+            }
+            return presentExecutionResult(await coreOperations.write({ workspaceId: executionWorkspaceId, ...input }, executionContext), target);
+        });
         registerAppTool(server, toolNames.edit, {
             title: "Edit file",
             description: toolDescriptions.edit,
@@ -2560,6 +3226,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 workspaceId: z
                     .string()
                     .describe("Workspace identifier returned by open_workspace."),
+                member: z.string().optional().describe("Required for a Composite Workspace; explicit member name that owns this operation."),
                 path: z
                     .string()
                     .optional()
@@ -2593,22 +3260,20 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             }),
             ...toolWidgetDescriptorMeta(config, "edit"),
             annotations: EDIT_TOOL_ANNOTATIONS,
-        }, async ({ workspaceId, path, paths, edits }, extra) => {
+        }, async ({ workspaceId, member, path, paths, edits }, extra) => {
             if ((path === undefined) === (paths === undefined)) {
                 throw new Error("edit requires exactly one of path or paths.");
             }
+            const target = resolveExecutionTarget(workspaceId, member);
+            const executionWorkspaceId = target.executionWorkspaceId;
+            const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+            if (remoteWorkspaces.has(executionWorkspaceId)) {
+                return presentExecutionResult(await remoteWorkspaces.edit(executionWorkspaceId, { path, paths, edits }, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+            }
             if (path !== undefined) {
-                return coreOperations.edit({ workspaceId, path, edits }, {
-                    requestMeta: extra._meta,
-                    signal: extra.signal,
-                    sessionId: extra.sessionId,
-                });
+                return presentExecutionResult(await coreOperations.edit({ workspaceId: executionWorkspaceId, path, edits }, executionContext), target);
             }
-            return nativeBulkMutations.edit({ workspaceId, paths: paths, edits }, {
-                requestMeta: extra._meta,
-                signal: extra.signal,
-                sessionId: extra.sessionId,
-            });
+            return presentExecutionResult(await nativeBulkMutations.edit({ workspaceId: executionWorkspaceId, paths: paths, edits }, executionContext), target);
         });
     }
     registerAppTool(server, toolNames.rename, {
@@ -2616,6 +3281,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         description: toolDescriptions.rename,
         inputSchema: {
             workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+            member: z.string().optional().describe("Required for a Composite Workspace; explicit member name that owns this operation."),
             path: z.string().describe("Source file or directory path relative to the workspace root, or absolute inside the OS temp directory."),
             newPath: z.string().describe("Destination path relative to the workspace root, or absolute inside the OS temp directory. The destination must not already exist."),
         },
@@ -2626,16 +3292,21 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         }),
         ...toolWidgetDescriptorMeta(config, "edit"),
         annotations: EDIT_TOOL_ANNOTATIONS,
-    }, async ({ workspaceId, path, newPath }, extra) => coreOperations.rename({ workspaceId, path, newPath }, {
-        requestMeta: extra._meta,
-        signal: extra.signal,
-        sessionId: extra.sessionId,
-    }));
+    }, async ({ workspaceId, member, path, newPath }, extra) => {
+        const target = resolveExecutionTarget(workspaceId, member);
+        const executionWorkspaceId = target.executionWorkspaceId;
+        const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+        if (remoteWorkspaces.has(executionWorkspaceId)) {
+            return presentExecutionResult(await remoteWorkspaces.rename(executionWorkspaceId, { path, newPath }, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+        }
+        return presentExecutionResult(await coreOperations.rename({ workspaceId: executionWorkspaceId, path, newPath }, executionContext), target);
+    });
     registerAppTool(server, toolNames.delete, {
         title: "Delete path",
         description: toolDescriptions.delete,
         inputSchema: {
             workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+            member: z.string().optional().describe("Required for a Composite Workspace; explicit member name that owns this operation."),
             path: z.string().optional().describe("One file or directory path to delete. Use exactly one of path or paths."),
             paths: z
                 .array(z.string())
@@ -2661,22 +3332,20 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         }),
         ...toolWidgetDescriptorMeta(config, "edit"),
         annotations: EDIT_TOOL_ANNOTATIONS,
-    }, async ({ workspaceId, path, paths, recursive }, extra) => {
+    }, async ({ workspaceId, member, path, paths, recursive }, extra) => {
         if ((path === undefined) === (paths === undefined)) {
             throw new Error("delete requires exactly one of path or paths.");
         }
+        const target = resolveExecutionTarget(workspaceId, member);
+        const executionWorkspaceId = target.executionWorkspaceId;
+        const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+        if (remoteWorkspaces.has(executionWorkspaceId)) {
+            return presentExecutionResult(await remoteWorkspaces.delete(executionWorkspaceId, { path, paths, recursive }, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+        }
         if (path !== undefined) {
-            return coreOperations.delete({ workspaceId, path, recursive }, {
-                requestMeta: extra._meta,
-                signal: extra.signal,
-                sessionId: extra.sessionId,
-            });
+            return presentExecutionResult(await coreOperations.delete({ workspaceId: executionWorkspaceId, path, recursive }, executionContext), target);
         }
-        return nativeBulkMutations.delete({ workspaceId, paths: paths, recursive }, {
-            requestMeta: extra._meta,
-            signal: extra.signal,
-            sessionId: extra.sessionId,
-        });
+        return presentExecutionResult(await nativeBulkMutations.delete({ workspaceId: executionWorkspaceId, paths: paths, recursive }, executionContext), target);
     });
     if (config.toolMode === "codex") {
         registerAppTool(server, "apply_patch", {
@@ -2686,6 +3355,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 workspaceId: z
                     .string()
                     .describe("Workspace identifier returned by open_workspace."),
+                member: z.string().optional().describe("Required for a Composite Workspace; explicit member name that owns this patch."),
                 patch: z
                     .string()
                     .describe("Patch text enclosed by *** Begin Patch and *** End Patch markers."),
@@ -2701,9 +3371,15 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             }),
             ...toolWidgetDescriptorMeta(config, "edit"),
             annotations: EDIT_TOOL_ANNOTATIONS,
-        }, async ({ workspaceId, patch }, extra) => {
-            const workspace = workspaces.getWorkspace(workspaceId);
-            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(extra._meta, extra.sessionId), { workspaceId, patch }, {
+        }, async ({ workspaceId, member, patch }, extra) => {
+            const target = resolveExecutionTarget(workspaceId, member);
+            const executionWorkspaceId = target.executionWorkspaceId;
+            const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+            if (remoteWorkspaces.has(executionWorkspaceId)) {
+                return presentExecutionResult(await remoteWorkspaces.applyPatch(executionWorkspaceId, { patch }, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+            }
+            const workspace = workspaces.getWorkspace(executionWorkspaceId);
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(extra._meta, extra.sessionId), activityRequestFor({ workspaceId: executionWorkspaceId, patch }, executionContext), {
                 signal: extra.signal,
                 tool: "apply_patch",
                 invocation: workspaceHookInvocation(workspace),
@@ -2731,7 +3407,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         _meta: {
                             tool: "apply_patch",
                             card: {
-                                workspaceId,
+                                workspaceId: executionWorkspaceId,
                                 path: displayPath,
                                 summary: {
                                     files: applied.files.length,
@@ -2750,7 +3426,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         },
                     };
                 },
-            });
+            }, activityRelationFor(executionContext)).then((result) => presentExecutionResult(result, target));
         });
     }
     if (config.toolMode !== "codex") {
@@ -2761,6 +3437,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 workspaceId: z
                     .string()
                     .describe("Workspace identifier returned by open_workspace."),
+                member: z.string().optional().describe("Required for a Composite Workspace; explicit member name that owns this process operation."),
                 action: z
                     .enum(["run", "process", "output"])
                     .optional()
@@ -2834,16 +3511,36 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             outputSchema: processOutputSchema(),
             ...toolWidgetDescriptorMeta(config, "shell"),
             annotations: SHELL_TOOL_ANNOTATIONS,
-        }, async ({ workspaceId, action = "run", command, processId, outputId, input, interrupt, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens, }, extra) => {
-            const workspace = workspaces.getWorkspace(workspaceId);
+        }, async ({ workspaceId, member, action = "run", command, processId, outputId, input, interrupt, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens, }, extra) => {
+            const target = resolveExecutionTarget(workspaceId, member);
+            const executionWorkspaceId = target.executionWorkspaceId;
+            const executionContext = await prepareExecutionContext(target, extra._meta, extra.signal, extra.sessionId);
+            if (remoteWorkspaces.has(executionWorkspaceId)) {
+                return presentExecutionResult(await remoteWorkspaces.bash(executionWorkspaceId, {
+                    action,
+                    ...(command !== undefined ? { command } : {}),
+                    ...(processId !== undefined ? { processId } : {}),
+                    ...(outputId !== undefined ? { outputId } : {}),
+                    ...(input !== undefined ? { input } : {}),
+                    ...(interrupt !== undefined ? { interrupt } : {}),
+                    ...(tty !== undefined ? { tty } : {}),
+                    ...(columns !== undefined ? { columns } : {}),
+                    ...(rows !== undefined ? { rows } : {}),
+                    ...(workingDirectory !== undefined ? { workingDirectory } : {}),
+                    ...(yieldTimeMs !== undefined ? { yieldTimeMs } : {}),
+                    ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+                    ...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
+                }, hostScopeIdFor(extra._meta, extra.sessionId)), target);
+            }
+            const workspace = workspaces.getWorkspace(executionWorkspaceId);
             if (action === "run") {
                 if (!command)
                     throw new Error("bash action=run requires command.");
                 if (processId !== undefined || outputId !== undefined || input !== undefined || interrupt !== undefined) {
                     throw new Error("bash action=run does not accept processId, outputId, input, or interrupt.");
                 }
-                return coreOperations.shellRun({
-                    workspaceId,
+                return presentExecutionResult(await coreOperations.shellRun({
+                    workspaceId: executionWorkspaceId,
                     command,
                     surface: "bash",
                     tty,
@@ -2853,11 +3550,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     yieldTimeMs,
                     timeoutMs,
                     maxOutputTokens,
-                }, {
-                    requestMeta: extra._meta,
-                    signal: extra.signal,
-                    sessionId: extra.sessionId,
-                });
+                }, executionContext), target);
             }
             if (action === "output") {
                 if (!outputId)
@@ -2872,8 +3565,8 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     tool: toolNames.shell,
                     invocation: workspaceHookInvocation(workspace),
                     payload: { action, outputId },
-                    operation: async () => durableOutputResponse(toolNames.shell, workspaceId, readWorkspaceBashOutput(bashOutputStore, workspaceId, outputId)),
-                });
+                    operation: async () => durableOutputResponse(toolNames.shell, executionWorkspaceId, readWorkspaceBashOutput(bashOutputStore, executionWorkspaceId, outputId)),
+                }).then((result) => presentExecutionResult(result, target));
             }
             if (outputId !== undefined)
                 throw new Error("bash action=process does not accept outputId.");
@@ -2901,7 +3594,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 operation: async () => {
                     const startedAt = performance.now();
                     const snapshot = await processSessions.write({
-                        workspaceId,
+                        workspaceId: executionWorkspaceId,
                         processId,
                         chars: interrupt ? "\u0003" : input,
                         columns,
@@ -2919,7 +3612,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         success: snapshot.running || snapshot.exitCode === 0,
                         durationMs: Math.round(performance.now() - startedAt),
                     });
-                    const response = processToolResponse(toolNames.shell, workspaceId, snapshot, {
+                    const response = processToolResponse(toolNames.shell, executionWorkspaceId, snapshot, {
                         action,
                         processId,
                         inputLength: input?.length ?? 0,
@@ -2931,12 +3624,20 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     if (!snapshot.running) {
                         recordBashCompletion(activityLifecycle, bashOutputStore, snapshot.outputId);
                     }
-                    return response;
+                    return presentExecutionResult(response, target);
                 },
             });
         });
     }
-    registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle, bashOutputStore, (input, context) => coreOperations.shellRun(input, context));
+    registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle, bashOutputStore, (input, context) => coreOperations.shellRun(input, context), {
+        resolve: resolveExecutionTarget,
+        prepare: prepareExecutionContext,
+        present: presentExecutionResult,
+        isRemote: (workspaceId) => remoteWorkspaces.has(workspaceId),
+        execCommandRemote: (workspaceId, input, conversationScopeId) => remoteWorkspaces.execCommand(workspaceId, input, conversationScopeId),
+        writeStdinRemote: (workspaceId, input, conversationScopeId) => remoteWorkspaces.writeStdin(workspaceId, input, conversationScopeId),
+        hostScopeIdFor,
+    });
     return server;
 }
 export function createServer(config = loadConfig(), options = {}) {
@@ -3069,6 +3770,8 @@ export function createServer(config = loadConfig(), options = {}) {
     });
     app.use(createForgeRelayAuthRouter({
         provider: oauthProvider,
+        cliAuthenticationProvider: oauthProvider,
+        instanceId: config.instanceId,
         issuerUrl: new URL(config.publicBaseUrl),
         resourceServerUrl,
         scopesSupported: config.oauth.scopes,