@akira-tl/forgerelay 0.5.0 → 0.5.2

package/dist/server.js

@@ -15,6 +15,9 @@ import { registerAppResource, registerAppTool, RESOURCE_MIME_TYPE, } from "@mode
 import express from "express";
 import * as z from "zod/v4";
 import { applyPatch } from "./apply-patch.js";
+import { ActivityAuditStore } from "./activity/audit-store.js";
+import { BashOutputStore } from "./activity/bash-output-store.js";
+import { ActivityLifecycle, } from "./activity/lifecycle.js";
 import { buildCapabilityFingerprint } from "./capabilities.js";
 import { CapabilityError, createCapabilityRegistry, } from "./capability-registry.js";
 import { deletePath, renamePath } from "./file-mutations.js";
@@ -466,6 +469,24 @@ async function readWorkspaceAppResource(config, requestedUri, transportSessionId
         throw error;
     }
 }
+const PROCESS_RESPONSE_OUTPUT_LINES = 10;
+function compactProcessOutput(output) {
+    if (!output)
+        return { output: "", truncated: false };
+    const trailingNewline = output.endsWith("\n");
+    const body = trailingNewline ? output.slice(0, -1) : output;
+    const lines = body.split("\n");
+    if (lines.length <= PROCESS_RESPONSE_OUTPUT_LINES)
+        return { output, truncated: false };
+    const compact = lines.slice(-PROCESS_RESPONSE_OUTPUT_LINES).join("\n");
+    return {
+        output: trailingNewline ? `${compact}\n` : compact,
+        truncated: true,
+    };
+}
+function outputIdNotice(outputId) {
+    return outputId ? `Full output ID: ${outputId}.` : "";
+}
 function processResult(snapshot) {
     const status = snapshot.running
         ? `Process running with process ID ${snapshot.processId}.`
@@ -474,7 +495,8 @@ function processResult(snapshot) {
             : snapshot.signal
                 ? `Process exited after signal ${snapshot.signal}.`
                 : `Process exited with code ${snapshot.exitCode ?? "unknown"}.`;
-    return snapshot.output ? `${snapshot.output.replace(/\n$/, "")}\n${status}` : status;
+    const compact = compactProcessOutput(snapshot.output).output.replace(/\n$/, "");
+    return [compact, status, outputIdNotice(snapshot.outputId)].filter(Boolean).join("\n");
 }
 function completedProcessResult(snapshot) {
     const status = snapshot.timedOut
@@ -483,12 +505,14 @@ function completedProcessResult(snapshot) {
             ? `Background process ${snapshot.processId} exited after signal ${snapshot.signal}.`
             : `Background process ${snapshot.processId} exited with code ${snapshot.exitCode ?? "unknown"}.`;
     const command = `Command: ${snapshot.command}`;
-    const output = snapshot.output ? `\n${snapshot.output.replace(/\n$/, "")}` : "";
-    return `${status}\n${command}${output}`;
+    const output = compactProcessOutput(snapshot.output).output.replace(/\n$/, "");
+    return [status, command, output, outputIdNotice(snapshot.outputId)].filter(Boolean).join("\n");
 }
-function attachCompletedProcessNotices(processSessions, workspaceId, result) {
+function attachCompletedProcessNotices(processSessions, workspaceId, result, onCompleted) {
     if (result instanceof Error) {
         const completed = processSessions.takeCompleted(workspaceId);
+        for (const snapshot of completed)
+            onCompleted?.(snapshot);
         if (completed.length > 0) {
             result.message = [
                 result.message,
@@ -511,6 +535,8 @@ function attachCompletedProcessNotices(processSessions, workspaceId, result) {
                 : undefined
         : undefined;
     const completed = processSessions.takeCompleted(workspaceId, undefined, currentProcessId);
+    for (const snapshot of completed)
+        onCompleted?.(snapshot);
     if (completed.length === 0)
         return result;
     return {
@@ -525,6 +551,7 @@ function processOutputSchema() {
     return resultOutputSchema({
         processId: z.number().int().positive().optional().describe("Canonical process handle for bash(action=\"process\") or the active command adapter."),
         sessionId: z.number().int().positive().optional().describe("Deprecated alias of processId for compatibility."),
+        outputId: z.string().optional().describe("Stable local audit identifier for retrieving the complete original process output."),
         running: z.boolean(),
         exitCode: z.number().int().optional(),
         signal: z.string().optional(),
@@ -541,9 +568,10 @@ function readForgeRelayVersion() {
     return packageJson.version;
 }
 function processToolResponse(tool, workspaceId, snapshot, summary) {
+    const compact = compactProcessOutput(snapshot.output);
     const result = processResult(snapshot);
     const content = [textBlock(result)];
-    const outputSummary = textSummary(snapshot.output ? [textBlock(snapshot.output)] : []);
+    const outputSummary = textSummary(compact.output ? [textBlock(compact.output)] : []);
     return {
         content,
         _meta: {
@@ -558,15 +586,111 @@ function processToolResponse(tool, workspaceId, snapshot, summary) {
             result,
             processId: snapshot.processId,
             sessionId: snapshot.sessionId,
+            outputId: snapshot.outputId,
             running: snapshot.running,
             exitCode: snapshot.exitCode,
             signal: snapshot.signal,
             timedOut: snapshot.timedOut,
             wallTimeMs: snapshot.wallTimeMs,
-            outputTruncated: snapshot.outputTruncated,
+            outputTruncated: snapshot.outputTruncated || compact.truncated,
         },
     };
 }
+function durableOutputResult(record) {
+    const status = record.status === "running"
+        ? `Process ${record.processId} is still running.`
+        : record.timedOut
+            ? `Process ${record.processId} timed out and was terminated.`
+            : record.signal
+                ? `Process ${record.processId} exited after signal ${record.signal}.`
+                : `Process ${record.processId} exited with code ${record.exitCode ?? "unknown"}.`;
+    return [record.output.replace(/\n$/, ""), status, `Full output ID: ${record.outputId}.`]
+        .filter(Boolean)
+        .join("\n");
+}
+function durableOutputResponse(tool, workspaceId, record) {
+    const result = durableOutputResult(record);
+    const content = [textBlock(result)];
+    const finishedAt = record.finishedAt ? Date.parse(record.finishedAt) : Date.now();
+    const startedAt = Date.parse(record.startedAt);
+    return {
+        content,
+        _meta: {
+            tool,
+            card: {
+                workspaceId,
+                summary: textSummary(record.output ? [textBlock(record.output)] : []),
+                payload: { content },
+            },
+        },
+        structuredContent: {
+            result,
+            processId: record.processId,
+            sessionId: record.processId,
+            outputId: record.outputId,
+            running: record.status === "running",
+            exitCode: record.exitCode,
+            signal: record.signal,
+            timedOut: record.timedOut,
+            wallTimeMs: Math.max(0, Number.isFinite(finishedAt - startedAt) ? finishedAt - startedAt : 0),
+            outputTruncated: false,
+        },
+    };
+}
+function markReturnedOutput(store, result) {
+    if (typeof result !== "object" || result === null)
+        return;
+    const structured = result.structuredContent;
+    if (typeof structured !== "object" || structured === null)
+        return;
+    const record = structured;
+    if (record.running === true && typeof record.outputId === "string") {
+        store.markReturned(record.outputId);
+    }
+}
+function readWorkspaceBashOutput(store, workspaceId, outputId) {
+    const record = store.read(outputId);
+    if (!record)
+        throw new Error(`Unknown Bash output: ${outputId}`);
+    if (record.workspaceId !== workspaceId) {
+        throw new Error(`Bash output ${outputId} does not belong to workspace ${workspaceId}.`);
+    }
+    return record;
+}
+function bashCompletionError(record) {
+    if (record.error)
+        return record.error;
+    if (record.timedOut)
+        return `Background process ${record.processId} timed out.`;
+    if (record.signal)
+        return `Background process ${record.processId} exited after signal ${record.signal}.`;
+    return `Background process ${record.processId} exited with code ${record.exitCode ?? "unknown"}.`;
+}
+function recordBashCompletion(lifecycle, store, outputId) {
+    if (!outputId)
+        return;
+    const completion = store.claimCompletion(outputId);
+    if (!completion)
+        return;
+    lifecycle.recordLinked({
+        sourceActivityId: completion.activityId,
+        tool: "bash_result",
+        request: {
+            processId: completion.processId,
+            outputId: completion.outputId,
+        },
+        result: {
+            processId: completion.processId,
+            outputId: completion.outputId,
+            exitCode: completion.exitCode,
+            signal: completion.signal,
+            timedOut: completion.timedOut,
+        },
+        outcome: completion.status === "failed"
+            ? { type: "failed", error: bashCompletionError(completion) }
+            : { type: "succeeded" },
+    });
+}
 function workspaceHookInvocation(workspace) {
     return {
         workspaceId: workspace.id,
@@ -597,7 +721,77 @@ async function reviewWorkspaceChanges(reviewCheckpoints, workspace) {
 function toolResultIsError(result) {
     return typeof result === "object" && result !== null && result.isError === true;
 }
-function registerProcessTools(server, config, workspaces, processSessions, hooks) {
+function workspaceActivitySnapshot(workspace) {
+    return {
+        id: workspace.id,
+        root: workspace.root,
+        mode: workspace.mode,
+        ...(workspace.sourceRoot ? { sourceRoot: workspace.sourceRoot } : {}),
+        ...(workspace.worktree?.branch ? { branch: workspace.worktree.branch } : {}),
+        ...(workspace.worktree?.targetBranch ? { targetBranch: workspace.worktree.targetBranch } : {}),
+    };
+}
+function activityFailureMessage(result) {
+    if (typeof result !== "object" || result === null)
+        return "Tool returned a failed result.";
+    const record = result;
+    if (Array.isArray(record.content)) {
+        const text = record.content
+            .map((entry) => {
+            if (typeof entry !== "object" || entry === null)
+                return "";
+            const value = entry.text;
+            return typeof value === "string" ? value : "";
+        })
+            .filter(Boolean)
+            .join("\n");
+        if (text)
+            return text;
+    }
+    if (typeof record.structuredContent === "object" && record.structuredContent !== null) {
+        const value = record.structuredContent.result;
+        if (typeof value === "string" && value)
+            return value;
+    }
+    return "Tool returned a failed result.";
+}
+function standardActivityOutcome(result) {
+    return toolResultIsError(result)
+        ? { type: "failed", error: activityFailureMessage(result) }
+        : { type: "succeeded" };
+}
+function processActivityOutcome(result) {
+    if (toolResultIsError(result))
+        return { type: "failed", error: activityFailureMessage(result) };
+    if (typeof result !== "object" || result === null)
+        return { type: "succeeded" };
+    const structured = result.structuredContent;
+    if (typeof structured !== "object" || structured === null)
+        return { type: "succeeded" };
+    const process = structured;
+    if (process.running === true)
+        return { type: "returned" };
+    if (process.timedOut === true ||
+        typeof process.signal === "string" ||
+        (typeof process.exitCode === "number" && process.exitCode !== 0)) {
+        return { type: "failed", error: activityFailureMessage(result) };
+    }
+    return { type: "succeeded" };
+}
+function runActivityTool(lifecycle, workspace, requestMeta, tool, request, operation, outcome = standardActivityOutcome) {
+    return lifecycle.run({
+        tool,
+        workspace: workspaceActivitySnapshot(workspace),
+        conversationScopeId: openAiConversationScopeId(requestMeta),
+        request,
+        operation,
+        outcome,
+    });
+}
+function runActivityToolWithHooks(lifecycle, hooks, workspace, requestMeta, request, hookOptions) {
+    return runActivityTool(lifecycle, workspace, requestMeta, hookOptions.tool, request, () => runToolWithHooks(hooks, hookOptions));
+}
+function registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle, bashOutputStore) {
     if (config.toolMode === "codex") {
         registerAppTool(server, "exec_command", {
             title: "Execute command",
@@ -643,72 +837,78 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
         }, async ({ workspaceId, cmd, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens }, extra) => {
             const workspace = workspaces.getWorkspace(workspaceId);
             let undeliveredProcessId;
-            try {
-                const result = await runToolWithHooks(hooks, {
-                    signal: extra.signal,
-                    tool: "exec_command",
-                    invocation: workspaceHookInvocation(workspace),
-                    payload: { command: cmd, workingDirectory: workingDirectory ?? "." },
-                    operation: async () => {
-                        const startedAt = performance.now();
-                        const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
-                        await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [cwd]);
-                        const snapshot = await processSessions.start({
-                            workspaceId,
-                            command: cmd,
-                            cwd,
-                            workspaceRoot: workspace.root,
-                            tty,
-                            columns,
-                            rows,
-                            yieldTimeMs,
-                            timeoutMs,
-                            maxOutputTokens,
-                            codexCi: true,
-                            signal: extra.signal,
-                        });
-                        undeliveredProcessId = snapshot.running ? snapshot.processId : undefined;
-                        logToolCall(config, {
-                            tool: "exec_command",
-                            ...workspaceLogContext(workspace, extra.sessionId),
-                            workingDirectory: workingDirectory ?? ".",
-                            command: cmd,
-                            commandLength: cmd.length,
-                            exitCode: snapshot.exitCode,
-                            running: snapshot.running,
-                            processId: snapshot.processId,
-                            success: snapshot.running || snapshot.exitCode === 0,
-                            durationMs: Math.round(performance.now() - startedAt),
-                        });
-                        return processToolResponse("exec_command", workspaceId, snapshot, {
-                            command: cmd,
-                            workingDirectory: workingDirectory ?? ".",
-                            running: snapshot.running,
-                            exitCode: snapshot.exitCode,
-                            wallTimeMs: snapshot.wallTimeMs,
-                        });
-                    },
-                });
-                extra.signal.throwIfAborted();
-                return result;
-            }
-            catch (error) {
-                if (undeliveredProcessId !== undefined) {
-                    processSessions.discardUndelivered(workspaceId, undeliveredProcessId);
+            const activityResult = await runActivityTool(activityLifecycle, workspace, extra._meta, "exec_command", { workspaceId, cmd, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens }, async (activityContext) => {
+                try {
+                    const result = await runToolWithHooks(hooks, {
+                        signal: extra.signal,
+                        tool: "exec_command",
+                        invocation: workspaceHookInvocation(workspace),
+                        payload: { command: cmd, workingDirectory: workingDirectory ?? "." },
+                        operation: async () => {
+                            const startedAt = performance.now();
+                            const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
+                            await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [cwd]);
+                            const snapshot = await processSessions.start({
+                                workspaceId,
+                                command: cmd,
+                                cwd,
+                                workspaceRoot: workspace.root,
+                                tty,
+                                columns,
+                                rows,
+                                yieldTimeMs,
+                                timeoutMs,
+                                maxOutputTokens,
+                                codexCi: true,
+                                signal: extra.signal,
+                                audit: activityContext,
+                            });
+                            undeliveredProcessId = snapshot.running ? snapshot.processId : undefined;
+                            logToolCall(config, {
+                                tool: "exec_command",
+                                ...workspaceLogContext(workspace, extra.sessionId),
+                                workingDirectory: workingDirectory ?? ".",
+                                command: cmd,
+                                commandLength: cmd.length,
+                                exitCode: snapshot.exitCode,
+                                running: snapshot.running,
+                                processId: snapshot.processId,
+                                success: snapshot.running || snapshot.exitCode === 0,
+                                durationMs: Math.round(performance.now() - startedAt),
+                            });
+                            return processToolResponse("exec_command", workspaceId, snapshot, {
+                                command: cmd,
+                                workingDirectory: workingDirectory ?? ".",
+                                running: snapshot.running,
+                                exitCode: snapshot.exitCode,
+                                wallTimeMs: snapshot.wallTimeMs,
+                            });
+                        },
+                    });
+                    extra.signal.throwIfAborted();
+                    return result;
                 }
-                throw error;
-            }
+                catch (error) {
+                    if (undeliveredProcessId !== undefined) {
+                        processSessions.discardUndelivered(workspaceId, undeliveredProcessId);
+                    }
+                    throw error;
+                }
+            }, processActivityOutcome);
+            markReturnedOutput(bashOutputStore, activityResult);
+            return activityResult;
         });
     }
     if (config.toolMode !== "codex")
         return;
     registerAppTool(server, "write_stdin", {
         title: "Write to process",
-        description: "Poll or write characters to a running process returned by bash or exec_command. Omit chars or pass an empty string to poll. Waiting never kills the process; pass \\u0003 to explicitly send Ctrl-C.",
+        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."),
             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."),
             chars: z.string().optional().describe("Characters to write. Omit or pass an empty string to poll."),
             columns: z.number().int().min(1).max(1_000).optional().describe("Resize a PTY to this width."),
             rows: z.number().int().min(1).max(1_000).optional().describe("Resize a PTY to this height."),
@@ -730,8 +930,21 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
         outputSchema: processOutputSchema(),
         ...toolWidgetDescriptorMeta(config, "shell"),
         annotations: SHELL_TOOL_ANNOTATIONS,
-    }, async ({ workspaceId, processId, sessionId, chars, columns, rows, yieldTimeMs, maxOutputTokens }, extra) => {
+    }, async ({ workspaceId, processId, sessionId, outputId, chars, columns, rows, yieldTimeMs, maxOutputTokens }, extra) => {
         const workspace = workspaces.getWorkspace(workspaceId);
+        if (outputId !== undefined) {
+            if (processId !== undefined || sessionId !== undefined || chars !== undefined || columns !== undefined ||
+                rows !== undefined || yieldTimeMs !== undefined || maxOutputTokens !== undefined) {
+                throw new Error("write_stdin outputId lookup cannot be combined with process control fields.");
+            }
+            return runToolWithHooks(hooks, {
+                signal: extra.signal,
+                tool: "write_stdin",
+                invocation: workspaceHookInvocation(workspace),
+                payload: { outputId },
+                operation: async () => durableOutputResponse("write_stdin", workspaceId, readWorkspaceBashOutput(bashOutputStore, workspaceId, outputId)),
+            });
+        }
         const resolvedProcessId = resolveProcessId(processId, sessionId);
         return runToolWithHooks(hooks, {
             signal: extra.signal,
@@ -764,20 +977,24 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
                     success: snapshot.running || snapshot.exitCode === 0,
                     durationMs: Math.round(performance.now() - startedAt),
                 });
-                return processToolResponse("write_stdin", workspaceId, snapshot, {
+                const response = processToolResponse("write_stdin", workspaceId, snapshot, {
                     processId: resolvedProcessId,
                     charactersWritten: chars?.length ?? 0,
                     running: snapshot.running,
                     exitCode: snapshot.exitCode,
                     wallTimeMs: snapshot.wallTimeMs,
                 });
+                if (!snapshot.running) {
+                    recordBashCompletion(activityLifecycle, bashOutputStore, snapshot.outputId);
+                }
+                return response;
             },
         });
     });
 }
-export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence) {
+export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore) {
     const toolDescriptions = buildToolDescriptions(config);
-    const hooks = new HookRunner(config.hooks, config.logging, process.env, (workspaceId, result) => attachCompletedProcessNotices(processSessions, workspaceId, result));
+    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);
     const artifactDownloadAvailable = config.artifactsEnabled && isArtifactDownloadSupportedPlatform();
     const reviewChangesAvailable = config.widgets === "changes";
@@ -1287,7 +1504,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     }, async ({ workspaceId, name, action, arguments: capabilityArguments, file }, extra) => {
         const workspace = workspaces.getWorkspace(workspaceId);
         let changedPaths = [];
-        return runToolWithHooks(hooks, {
+        return runActivityToolWithHooks(activityLifecycle, hooks, workspace, extra._meta, { workspaceId, name, action, arguments: capabilityArguments, file }, {
             signal: extra.signal,
             tool: toolNames.capability,
             invocation: workspaceHookInvocation(workspace),
@@ -1510,7 +1727,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         annotations: { readOnlyHint: true },
     }, async ({ workspaceId, ...input }, extra) => {
         const workspace = workspaces.getWorkspace(workspaceId);
-        return runToolWithHooks(hooks, {
+        return runActivityToolWithHooks(activityLifecycle, hooks, workspace, extra._meta, { workspaceId, ...input }, {
             signal: extra.signal,
             tool: toolNames.read,
             invocation: workspaceHookInvocation(workspace),
@@ -1597,7 +1814,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             annotations: WRITE_TOOL_ANNOTATIONS,
         }, async ({ workspaceId, ...input }, extra) => {
             const workspace = workspaces.getWorkspace(workspaceId);
-            return runToolWithHooks(hooks, {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, extra._meta, { workspaceId, ...input }, {
                 signal: extra.signal,
                 tool: toolNames.write,
                 invocation: workspaceHookInvocation(workspace),
@@ -1681,7 +1898,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             annotations: EDIT_TOOL_ANNOTATIONS,
         }, async ({ workspaceId, ...input }, extra) => {
             const workspace = workspaces.getWorkspace(workspaceId);
-            return runToolWithHooks(hooks, {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, extra._meta, { workspaceId, ...input }, {
                 signal: extra.signal,
                 tool: toolNames.edit,
                 invocation: workspaceHookInvocation(workspace),
@@ -1758,7 +1975,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         annotations: EDIT_TOOL_ANNOTATIONS,
     }, async ({ workspaceId, path, newPath }, extra) => {
         const workspace = workspaces.getWorkspace(workspaceId);
-        return runToolWithHooks(hooks, {
+        return runActivityToolWithHooks(activityLifecycle, hooks, workspace, extra._meta, { workspaceId, path, newPath }, {
             signal: extra.signal,
             tool: toolNames.rename,
             invocation: workspaceHookInvocation(workspace),
@@ -1831,7 +2048,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         annotations: EDIT_TOOL_ANNOTATIONS,
     }, async ({ workspaceId, path, recursive }, extra) => {
         const workspace = workspaces.getWorkspace(workspaceId);
-        return runToolWithHooks(hooks, {
+        return runActivityToolWithHooks(activityLifecycle, hooks, workspace, extra._meta, { workspaceId, path, recursive }, {
             signal: extra.signal,
             tool: toolNames.delete,
             invocation: workspaceHookInvocation(workspace),
@@ -1912,7 +2129,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             annotations: EDIT_TOOL_ANNOTATIONS,
         }, async ({ workspaceId, patch }, extra) => {
             const workspace = workspaces.getWorkspace(workspaceId);
-            return runToolWithHooks(hooks, {
+            return runActivityToolWithHooks(activityLifecycle, hooks, workspace, extra._meta, { workspaceId, patch }, {
                 signal: extra.signal,
                 tool: "apply_patch",
                 invocation: workspaceHookInvocation(workspace),
@@ -1971,9 +2188,9 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     .string()
                     .describe("Workspace identifier returned by open_workspace."),
                 action: z
-                    .enum(["run", "process"])
+                    .enum(["run", "process", "output"])
                     .optional()
-                    .describe("Defaults to run. Use process with a returned processId to poll, interact, resize, or interrupt a running command."),
+                    .describe("Defaults to run. Use process with a returned processId to poll/interact, or output with outputId to retrieve complete durable output."),
                 command: z
                     .string()
                     .optional()
@@ -1984,6 +2201,10 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     .positive()
                     .optional()
                     .describe("Process identifier returned by a previous bash action=run call. Required for action=process."),
+                outputId: z
+                    .string()
+                    .optional()
+                    .describe("Stable output identifier returned by a Bash run. Required for action=output."),
                 input: z
                     .string()
                     .optional()
@@ -2039,79 +2260,113 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             outputSchema: processOutputSchema(),
             ...toolWidgetDescriptorMeta(config, "shell"),
             annotations: SHELL_TOOL_ANNOTATIONS,
-        }, async ({ workspaceId, action = "run", command, processId, input, interrupt, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens, }, extra) => {
+        }, async ({ workspaceId, action = "run", command, processId, outputId, input, interrupt, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens, }, extra) => {
             const workspace = workspaces.getWorkspace(workspaceId);
             if (action === "run") {
                 if (!command)
                     throw new Error("bash action=run requires command.");
-                if (processId !== undefined || input !== undefined || interrupt !== undefined) {
-                    throw new Error("bash action=run does not accept processId, input, or interrupt.");
+                if (processId !== undefined || outputId !== undefined || input !== undefined || interrupt !== undefined) {
+                    throw new Error("bash action=run does not accept processId, outputId, input, or interrupt.");
                 }
                 let undeliveredProcessId;
-                try {
-                    const result = await runToolWithHooks(hooks, {
-                        signal: extra.signal,
-                        tool: toolNames.shell,
-                        invocation: workspaceHookInvocation(workspace),
-                        payload: {
-                            action,
-                            command,
-                            workingDirectory: workingDirectory ?? ".",
-                        },
-                        isFailure: toolResultIsError,
-                        operation: async () => {
-                            const startedAt = performance.now();
-                            const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
-                            await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [cwd]);
-                            const snapshot = await processSessions.start({
-                                workspaceId,
-                                command,
-                                cwd,
-                                workspaceRoot: workspace.root,
-                                tty,
-                                columns,
-                                rows,
-                                yieldTimeMs,
-                                timeoutMs,
-                                maxOutputTokens,
-                                signal: extra.signal,
-                            });
-                            undeliveredProcessId = snapshot.running ? snapshot.processId : undefined;
-                            logToolCall(config, {
-                                tool: toolNames.shell,
-                                ...workspaceLogContext(workspace, extra.sessionId),
-                                workingDirectory: workingDirectory ?? ".",
-                                command,
-                                commandLength: command.length,
-                                exitCode: snapshot.exitCode,
-                                running: snapshot.running,
-                                processId: snapshot.processId,
-                                success: snapshot.running || (snapshot.exitCode === 0 && !snapshot.signal),
-                                durationMs: Math.round(performance.now() - startedAt),
-                            });
-                            const response = processToolResponse(toolNames.shell, workspaceId, snapshot, {
+                const activityResult = await runActivityTool(activityLifecycle, workspace, extra._meta, toolNames.shell, {
+                    workspaceId,
+                    action,
+                    command,
+                    tty,
+                    columns,
+                    rows,
+                    workingDirectory,
+                    yieldTimeMs,
+                    timeoutMs,
+                    maxOutputTokens,
+                }, async (activityContext) => {
+                    try {
+                        const result = await runToolWithHooks(hooks, {
+                            signal: extra.signal,
+                            tool: toolNames.shell,
+                            invocation: workspaceHookInvocation(workspace),
+                            payload: {
                                 action,
                                 command,
                                 workingDirectory: workingDirectory ?? ".",
-                                running: snapshot.running,
-                                exitCode: snapshot.exitCode,
-                                wallTimeMs: snapshot.wallTimeMs,
-                            });
-                            return !snapshot.running && (snapshot.signal || snapshot.exitCode !== 0)
-                                ? { ...response, isError: true }
-                                : response;
-                        },
-                    });
-                    extra.signal.throwIfAborted();
-                    return result;
-                }
-                catch (error) {
-                    if (undeliveredProcessId !== undefined) {
-                        processSessions.discardUndelivered(workspaceId, undeliveredProcessId);
+                            },
+                            isFailure: toolResultIsError,
+                            operation: async () => {
+                                const startedAt = performance.now();
+                                const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
+                                await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [cwd]);
+                                const snapshot = await processSessions.start({
+                                    workspaceId,
+                                    command,
+                                    cwd,
+                                    workspaceRoot: workspace.root,
+                                    tty,
+                                    columns,
+                                    rows,
+                                    yieldTimeMs,
+                                    timeoutMs,
+                                    maxOutputTokens,
+                                    signal: extra.signal,
+                                    audit: activityContext,
+                                });
+                                undeliveredProcessId = snapshot.running ? snapshot.processId : undefined;
+                                logToolCall(config, {
+                                    tool: toolNames.shell,
+                                    ...workspaceLogContext(workspace, extra.sessionId),
+                                    workingDirectory: workingDirectory ?? ".",
+                                    command,
+                                    commandLength: command.length,
+                                    exitCode: snapshot.exitCode,
+                                    running: snapshot.running,
+                                    processId: snapshot.processId,
+                                    success: snapshot.running || (snapshot.exitCode === 0 && !snapshot.signal),
+                                    durationMs: Math.round(performance.now() - startedAt),
+                                });
+                                const response = processToolResponse(toolNames.shell, workspaceId, snapshot, {
+                                    action,
+                                    command,
+                                    workingDirectory: workingDirectory ?? ".",
+                                    running: snapshot.running,
+                                    exitCode: snapshot.exitCode,
+                                    wallTimeMs: snapshot.wallTimeMs,
+                                });
+                                return !snapshot.running && (snapshot.signal || snapshot.exitCode !== 0)
+                                    ? { ...response, isError: true }
+                                    : response;
+                            },
+                        });
+                        extra.signal.throwIfAborted();
+                        return result;
                     }
-                    throw error;
+                    catch (error) {
+                        if (undeliveredProcessId !== undefined) {
+                            processSessions.discardUndelivered(workspaceId, undeliveredProcessId);
+                        }
+                        throw error;
+                    }
+                }, processActivityOutcome);
+                markReturnedOutput(bashOutputStore, activityResult);
+                return activityResult;
+            }
+            if (action === "output") {
+                if (!outputId)
+                    throw new Error("bash action=output requires outputId.");
+                if (command !== undefined || processId !== undefined || input !== undefined || interrupt !== undefined ||
+                    tty !== undefined || columns !== undefined || rows !== undefined || workingDirectory !== undefined ||
+                    yieldTimeMs !== undefined || timeoutMs !== undefined || maxOutputTokens !== undefined) {
+                    throw new Error("bash action=output accepts only workspaceId and outputId.");
                 }
+                return runToolWithHooks(hooks, {
+                    signal: extra.signal,
+                    tool: toolNames.shell,
+                    invocation: workspaceHookInvocation(workspace),
+                    payload: { action, outputId },
+                    operation: async () => durableOutputResponse(toolNames.shell, workspaceId, readWorkspaceBashOutput(bashOutputStore, workspaceId, outputId)),
+                });
             }
+            if (outputId !== undefined)
+                throw new Error("bash action=process does not accept outputId.");
             if (command !== undefined || workingDirectory !== undefined || tty !== undefined || timeoutMs !== undefined) {
                 throw new Error("bash action=process does not accept command, workingDirectory, tty, or timeoutMs.");
             }
@@ -2154,7 +2409,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         success: snapshot.running || snapshot.exitCode === 0,
                         durationMs: Math.round(performance.now() - startedAt),
                     });
-                    return processToolResponse(toolNames.shell, workspaceId, snapshot, {
+                    const response = processToolResponse(toolNames.shell, workspaceId, snapshot, {
                         action,
                         processId,
                         inputLength: input?.length ?? 0,
@@ -2163,11 +2418,15 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         exitCode: snapshot.exitCode,
                         wallTimeMs: snapshot.wallTimeMs,
                     });
+                    if (!snapshot.running) {
+                        recordBashCompletion(activityLifecycle, bashOutputStore, snapshot.outputId);
+                    }
+                    return response;
                 },
             });
         });
     }
-    registerProcessTools(server, config, workspaces, processSessions, hooks);
+    registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle, bashOutputStore);
     return server;
 }
 export function createServer(config = loadConfig(), options = {}) {
@@ -2193,8 +2452,11 @@ export function createServer(config = loadConfig(), options = {}) {
     });
     const workspaceStore = createWorkspaceStore(config.stateDir);
     const workspaces = new WorkspaceRegistry(config, workspaceStore);
+    const activityAuditStore = new ActivityAuditStore(config.stateDir);
+    const activityLifecycle = new ActivityLifecycle(activityAuditStore);
+    const bashOutputStore = new BashOutputStore(config.stateDir);
     const reviewCheckpoints = createReviewCheckpointManager();
-    const processSessions = new ProcessManager();
+    const processSessions = new ProcessManager({ outputAudit: bashOutputStore });
     const codeIntelligence = new CodeIntelligenceManager(config);
     const localAgentProviders = config.subagents
         ? getLocalAgentProviderAvailabilitySnapshot()
@@ -2379,7 +2641,7 @@ export function createServer(config = loadConfig(), options = {}) {
                         });
                     }
                 };
-                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence);
+                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore);
                 await server.connect(transport);
             }
             else {
@@ -2411,6 +2673,8 @@ export function createServer(config = loadConfig(), options = {}) {
                 processSessions.shutdown();
                 await codeIntelligence.shutdown();
                 oauthProvider.close();
+                bashOutputStore.close();
+                activityAuditStore.close();
                 workspaceStore.close?.();
             })();
             return closePromise;