fix(server): commands a lost Codex app-server never finished no longer show as running

When the app-server dies or stops answering, the adapter now fails every
command, dynamic tool, and MCP app capture it still tracks — for active turns
and for settled turns with background work — before failing the event stream.
Previously the run failed but its command item and node stayed running, so the
composer kept a Running chip with a Stop button for work that no longer existed.

The terminalization is the same triplet the interrupt path already runs, so both
now go through one `terminalizeTrackedTurnWork` helper instead of repeating the
three calls (and the opaque persistent-tools flag) at each site.

The test that used a Codex exit to leave a stale command for Stop now asserts
that the exit itself fails the command.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: spencermorris04

apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts

@@ -2013,6 +2013,23 @@ NodeReadline.createInterface({ input: process.stdin }).on("line", (line) => {
       };
       write({ id, result: { turn } });
       write({ method: "turn/started", params: { threadId: params.threadId, turn } });
+      write({
+        method: "item/started",
+        params: {
+          threadId: params.threadId,
+          turnId: turn.id,
+          startedAtMs: Date.now(),
+          item: {
+            type: "commandExecution",
+            id: \`command-\${turn.id}\`,
+            command: "sleep 600",
+            cwd: process.cwd(),
+            status: "inProgress",
+            commandActions: [],
+            aggregatedOutput: null,
+          },
+        },
+      });
       break;
     }
     case "thread/loaded/list":
@@ -2166,6 +2183,13 @@ NodeReadline.createInterface({ input: process.stdin }).on("line", (line) => {
             const projection = yield* orchestrator.getThreadProjection(threadId);
             assert.equal(projection.runs.at(-1)?.status, "failed");
             assert.equal(projection.providerSessions.at(-1)?.status, "error");
+            // Nothing will complete the command the process took with it.
+            const command = projection.turnItems.find((item) => item.type === "command_execution");
+            assert.equal(command?.status, "failed");
+            assert.equal(
+              projection.nodes.find((node) => node.id === command?.nodeId)?.status,
+              "failed",
+            );
           }
 
           yield* createAndStart(ThreadId.make("thread:codex-recovery-new"));
@@ -5204,7 +5228,7 @@ describe("CodexAdapterV2 post-settle continuation", () => {
     );
   });
 
-  it.effect("Stop ends a background command no Codex process tracks any more", () =>
+  it.effect("fails a background command its exited Codex process never finished", () =>
     Effect.scoped(
       Effect.gen(function* () {
         const fs = yield* FileSystem.FileSystem;
@@ -5266,6 +5290,16 @@ describe("CodexAdapterV2 post-settle continuation", () => {
             Stream.runHead,
             Effect.forkChild({ startImmediately: true }),
           );
+          const commandFailed = yield* orchestrator.streamDomainEvents.pipe(
+            Stream.filter(
+              (event) =>
+                event.type === "turn-item.updated" &&
+                event.payload.type === "command_execution" &&
+                event.payload.status === "failed",
+            ),
+            Stream.runHead,
+            Effect.forkChild({ startImmediately: true }),
+          );
           yield* orchestrator.dispatch({
             type: "message.dispatch",
             commandId: CommandId.make("start-background-stop-untracked"),
@@ -5279,28 +5313,14 @@ describe("CodexAdapterV2 post-settle continuation", () => {
           });
           yield* worker.drain();
           yield* Fiber.join(settled);
-          yield* worker.drain();
-          const before = yield* orchestrator.getThreadShell(threadId);
-          assert.deepEqual(
-            before?.pendingBackgroundTasks?.map((task) => task.kind),
-            ["command"],
-            "the thread still shows the command the gone process never finished",
-          );
-          const run = (yield* orchestrator.getThreadProjection(threadId)).runs.at(-1)!;
-          yield* orchestrator.dispatch({
-            type: "run.interrupt",
-            commandId: CommandId.make("stop-background-untracked"),
-            threadId,
-            runId: run.id,
-            holdQueue: true,
-          });
+          yield* Fiber.join(commandFailed);
           yield* worker.drain();
           const projection = yield* orchestrator.getThreadProjection(threadId);
           assert.deepEqual(
             projection.turnItems.flatMap((item) =>
               item.type === "command_execution" ? [item.status] : [],
             ),
-            ["interrupted"],
+            ["failed"],
           );
           assert.equal(projection.runs.at(-1)?.status, "completed");
           assert.deepEqual(

apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts

@@ -3844,6 +3844,32 @@ export const makeCodexAdapterV2 = Effect.fn("makeCodexAdapterV2")(function* (
             }
           });
 
+        // Terminalizes everything a turn still tracks — running command items,
+        // dynamic tools (persistent ones included, since the turn itself is
+        // ending), and pending MCP app captures — to one terminal status.
+        // Shared by the interrupt path and the lost-app-server path.
+        const terminalizeTrackedTurnWork = (
+          context: ActiveCodexTurnContext,
+          status: "interrupted" | "failed",
+          completedAt: DateTime.Utc,
+        ) =>
+          Effect.gen(function* () {
+            yield* terminalizeRunningCommandItems(
+              context,
+              context.nativeTurnId,
+              status,
+              completedAt,
+            );
+            yield* terminalizeRunningDynamicTools(
+              context,
+              context.nativeTurnId,
+              status,
+              completedAt,
+              true,
+            );
+            yield* terminalizeMcpAppCaptures(context, context.nativeTurnId);
+          });
+
         const buildProposedPlanArtifacts = (input: {
           readonly context: ActiveCodexTurnContext;
           readonly nativeItemId: string;
@@ -6429,11 +6455,25 @@ export const makeCodexAdapterV2 = Effect.fn("makeCodexAdapterV2")(function* (
             }
           }
         });
+        // No item/completed will arrive for work the process took with it,
+        // including background commands of turns that already completed.
+        const failLostTurnWork = turnTerminalizationPermit.withPermits(1)(
+          Effect.gen(function* () {
+            const completedAt = yield* DateTime.now;
+            for (const context of [
+              ...(yield* Ref.get(activeTurns)).values(),
+              ...(yield* Ref.get(settledTurns)).values(),
+            ]) {
+              yield* terminalizeTrackedTurnWork(context, "failed", completedAt);
+            }
+          }),
+        );
         yield* Effect.raceFirst(
           client.terminated,
           // A probe that fails with a transport error is the termination above.
           unresponsive.pipe(Effect.catch(() => Effect.never)),
         ).pipe(
+          Effect.tap(() => failLostTurnWork),
           Effect.flatMap((cause) =>
             Queue.fail(
               events,
@@ -7078,20 +7118,7 @@ export const makeCodexAdapterV2 = Effect.fn("makeCodexAdapterV2")(function* (
                       const context = target.context;
                       if ((yield* Ref.get(settledTurns)).get(context.nativeTurnId) !== context)
                         continue;
-                      yield* terminalizeRunningCommandItems(
-                        context,
-                        context.nativeTurnId,
-                        "interrupted",
-                        completedAt,
-                      );
-                      yield* terminalizeRunningDynamicTools(
-                        context,
-                        context.nativeTurnId,
-                        "interrupted",
-                        completedAt,
-                        true,
-                      );
-                      yield* terminalizeMcpAppCaptures(context, context.nativeTurnId);
+                      yield* terminalizeTrackedTurnWork(context, "interrupted", completedAt);
                       yield* Ref.update(runningCommandItemsByTurn, (current) => {
                         const updated = new Map(current);
                         updated.delete(context.nativeTurnId);