@akira-tl/forgerelay 0.6.1 → 0.7.1

package/dist/server.js

@@ -45,6 +45,8 @@ 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";
@@ -52,8 +54,10 @@ import { shutdownHttpServer } from "./server-shutdown.js";
 import { formatPathForPrompt } from "./skills.js";
 import { createWorkspaceStore } from "./workspace-store.js";
 import { formatAgentsPath, WorkspaceRegistry } from "./workspaces.js";
-import { summarizeLocalAgentProfile } from "./local-agent-profiles.js";
-import { formatLocalAgentProviderAvailabilitySummary, getLocalAgentProviderAvailabilitySnapshot, } from "./local-agent-availability.js";
+import { formatAvailableSubagentProfile, summarizeSubagentProfile } from "./subagents/profiles.js";
+import { formatSubagentProviderAvailabilitySummary, formatUnavailableSubagentProvider, getSubagentProviderAvailabilitySnapshot, } from "./subagents/providers/availability.js";
+import { capabilityActivityAuditRequest, capabilityActivityAuditResult } from "./subagents/sessions/mcp/audit.js";
+import { createSubagentMcpRuntime } from "./subagents/sessions/mcp/runtime.js";
 // Legacy MCP Streamable HTTP clients can reconnect without closing the previous
 // transport. Bound stale transport-session retention so abandoned transports do
 // not accumulate for the life of the process.
@@ -129,17 +133,6 @@ async function assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, wor
         "Apply these instructions, then retry this tool call. No mutation or command was executed.",
     ].join("\n"));
 }
-function formatVisibleAgent(agent) {
-    const model = agent.model ? `, model ${agent.model}` : "";
-    const thinking = agent.thinking ? `, thinking ${agent.thinking}` : "";
-    const availability = agent.providerAvailable === false
-        ? `, unavailable: ${agent.providerUnavailableReason ?? "provider unavailable"}`
-        : "";
-    return `${agent.name} (${agent.provider}${model}${thinking}${availability})`;
-}
-function formatUnavailableAgentProvider(provider) {
-    return `${provider.name} (${provider.reason ?? "unavailable"})`;
-}
 function resultOutputSchema(extra = {}) {
     return {
         result: z
@@ -226,9 +219,10 @@ const workspaceLocalAgentOutputSchema = z.object({
     providerAvailable: z.boolean().optional(),
     providerUnavailableReason: z.string().optional(),
 });
-const workspaceLocalAgentProviderOutputSchema = z.object({
+const workspaceSubagentProviderOutputSchema = z.object({
     name: z.string(),
     available: z.boolean(),
+    continuationSupported: z.boolean(),
     reason: z.string().optional(),
 });
 const workspaceAvailableAgentsFileOutputSchema = z.object({
@@ -876,6 +870,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 [];
@@ -956,7 +983,15 @@ function activityRelationFor(context) {
         ...(context.turnId ? { turnId: context.turnId } : {}),
     };
 }
-function runActivityTool(lifecycle, workspace, conversationScopeId, tool, request, operation, outcome = standardActivityOutcome, relation = {}) {
+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 = {}, auditResult) {
     return lifecycle.run({
         tool,
         workspace: workspaceActivitySnapshot(workspace),
@@ -964,19 +999,21 @@ function runActivityTool(lifecycle, workspace, conversationScopeId, tool, reques
         request,
         operation,
         outcome,
+        ...(auditResult ? { auditResult } : {}),
         ...relation,
     });
 }
 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()
@@ -1013,22 +1050,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;
@@ -1037,6 +1086,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."),
@@ -1061,8 +1111,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) {
@@ -1073,7 +1138,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);
@@ -1090,7 +1155,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,
@@ -1108,7 +1173,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,
@@ -1120,13 +1185,59 @@ 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) {
+export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, subagentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries, options = {}) {
     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 subagentMcp = createSubagentMcpRuntime(config, activityLifecycle, options);
+    const presentExecutionResult = (result, target) => {
+        const presented = !target.compositeWorkspaceId || !target.memberName
+            ? result
+            : remapCompositeToolResult(result, target.executionWorkspaceId, target.compositeWorkspaceId, target.memberName);
+        return subagentMcp.decorateResult(target.executionWorkspaceId, presented);
+    };
     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);
@@ -1136,6 +1247,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     const batchExecuteAvailable = config.toolMode !== "codex";
     const capabilityRegistry = createCapabilityRegistry({
         inspectHooks: (workspaceRoot) => checkHookConfiguration(workspaceRoot, config.hooks),
+        ...subagentMcp.registryDependencies,
         batchExecute: {
             available: batchExecuteAvailable,
             unavailableReason: batchExecuteAvailable
@@ -1224,11 +1336,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),
@@ -1300,7 +1460,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),
@@ -1361,7 +1521,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),
@@ -1423,7 +1583,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),
@@ -1482,7 +1642,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),
@@ -1566,7 +1726,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,
@@ -1640,7 +1800,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 runActivityTool(activityLifecycle, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), toolNames.capability, activityRequestFor(capabilityActivityAuditRequest(input), context), (activityContext) => runToolWithHooks(hooks, {
                 signal: context.signal,
                 tool: toolNames.capability,
                 invocation: workspaceHookInvocation(workspace),
@@ -1656,6 +1816,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                             requestMeta: context.requestMeta,
                             sessionId: context.sessionId,
                             batch: context.batch,
+                            activityId: activityContext.activityId,
                         });
                         changedPaths = execution.changedPaths ?? [];
                         const result = {
@@ -1708,7 +1869,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         return result;
                     }
                 },
-            }, activityRelationFor(context));
+            }), standardActivityOutcome, activityRelationFor(context), (result) => capabilityActivityAuditResult(name, result));
         },
     });
     batchExecutor = new BatchExecutor({
@@ -1794,16 +1955,44 @@ 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 coding workspace. Defaults to local execution; for a new workspace, relay may name a registered direct remote ForgeRelay. Reuse the returned Gateway workspaceId for later calls. Default to checkout; use mode=\"worktree\" only for explicitly isolated or parallel Git work. Bootstrap context is delivered automatically only when needed and can be 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()
@@ -1863,8 +2052,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(),
@@ -1907,10 +2105,22 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             agentsFiles: z.array(workspaceAgentsFileOutputSchema).optional(),
             availableAgentsFiles: z.array(workspaceAvailableAgentsFileOutputSchema).optional(),
             skills: z.array(workspaceSkillOutputSchema).optional(),
-            agentProviders: z.array(workspaceLocalAgentProviderOutputSchema).optional(),
+            agentProviders: z.array(workspaceSubagentProviderOutputSchema).optional(),
             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(),
@@ -1922,26 +2132,198 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             idempotentHint: false,
             openWorldHint: false,
         },
-    }, async ({ action = "open", path, relay, 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 || relay !== 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, relay, 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,
@@ -1953,6 +2335,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, {
@@ -1967,6 +2350,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 structuredContent: {
                     action: "list",
                     ...inventory,
+                    ...(composites.length > 0 ? { compositeWorkspaces: composites } : {}),
                     instruction,
                 },
             };
@@ -1975,6 +2359,70 @@ 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.");
@@ -2014,6 +2462,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     tool: "open_workspace",
                     card: {
                         workspaceId: opened.workspaceId,
+                        kind: "workspace",
                         root: opened.root,
                         path: opened.root,
                         mode: opened.mode,
@@ -2025,6 +2474,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 structuredContent: {
                     action: "open",
                     workspaceId: opened.workspaceId,
+                    kind: "workspace",
                     root: opened.root,
                     mode: opened.mode,
                     ...(opened.sourceRoot ? { sourceRoot: opened.sourceRoot } : {}),
@@ -2093,9 +2543,9 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             path: formatPathForPrompt(guide.filePath),
         }));
         const capabilityCatalog = capabilityRegistry.catalog(capabilityContextFor(workspace));
-        const cardAgentProviders = config.subagents ? localAgentProviders : [];
+        const cardAgentProviders = config.subagents ? subagentProviders : [];
         const cardAgents = workspace.agentProfiles.map((profile) => {
-            const summary = summarizeLocalAgentProfile(profile);
+            const summary = summarizeSubagentProfile(profile);
             const availability = cardAgentProviders.find((provider) => provider.name === summary.provider);
             return {
                 ...summary,
@@ -2173,10 +2623,10 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         ? `Available subagent providers: ${visibleAgentProviders.filter((provider) => provider.available).map((provider) => provider.name).join(", ")}`
                         : undefined,
                     visibleAgentProviders.some((provider) => !provider.available)
-                        ? `Unavailable subagent providers: ${visibleAgentProviders.filter((provider) => !provider.available).map(formatUnavailableAgentProvider).join(", ")}`
+                        ? `Unavailable subagent providers: ${visibleAgentProviders.filter((provider) => !provider.available).map(formatUnavailableSubagentProvider).join(", ")}`
                         : undefined,
                     visibleAgents.length > 0
-                        ? `Available subagent profiles: ${visibleAgents.map(formatVisibleAgent).join(", ")}`
+                        ? `Available subagent profiles: ${visibleAgents.map(formatAvailableSubagentProfile).join(", ")}`
                         : undefined,
                     knownWorktrees.length > 0
                         ? `Known worktrees: ${knownWorktrees.map((worktree) => `${worktree.path} [${worktree.workspaceId}]${worktree.branch ? ` branch=${worktree.branch}` : ""}${worktree.targetBranch ? ` target=${worktree.targetBranch}` : ""}${worktree.current ? " (current)" : ""}`).join(", ")}`
@@ -2202,6 +2652,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,
@@ -2234,6 +2685,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,
@@ -2261,18 +2713,40 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         return response;
     });
     registerActivityQueryTools(server, activityQueries, connectionScopeId, toolWidgetDescriptorMeta(config, "activity")._meta, config.activityPanelExpanded, config.logging, workspacePanelState, {
-        panel: async (workspaceId, conversationScopeId) => remoteWorkspaces.has(workspaceId)
-            ? remoteWorkspaces.activityPanel(workspaceId, conversationScopeId)
-            : undefined,
-        snapshot: (input, conversationScopeId) => remoteWorkspaces.activitySnapshot(input, conversationScopeId),
-        detail: (turnId, activityId, conversationScopeId) => remoteWorkspaces.activityDetail(turnId, activityId, conversationScopeId),
-        output: (turnId, outputId, conversationScopeId) => remoteWorkspaces.activityOutput(turnId, outputId, conversationScopeId),
+        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-]*)+$/)
@@ -2304,17 +2778,20 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             idempotentHint: false,
             openWorldHint: true,
         },
-    }, async ({ workspaceId, name, action, arguments: capabilityArguments, file }, extra) => {
-        if (remoteWorkspaces.has(workspaceId)) {
-            return remoteWorkspaces.capability(workspaceId, {
+    }, 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));
+            }, 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), {
@@ -2335,7 +2812,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)
@@ -2358,18 +2835,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),
@@ -2422,11 +2895,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
@@ -2437,7 +2910,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(),
@@ -2449,6 +2930,43 @@ 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);
@@ -2565,6 +3083,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()
@@ -2602,30 +3124,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.");
         }
-        if (remoteWorkspaces.has(workspaceId)) {
-            return remoteWorkspaces.read(workspaceId, { path, paths, offset, limit }, hostScopeIdFor(extra._meta, extra.sessionId));
+        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,
                 }),
@@ -2666,10 +3185,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, {
@@ -2679,6 +3198,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."),
@@ -2687,15 +3207,14 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             outputSchema: resultOutputSchema(),
             ...toolWidgetDescriptorMeta(config, "write"),
             annotations: WRITE_TOOL_ANNOTATIONS,
-        }, async ({ workspaceId, ...input }, extra) => {
-            if (remoteWorkspaces.has(workspaceId)) {
-                return remoteWorkspaces.write(workspaceId, input, hostScopeIdFor(extra._meta, 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 coreOperations.write({ workspaceId, ...input }, {
-                requestMeta: extra._meta,
-                signal: extra.signal,
-                sessionId: extra.sessionId,
-            });
+            return presentExecutionResult(await coreOperations.write({ workspaceId: executionWorkspaceId, ...input }, executionContext), target);
         });
         registerAppTool(server, toolNames.edit, {
             title: "Edit file",
@@ -2704,6 +3223,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()
@@ -2737,25 +3257,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.");
             }
-            if (remoteWorkspaces.has(workspaceId)) {
-                return remoteWorkspaces.edit(workspaceId, { path, paths, edits }, hostScopeIdFor(extra._meta, extra.sessionId));
+            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, {
@@ -2763,6 +3278,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."),
         },
@@ -2773,21 +3289,21 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         }),
         ...toolWidgetDescriptorMeta(config, "edit"),
         annotations: EDIT_TOOL_ANNOTATIONS,
-    }, async ({ workspaceId, path, newPath }, extra) => {
-        if (remoteWorkspaces.has(workspaceId)) {
-            return remoteWorkspaces.rename(workspaceId, { path, newPath }, hostScopeIdFor(extra._meta, 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 coreOperations.rename({ workspaceId, path, newPath }, {
-            requestMeta: extra._meta,
-            signal: extra.signal,
-            sessionId: extra.sessionId,
-        });
+        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())
@@ -2813,25 +3329,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.");
         }
-        if (remoteWorkspaces.has(workspaceId)) {
-            return remoteWorkspaces.delete(workspaceId, { path, paths, recursive }, hostScopeIdFor(extra._meta, extra.sessionId));
+        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", {
@@ -2841,6 +3352,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."),
@@ -2856,9 +3368,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),
@@ -2886,7 +3404,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         _meta: {
                             tool: "apply_patch",
                             card: {
-                                workspaceId,
+                                workspaceId: executionWorkspaceId,
                                 path: displayPath,
                                 summary: {
                                     files: applied.files.length,
@@ -2905,7 +3423,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         },
                     };
                 },
-            });
+            }, activityRelationFor(executionContext)).then((result) => presentExecutionResult(result, target));
         });
     }
     if (config.toolMode !== "codex") {
@@ -2916,6 +3434,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()
@@ -2989,9 +3508,12 @@ 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) => {
-            if (remoteWorkspaces.has(workspaceId)) {
-                return remoteWorkspaces.bash(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 } : {}),
@@ -3005,17 +3527,17 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     ...(yieldTimeMs !== undefined ? { yieldTimeMs } : {}),
                     ...(timeoutMs !== undefined ? { timeoutMs } : {}),
                     ...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
-                }, hostScopeIdFor(extra._meta, extra.sessionId));
+                }, hostScopeIdFor(extra._meta, extra.sessionId)), target);
             }
-            const workspace = workspaces.getWorkspace(workspaceId);
+            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,
@@ -3025,11 +3547,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)
@@ -3044,8 +3562,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.");
@@ -3073,7 +3591,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,
@@ -3091,7 +3609,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,
@@ -3103,12 +3621,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 = {}) {
@@ -3144,8 +3670,8 @@ export function createServer(config = loadConfig(), options = {}) {
     const reviewCheckpoints = createReviewCheckpointManager();
     const processSessions = new ProcessManager({ outputAudit: bashOutputStore });
     const codeIntelligence = new CodeIntelligenceManager(config);
-    const localAgentProviders = config.subagents
-        ? getLocalAgentProviderAvailabilitySnapshot()
+    const subagentProviders = config.subagents
+        ? getSubagentProviderAvailabilitySnapshot()
         : [];
     const logTransportCloseResults = (reason, results) => {
         let closedCount = 0;
@@ -3328,7 +3854,7 @@ export function createServer(config = loadConfig(), options = {}) {
                         });
                     }
                 };
-                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries);
+                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, subagentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries);
                 await server.connect(transport);
             }
             else {
@@ -3351,7 +3877,7 @@ export function createServer(config = loadConfig(), options = {}) {
     return {
         app,
         config,
-        localAgentProviders,
+        subagentProviders,
         close: () => {
             closePromise ??= (async () => {
                 clearInterval(transportCleanupTimer);
@@ -3377,7 +3903,7 @@ async function isMainModule() {
     return modulePath === entrypointPath;
 }
 if (await isMainModule()) {
-    const { app, config, close, localAgentProviders } = createServer();
+    const { app, config, close, subagentProviders } = createServer();
     const httpServer = app.listen(config.port, config.host, () => {
         console.log(`forgerelay listening on http://${config.host}:${config.port}/mcp`);
         console.log(`allowed roots: ${config.allowedRoots.join(", ")}`);
@@ -3393,7 +3919,7 @@ if (await isMainModule()) {
                 : `unsupported on ${process.platform}`;
         console.log(`native artifact download: ${artifactDownloadStatus}`);
         if (config.subagents) {
-            console.log(`subagent providers: ${formatLocalAgentProviderAvailabilitySummary(localAgentProviders)}`);
+            console.log(`subagent providers: ${formatSubagentProviderAvailabilitySummary(subagentProviders)}`);
         }
     });
     let shuttingDown = false;