test(tui): cover session overlay abort wiring

Removing registerOverlayAbort from session assembly must fail tests.
The parked overlay binding is the session wiring, not a local duplicate
of it in the resume unit test.

Author: TheGreatAxios

src/tui/runner/parked-overlay-abort.ts

@@ -0,0 +1,28 @@
+/**
+ * TUI session overlay abort slot. Approval resume registers the parked
+ * overlay controller here; the permission gate's identity signal merges it
+ * so a reactor approval timeout dismisses the overlay instead of leaving it
+ * parked after the call is gone.
+ */
+
+interface ParkedOverlayAbortBinding {
+  registerOverlayAbort: (controller: AbortController | undefined) => void;
+  identitySignal: (identity: AbortSignal) => AbortSignal;
+}
+
+export function createParkedOverlayAbortBinding(): ParkedOverlayAbortBinding {
+  const parkedOverlayAbort = {
+    controller: undefined as AbortController | undefined,
+  };
+  return {
+    registerOverlayAbort: (controller) => {
+      parkedOverlayAbort.controller = controller;
+    },
+    identitySignal: (identity) => {
+      const parked = parkedOverlayAbort.controller?.signal;
+      return parked === undefined
+        ? identity
+        : AbortSignal.any([identity, parked]);
+    },
+  };
+}

src/tui/runner/session.overlay-abort.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test";
+import type { PermissionRequest } from "../../permission/types.js";
+import type { PermissionGateEvent } from "../gate-events.js";
+import { createGateRequestApproval } from "../request-approval.js";
+import { createParkedOverlayAbortBinding } from "./parked-overlay-abort.js";
+import { assembleTUISession } from "./session.js";
+
+const request: PermissionRequest = {
+  tool: "run_shell",
+  action: "Run shell command",
+  subject: "true",
+  scopes: [],
+};
+
+function noTimeout(): undefined {
+  return undefined;
+}
+
+describe("parked overlay abort binding", () => {
+  test("aborting the registered controller aborts the merged identity signal", () => {
+    const binding = createParkedOverlayAbortBinding();
+    const identity = new AbortController();
+    const overlay = new AbortController();
+    binding.registerOverlayAbort(overlay);
+    const merged = binding.identitySignal(identity.signal);
+    expect(merged.aborted).toBe(false);
+    overlay.abort("approval timed out");
+    expect(merged.aborted).toBe(true);
+    expect(merged.reason).toBe("approval timed out");
+    expect(identity.signal.aborted).toBe(false);
+  });
+
+  test("without a registered controller the identity signal is unchanged", () => {
+    const binding = createParkedOverlayAbortBinding();
+    const identity = new AbortController();
+    expect(binding.identitySignal(identity.signal)).toBe(identity.signal);
+  });
+
+  test("clearing the registration drops the overlay from later identity signals", () => {
+    const binding = createParkedOverlayAbortBinding();
+    const identity = new AbortController();
+    const overlay = new AbortController();
+    binding.registerOverlayAbort(overlay);
+    binding.registerOverlayAbort(undefined);
+    const merged = binding.identitySignal(identity.signal);
+    overlay.abort("approval timed out");
+    expect(merged.aborted).toBe(false);
+  });
+});
+
+describe("assembleTUISession overlay abort wiring", () => {
+  test("registers the parked overlay abort on approval resume and merges it into the gate identity signal", () => {
+    const src = assembleTUISession.toString();
+    expect(src).toContain("createParkedOverlayAbortBinding");
+    expect(src).toContain("registerOverlayAbort");
+    expect(src).toContain("parkedOverlay.identitySignal");
+    expect(src).toContain("parkedOverlay.registerOverlayAbort");
+  });
+
+  test("a registered overlay abort dismisses the gate event the session identity signal feeds", async () => {
+    const binding = createParkedOverlayAbortBinding();
+    const identity = new AbortController();
+    let captured: PermissionGateEvent | undefined;
+    const requestApproval = createGateRequestApproval({
+      emitGate: (event) => {
+        captured = event;
+        return true;
+      },
+      approvalTimeout: noTimeout,
+      identitySignal: () => binding.identitySignal(identity.signal),
+    });
+    const overlay = new AbortController();
+    binding.registerOverlayAbort(overlay);
+    const pending = requestApproval(request);
+    expect(captured?.signal?.aborted).toBe(false);
+    overlay.abort("approval timed out");
+    expect(captured?.signal?.aborted).toBe(true);
+    expect(captured?.signal?.reason).toBe("approval timed out");
+    captured?.resolve({ allow: false, message: "approval timed out" });
+    expect((await pending).allow).toBe(false);
+  });
+});

src/tui/runner/session.ts

@@ -119,6 +119,7 @@ import {
   type RunnerState,
   type TUIStart,
 } from "./state.js";
+import { createParkedOverlayAbortBinding } from "./parked-overlay-abort.js";
 
 export async function assembleTUISession(
   state: RunnerState,
@@ -171,9 +172,7 @@ export async function assembleTUISession(
 
   const correlationAcceptance = createCorrelationAcceptance();
   const parkedApprovalCancel = { fn: undefined as (() => void) | undefined };
-  const parkedOverlayAbort = {
-    controller: undefined as AbortController | undefined,
-  };
+  const parkedOverlay = createParkedOverlayAbortBinding();
   const deliveryGeneration = createDeliveryGeneration(() => {
     parkedApprovalCancel.fn?.();
     correlationAcceptance.settleAll();
@@ -188,13 +187,8 @@ export async function assembleTUISession(
     requestApproval: createGateRequestApproval({
       emitGate: (event) => emitter.emit("permission.gate", event),
       approvalTimeout,
-      identitySignal: () => {
-        const identity = deliveryGeneration.signal();
-        const parked = parkedOverlayAbort.controller?.signal;
-        return parked === undefined
-          ? identity
-          : AbortSignal.any([identity, parked]);
-      },
+      identitySignal: () =>
+        parkedOverlay.identitySignal(deliveryGeneration.signal()),
     }),
     getActiveProviderModel: () =>
       `${state.config.providerName}:${state.config.model}`,
@@ -535,9 +529,7 @@ export async function assembleTUISession(
     registerParkedCancel: (cancel) => {
       parkedApprovalCancel.fn = cancel;
     },
-    registerOverlayAbort: (controller) => {
-      parkedOverlayAbort.controller = controller;
-    },
+    registerOverlayAbort: parkedOverlay.registerOverlayAbort,
     deliver: (message, stillCurrent) => {
       return sessionOps.enqueue(async () => {
         if (!stillCurrent()) return;

tests/unit/approval-resume.test.ts

@@ -27,6 +27,7 @@ import {
 import { createGateRequestApproval } from "../../src/tui/request-approval.js";
 import { startInterruptRebuild } from "../../src/tui/runner/exit.js";
 import { runWhileAgentBusy } from "../../src/tui/runner/state.js";
+import { createParkedOverlayAbortBinding } from "../../src/tui/runner/parked-overlay-abort.js";
 
 const SUSPENDED: SendResult = {
   type: "suspended",
@@ -756,9 +757,7 @@ describe("approval resume occupancy until correlation", () => {
 
 describe("approval resume overlay on reactor timeout", () => {
   test("auto-abandons the overlay and unsticks occupancy when the parked call times out", async () => {
-    const parkedOverlayAbort = {
-      controller: undefined as AbortController | undefined,
-    };
+    const parkedOverlay = createParkedOverlayAbortBinding();
     const generation = createDeliveryGeneration();
     const turns = [userTurn()];
     let overlay: PermissionGateEvent | undefined;
@@ -786,12 +785,7 @@ describe("approval resume overlay on reactor timeout", () => {
         return true;
       },
       approvalTimeout: () => undefined,
-      identitySignal: () => {
-        const identity = generation.signal();
-        const parked = parkedOverlayAbort.controller?.signal;
-        if (parked === undefined) return identity;
-        return AbortSignal.any([identity, parked]);
-      },
+      identitySignal: () => parkedOverlay.identitySignal(generation.signal()),
     });
     const gate = createPermissionGate({
       approvals: [],
@@ -808,9 +802,7 @@ describe("approval resume overlay on reactor timeout", () => {
         history: async () => turns,
       }),
       captureGeneration: generation.capture,
-      registerOverlayAbort: (controller) => {
-        parkedOverlayAbort.controller = controller;
-      },
+      registerOverlayAbort: parkedOverlay.registerOverlayAbort,
       parkedTimeoutPollMs: 5,
       gate,
     });