fix(web): show command exit codes (#11)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Author: incognitojam

apps/server/src/orchestration/ActivityPayloadProjection.test.ts

@@ -14,6 +14,16 @@ function activity(payload: Record<string, unknown>): OrchestrationThreadActivity
   } as unknown as OrchestrationThreadActivity;
 }
 
+function commandActivity(data: Record<string, unknown>): OrchestrationThreadActivity {
+  return activity({
+    itemType: "command_execution",
+    status: "completed",
+    title: "Ran command",
+    detail: "/bin/zsh -lc 'echo ping'",
+    data,
+  });
+}
+
 /**
  * Wire-survival regression: the slimming pass rewrites payload.data but must
  * never strip the top-level per-agent fields the subagent fold depends on.
@@ -115,3 +125,73 @@ describe("projectActivityPayload agent-field survival", () => {
     expect(projected.payload).toEqual(source.payload);
   });
 });
+
+describe("projectActivityPayload command exit codes", () => {
+  it("retains a Codex command exit code while dropping command output", () => {
+    const projected = projectActivityPayload(
+      commandActivity({
+        completedAtMs: 1_785_974_254_706,
+        item: {
+          aggregatedOutput: "ping\n",
+          command: "/bin/zsh -lc 'echo ping'",
+          exitCode: 0,
+          status: "completed",
+        },
+      }),
+    );
+
+    expect(projected.payload).toMatchObject({
+      data: {
+        item: {
+          command: "/bin/zsh -lc 'echo ping'",
+          exitCode: 0,
+        },
+      },
+    });
+    expect(JSON.stringify(projected.payload)).not.toContain("aggregatedOutput");
+  });
+
+  it("retains an ACP command exit code alongside its compact output summary", () => {
+    const projected = projectActivityPayload(
+      commandActivity({
+        kind: "execute",
+        command: "bun run check",
+        rawOutput: {
+          exitCode: 17,
+          stdout: "check failed\nmore detail",
+          stderr: "",
+        },
+      }),
+    );
+
+    expect(projected.payload).toMatchObject({
+      data: {
+        kind: "execute",
+        command: "bun run check",
+        rawOutput: {
+          exitCode: 17,
+          content: "check failed",
+        },
+      },
+    });
+  });
+
+  it("retains an exit code when ACP command output is empty", () => {
+    const projected = projectActivityPayload(
+      commandActivity({
+        kind: "execute",
+        rawOutput: {
+          exitCode: 0,
+          stdout: "",
+          stderr: "",
+        },
+      }),
+    );
+
+    expect(projected.payload).toMatchObject({
+      data: {
+        rawOutput: { exitCode: 0 },
+      },
+    });
+  });
+});

apps/server/src/orchestration/ActivityPayloadProjection.ts

@@ -18,6 +18,10 @@ function asTrimmedString(value: unknown): string | null {
   return trimmed.length > 0 ? trimmed : null;
 }
 
+function asInteger(value: unknown): number | null {
+  return typeof value === "number" && Number.isInteger(value) ? value : null;
+}
+
 function pushChangedFile(target: string[], seen: Set<string>, value: unknown): void {
   const normalized = asTrimmedString(value);
   if (!normalized || seen.has(normalized)) {
@@ -90,15 +94,29 @@ function projectCommandData(data: Record<string, unknown>): Record<string, unkno
   if ("command" in item) {
     projectedItem.command = item.command;
   }
+  const exitCode = asInteger(item.exitCode);
+  if (exitCode !== null) {
+    projectedItem.exitCode = exitCode;
+  }
 
   const input = asRecord(item.input);
   if (input && "command" in input) {
     projectedItem.input = { command: input.command };
   }
 
   const result = asRecord(item.result);
-  if (result && "command" in result) {
-    projectedItem.result = { command: result.command };
+  if (result) {
+    const projectedResult: Record<string, unknown> = {};
+    if ("command" in result) {
+      projectedResult.command = result.command;
+    }
+    const resultExitCode = asInteger(result.exitCode);
+    if (resultExitCode !== null) {
+      projectedResult.exitCode = resultExitCode;
+    }
+    if (Object.keys(projectedResult).length > 0) {
+      projectedItem.result = projectedResult;
+    }
   }
 
   return Object.keys(projectedItem).length > 0 ? projectedItem : undefined;
@@ -237,26 +255,38 @@ function projectRawOutput(value: unknown): Record<string, unknown> | undefined {
     return undefined;
   }
 
+  const projected: Record<string, unknown> = {};
+  const exitCode = asInteger(rawOutput.exitCode);
+  if (exitCode !== null) {
+    projected.exitCode = exitCode;
+  }
+
   if (typeof rawOutput.totalFiles === "number" && Number.isFinite(rawOutput.totalFiles)) {
-    return {
-      totalFiles: rawOutput.totalFiles,
-      ...(rawOutput.truncated === true ? { truncated: true } : {}),
-    };
+    projected.totalFiles = rawOutput.totalFiles;
+    if (rawOutput.truncated === true) {
+      projected.truncated = true;
+    }
+    return projected;
   }
 
   const content = asTrimmedString(rawOutput.content);
   if (content) {
     const summary = summarizeToolTextOutput(content);
-    return summary ? { content: summary } : undefined;
+    if (summary) {
+      projected.content = summary;
+    }
+    return Object.keys(projected).length > 0 ? projected : undefined;
   }
 
   const stdout = asTrimmedString(rawOutput.stdout);
   if (stdout) {
     const summary = summarizeToolTextOutput(stdout);
-    return summary ? { content: summary } : undefined;
+    if (summary) {
+      projected.content = summary;
+    }
   }
 
-  return undefined;
+  return Object.keys(projected).length > 0 ? projected : undefined;
 }
 
 /**
@@ -290,6 +320,14 @@ export function projectActivityPayload(
   if ("command" in data) {
     projectedData.command = data.command;
   }
+  const exitCode = asInteger(data.exitCode);
+  if (exitCode !== null) {
+    projectedData.exitCode = exitCode;
+  }
+  const resultExitCode = asInteger(asRecord(data.result)?.exitCode);
+  if (resultExitCode !== null) {
+    projectedData.result = { exitCode: resultExitCode };
+  }
 
   const changedFiles: string[] = [];
   collectChangedFiles(data, changedFiles, new Set<string>(), 0);

apps/web/src/components/chat/MessagesTimeline.test.tsx

@@ -671,15 +671,47 @@ describe("MessagesTimeline", () => {
               createdAt: "2026-03-17T19:12:28.000Z",
               label: "Glob",
               tone: "tool",
+              itemType: "command_execution",
               toolLifecycleStatus: "failed",
               detail: "No files found",
+              exitCode: 17,
             },
           },
         ]}
       />,
     );
 
     expect(markup).toContain("lucide-x");
-    expect(markup).toContain('aria-label="Tool call failed"');
+    expect(markup).toContain('aria-label="Exit code 17"');
+    expect(markup).toContain("Exit code 17");
+  });
+
+  it("renders a zero exit code for successful commands", () => {
+    const markup = renderToStaticMarkup(
+      <MessagesTimeline
+        {...buildProps()}
+        timelineEntries={[
+          {
+            id: "entry-1",
+            kind: "work",
+            createdAt: "2026-03-17T19:12:28.000Z",
+            entry: {
+              id: "work-1",
+              createdAt: "2026-03-17T19:12:28.000Z",
+              label: "Ran command",
+              tone: "tool",
+              itemType: "command_execution",
+              toolLifecycleStatus: "completed",
+              command: "bun run test",
+              exitCode: 0,
+            },
+          },
+        ]}
+      />,
+    );
+
+    expect(markup).toContain("lucide-check");
+    expect(markup).toContain('aria-label="Exit code 0"');
+    expect(markup).toContain("Exit code 0");
   });
 });

apps/web/src/components/chat/MessagesTimeline.tsx

@@ -2239,6 +2239,8 @@ const PlainWorkEntryRow = memo(function PlainWorkEntryRow(props: {
   const expandedBody = buildToolCallExpandedBody(workEntry, workspaceRoot);
   const canExpand = expandedBody !== null;
   const showFailedIndicator = workEntryIndicatesToolFailure(workEntry);
+  const exitCodeLabel =
+    workEntry.exitCode === undefined ? null : `Exit code ${workEntry.exitCode.toString()}`;
   const showDestructiveRowStyle =
     showFailedIndicator &&
     (workEntry.sourceActivityKind === "runtime.error" || !workLogEntryIsToolLike(workEntry));
@@ -2324,18 +2326,23 @@ const PlainWorkEntryRow = memo(function PlainWorkEntryRow(props: {
                     render={
                       <span
                         className="flex size-4 items-center justify-center"
-                        aria-label="Tool call failed"
+                        aria-label={exitCodeLabel ?? "Tool call failed"}
                       />
                     }
                   >
                     <XIcon className="block size-3 shrink-0 text-destructive" aria-hidden />
                   </TooltipTrigger>
-                  <TooltipPopup>Failed</TooltipPopup>
+                  <TooltipPopup>{exitCodeLabel ?? "Failed"}</TooltipPopup>
                 </Tooltip>
               ) : showSuccessIndicator ? (
                 <Tooltip>
                   <TooltipTrigger
-                    render={<span className="flex size-4 items-center justify-center" />}
+                    render={
+                      <span
+                        className="flex size-4 items-center justify-center"
+                        aria-label={exitCodeLabel ?? "Tool call completed"}
+                      />
+                    }
                   >
                     <span className="inline-flex size-4 items-center justify-center">
                       <CheckIcon
@@ -2345,7 +2352,7 @@ const PlainWorkEntryRow = memo(function PlainWorkEntryRow(props: {
                       />
                     </span>
                   </TooltipTrigger>
-                  <TooltipPopup>Completed</TooltipPopup>
+                  <TooltipPopup>{exitCodeLabel ?? "Completed"}</TooltipPopup>
                 </Tooltip>
               ) : showNeutralIndicator ? (
                 <Tooltip>

apps/web/src/connection/storage.ts

@@ -42,6 +42,7 @@ const SERVER_CONFIG_STORE_NAME = "server-config";
 const VCS_REFS_STORE_NAME = "vcs-refs";
 const CATALOG_KEY = "document";
 const SHELL_SNAPSHOT_CACHE_SCHEMA_VERSION = 1;
+const THREAD_SNAPSHOT_CACHE_SCHEMA_VERSION = 4;
 
 const StoredShellSnapshot = Schema.Struct({
   schemaVersion: Schema.Literal(SHELL_SNAPSHOT_CACHE_SCHEMA_VERSION),
@@ -54,9 +55,11 @@ const StoredShellSnapshotJson = Schema.fromJsonString(StoredShellSnapshot);
 // v3 adds windowed (paginated) snapshots carrying `page` metadata. The bump
 // exists for rollback safety: a pre-pagination client would decode a windowed
 // v2 record, silently drop the unknown `page` field, and treat the partial
-// thread as complete forever. Older entries fail to decode → cold cache.
+// thread as complete forever. v4 refreshes cached activity payloads after
+// command exit codes were added to the compact server projection. Older entries
+// fail to decode and are treated as a cold cache.
 const StoredThreadSnapshot = Schema.Struct({
-  schemaVersion: Schema.Literal(3),
+  schemaVersion: Schema.Literal(THREAD_SNAPSHOT_CACHE_SCHEMA_VERSION),
   environmentId: EnvironmentId,
   threadId: ThreadId,
   snapshot: OrchestrationThreadDetailSnapshot,
@@ -564,7 +567,7 @@ export const connectionStorageLayer = Layer.effectContext(
       saveThread: (environmentId, snapshot) =>
         Effect.gen(function* () {
           const encoded = yield* encodeStoredThreadSnapshot({
-            schemaVersion: 3,
+            schemaVersion: THREAD_SNAPSHOT_CACHE_SCHEMA_VERSION,
             environmentId,
             threadId: snapshot.thread.id,
             snapshot,

apps/web/src/session-logic.test.ts

@@ -631,6 +631,18 @@ describe("workEntryIndicatesToolFailure", () => {
     ).toBe(true);
   });
 
+  it("is true when a command has a nonzero exit code", () => {
+    expect(
+      workEntryIndicatesToolFailure({
+        ...base,
+        tone: "tool",
+        itemType: "command_execution",
+        toolLifecycleStatus: "completed",
+        exitCode: 17,
+      }),
+    ).toBe(true);
+  });
+
   it("detects file-not-found style tool output with completed lifecycle", () => {
     expect(
       workEntryIndicatesToolFailure({
@@ -1131,9 +1143,9 @@ describe("deriveWorkLogEntries", () => {
           data: {
             item: {
               command: ["bun", "run", "dev"],
+              exitCode: 0,
               result: {
                 content: '{ "dev": "vite dev --port 3000" } <exited with exit code 0>',
-                exitCode: 0,
               },
             },
           },
@@ -1145,11 +1157,43 @@ describe("deriveWorkLogEntries", () => {
     expect(entry).toMatchObject({
       command: "bun run dev",
       detail: '{ "dev": "vite dev --port 3000" }',
+      exitCode: 0,
       itemType: "command_execution",
       toolTitle: "bash",
     });
   });
 
+  it("extracts command exit codes from ACP raw output", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "command-tool-failed",
+        kind: "tool.completed",
+        summary: "Ran command",
+        payload: {
+          itemType: "command_execution",
+          status: "completed",
+          data: {
+            kind: "execute",
+            command: "bun run check",
+            rawOutput: {
+              exitCode: 17,
+              stdout: "",
+              stderr: "check failed",
+            },
+          },
+        },
+      }),
+    ];
+
+    const [entry] = deriveWorkLogEntries(activities);
+    expect(entry).toMatchObject({
+      command: "bun run check",
+      exitCode: 17,
+      itemType: "command_execution",
+    });
+    expect(entry && workEntryIndicatesToolFailure(entry)).toBe(true);
+  });
+
   it("extracts changed file paths for file-change tool activities", () => {
     const activities: OrchestrationThreadActivity[] = [
       makeActivity({