Abort TUI quit before awaiting the session-op tail

Stop workers first so a hung session-op cannot delay abort and reap. Log shutdown failures at error while still mapping teardown failure to exit 1.

Author: TheGreatAxios

src/tui/runner/exit.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, spyOn, test } from "bun:test";
+import { getLogger } from "@intx/log";
+
+import { LOG_NAMESPACE_ROOT } from "../../branding.js";
+import { finalizeTUIRun } from "./exit.js";
+import type { RunnerServices, RunnerState } from "./state.js";
+
+function stubQuit(args: { awaitTail: () => Promise<void>; shutdownRuntime: () => Promise<void> }): {
+  state: RunnerState;
+  services: RunnerServices;
+} {
+  const state = {
+    host: {
+      waitUntilExit: async () => undefined,
+    },
+    shutdownRuntime: args.shutdownRuntime,
+    runError: undefined,
+    streamPromise: Promise.resolve(),
+    config: { cwd: "/tmp", task: "t" },
+    sessionId: "s",
+    startedAt: 1,
+    runTaskTitle: "t",
+    connectedMcpServers: [],
+    liveSource: { id: "p", model: "m" },
+  } as unknown as RunnerState;
+  const services = {
+    sessionOps: {
+      enqueue: async () => undefined,
+      awaitTail: args.awaitTail,
+    },
+    cycleRecorder: { dispose: async () => "" },
+    mcpConnectController: new AbortController(),
+    runSink: {
+      getTurnCollector: () => null,
+      getRunError: () => undefined,
+      getStatus: () => "done",
+      getTurnCount: () => 0,
+      getTokenUsage: () => ({
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        thinking: 0,
+      }),
+      getToolCallCount: () => 0,
+    },
+    crashGuard: { markFinalized: () => undefined, isFinalized: () => false },
+    activeRunHandle: { task: "", startedAt: 0, model: "" },
+    hookManager: { dispatchPostRun: async () => undefined },
+    liveSessionMode: "orchestrator",
+  } as unknown as RunnerServices;
+  return { state, services };
+}
+
+describe("finalizeTUIRun quit order", () => {
+  test("starts runtime shutdown without waiting on a hung session-op tail", async () => {
+    const order: string[] = [];
+    let settleTail!: (err: Error) => void;
+    const hungTail = new Promise<void>((_, reject) => {
+      settleTail = reject;
+    });
+    const { state, services } = stubQuit({
+      awaitTail: async () => {
+        order.push("tail");
+        await hungTail;
+      },
+      shutdownRuntime: async () => {
+        order.push("shutdown");
+      },
+    });
+
+    const pending = finalizeTUIRun(state, services);
+    try {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(order[0]).toBe("shutdown");
+    } finally {
+      settleTail(new Error("stop"));
+    }
+    await expect(pending).rejects.toThrow("stop");
+  });
+
+  test("logs a runtime shutdown failure instead of swallowing it", async () => {
+    const logger = getLogger([LOG_NAMESPACE_ROOT, "tui"]);
+    const errorSpy = spyOn(logger, "error");
+    let settleTail!: (err: Error) => void;
+    const hungTail = new Promise<void>((_, reject) => {
+      settleTail = reject;
+    });
+    const { state, services } = stubQuit({
+      awaitTail: () => hungTail,
+      shutdownRuntime: async () => {
+        throw new Error("plugin dispose failed");
+      },
+    });
+
+    const pending = finalizeTUIRun(state, services);
+    try {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(errorSpy).toHaveBeenCalled();
+      const logged = errorSpy.mock.calls as unknown as readonly (readonly unknown[])[];
+      const first = logged[0];
+      expect(first).toBeDefined();
+      expect(String(first?.[0])).toMatch(/shutdown/i);
+      expect(first?.[1]).toEqual({ error: "plugin dispose failed" });
+    } finally {
+      errorSpy.mockRestore();
+      settleTail(new Error("stop"));
+    }
+    await expect(pending).rejects.toThrow("stop");
+  });
+});

src/tui/runner/exit.ts

@@ -525,17 +525,21 @@ export async function finalizeTUIRun(
   services: RunnerServices,
 ): Promise<number> {
   await hostOf(state).waitUntilExit();
-  await services.sessionOps.awaitTail();
-  // Stop inference and every worker before persistence, hooks, or telemetry can
-  // delay process exit. Closing the terminal is a process-lifetime boundary.
+  // Stop workers before awaiting the session-op tail so a hung enqueue cannot
+  // delay abort/reap. Persistence, hooks, and telemetry stay after stop.
   // Toolset dispose lives inside shutdownRuntime so quit, crash, and signals
   // share one owner.
   let teardownFailed = false;
   try {
     await state.shutdownRuntime?.();
-  } catch {
+  } catch (err) {
     teardownFailed = true;
+    tuiLogger.error("runtime shutdown failed: {error}", {
+      error: err instanceof Error ? err.message : String(err),
+    });
   }
+  await services.sessionOps.awaitTail();
+
   state.stopFleetReporting?.();
   // Quitting mid-stream is an abnormal end for the in-flight cycle: nothing
   // downstream delivers its terminal event once the app is gone.