test(tui): complete input-required persistence, negative, teardown, and session coverage

Adds live theme switching, transcript/scroll/typing/forced-repaint and overlay-open persistence, settle-one-of-two and both-strip ordering, MCP/permission/ask_director/OAuth negatives, a product-host teardown drain test, and the primary-session integration regression proving the marker, unique id, and admission-to-removal compose.

Author: bwachman

src/tui/operator-input-required-chrome.test.ts

@@ -1,16 +1,24 @@
 import { afterEach, describe, expect, test } from "bun:test";
+import { EventEmitter } from "node:events";
 import { rgbToHex, type CapturedSpan, type RGBA } from "@opentui/core";
 
+import type { PendingAskWake } from "../subagent/fleet-report.js";
 import {
   PRIMARY_ASK_OPERATOR_SOURCE,
   type OperatorGateEvent,
 } from "./gate-events.js";
+import { wireGates } from "./gate-wire.js";
 import { withTestRenderer, type Harness } from "./harness.js";
 import { BORDER } from "./prompt-border.js";
+import { repaintShellForTheme } from "./runner/settings.js";
 import {
+  appendStreamRow,
   clearOperatorInputRequired,
+  paintChrome,
   relayout,
   setOperatorInputRequiredGate,
+  setStatusFlash,
+  setWorkerWaitAsks,
 } from "./shell/chrome.js";
 import { createAppShell } from "./shell/index.js";
 import type { AppShell } from "./shell/internals.js";
@@ -28,6 +36,29 @@ function gate(id: string, question: string): OperatorGateEvent {
   };
 }
 
+const WAITING_WORKER: PendingAskWake = {
+  sessionId: "sess-builder",
+  agentId: "builder",
+  description: "copy assets",
+  question: "Which destination path should I use?",
+  questionId: "q1",
+};
+
+/**
+ * Wire an emitter to the shell the way mountProductHost does, so gate events
+ * reach the strip through the real admission/settlement hooks.
+ */
+function wirePrimaryHost(shell: AppShell, emitter: EventEmitter): () => void {
+  return wireGates(emitter, shell, {
+    onGateOpened: () => undefined,
+    onGateClosed: () => undefined,
+    onPrimaryOperatorAdmitted: (event) =>
+      setOperatorInputRequiredGate(shell, event),
+    onPrimaryOperatorSettled: (event) =>
+      clearOperatorInputRequired(shell, event.id),
+  });
+}
+
 async function withShell(
   fn: (shell: AppShell, h: Harness) => Promise<void>,
   size = { columns: 120, rows: 30 },
@@ -148,4 +179,164 @@ describe("operator input required strip", () => {
       });
     });
   }
+
+  test("a live theme switch repaints the strip in the new palette", async () => {
+    setTheme("corbits-dark");
+    await withShell(async (shell, h) => {
+      setOperatorInputRequiredGate(
+        shell,
+        gate("one", "Which branch should I use?"),
+      );
+      await frameRows(h);
+      setTheme("corbits-light");
+      repaintShellForTheme(shell);
+      await frameRows(h);
+      const label = spanWith(h, "INPUT REQUIRED");
+      expect(label === undefined ? null : hex(label.fg)).toBe(
+        UI.action.toLowerCase(),
+      );
+    });
+  });
+
+  test("the strip persists through transcript growth, scrolling, typing, flashes and redraws", async () => {
+    await withShell(async (shell, h) => {
+      setOperatorInputRequiredGate(
+        shell,
+        gate("one", "Which branch should I use?"),
+      );
+      const before = await frameRows(h);
+      const painted = before[inputRow(before)];
+      for (let i = 0; i < 60; i++) {
+        appendStreamRow(shell, { role: "assistant", text: `row ${i}` });
+      }
+      shell.transcript.scrollTo(0);
+      shell.prompt.value = "hold on, let me check the path";
+      setStatusFlash(shell, "copied");
+      paintChrome(shell);
+      paintChrome(shell, { force: true });
+      relayout(shell);
+      const after = await frameRows(h);
+      expect(after[inputRow(after)]).toBe(painted);
+      expect(shell.layout.heights.input_required).toBe(1);
+    });
+  });
+
+  test("the strip stays visible while an operator modal is open", async () => {
+    await withShell(async (shell, h) => {
+      const emitter = new EventEmitter();
+      const disposeGates = wirePrimaryHost(shell, emitter);
+      try {
+        emitter.emit("operator.gate", {
+          id: "one",
+          source: PRIMARY_ASK_OPERATOR_SOURCE,
+          question: "Which branch should I use?",
+          options: ["main", "dev"],
+          resolve: () => undefined,
+        });
+        expect(shell.overlayKind).toBe("operator");
+        const rows = await frameRows(h);
+        expect(shell.layout.heights.input_required).toBe(1);
+        expect(rows.some((row) => row.includes("INPUT REQUIRED"))).toBe(true);
+      } finally {
+        disposeGates();
+      }
+    });
+  });
+
+  test("settling one of two leaves the other strip in place", async () => {
+    await withShell(async (shell, h) => {
+      setOperatorInputRequiredGate(
+        shell,
+        gate("one", "Which branch should I use?"),
+      );
+      setOperatorInputRequiredGate(
+        shell,
+        gate("two", "Should I include tests?"),
+      );
+      await frameRows(h);
+      clearOperatorInputRequired(shell, "one");
+      const rows = await frameRows(h);
+      expect(rows.some((row) => row.includes("INPUT REQUIRED"))).toBe(true);
+      expect(rows.some((row) => row.includes("Should I include tests?"))).toBe(
+        true,
+      );
+      expect(shell.layout.heights.input_required).toBe(1);
+      clearOperatorInputRequired(shell, "two");
+      const restored = await frameRows(h);
+      expect(shell.layout.heights.input_required).toBe(0);
+      expect(restored.some((row) => row.includes("INPUT REQUIRED"))).toBe(
+        false,
+      );
+    });
+  });
+
+  test("WORKER WAITING and INPUT REQUIRED sit together with correct order", async () => {
+    await withShell(async (shell, h) => {
+      setWorkerWaitAsks(shell, [WAITING_WORKER]);
+      setOperatorInputRequiredGate(
+        shell,
+        gate("one", "Which branch should I use?"),
+      );
+      const rows = await frameRows(h);
+      const worker = rows.findIndex((row) => row.includes("WORKER WAITING"));
+      const input = rows.findIndex((row) => row.includes("INPUT REQUIRED"));
+      expect(worker).toBeGreaterThanOrEqual(0);
+      expect(input).toBeGreaterThan(worker);
+      expect(rows.filter((row) => row.includes("WORKER WAITING"))).toHaveLength(
+        1,
+      );
+      expect(rows.filter((row) => row.includes("INPUT REQUIRED"))).toHaveLength(
+        1,
+      );
+      const w = shell.layout.regions.worker_wait;
+      const i = shell.layout.regions.input_required;
+      const p = shell.layout.regions.prompt;
+      expect(w !== undefined && i !== undefined && p !== undefined).toBe(true);
+      if (w === undefined || i === undefined || p === undefined) return;
+      expect(w.y).toBeLessThan(i.y);
+      expect(i.y + i.height).toBe(p.y);
+    });
+  });
+
+  test("MCP-trust and permission gates never raise an INPUT REQUIRED row", async () => {
+    await withShell(async (shell, h) => {
+      const emitter = new EventEmitter();
+      const disposeGates = wirePrimaryHost(shell, emitter);
+      try {
+        emitter.emit("permission.gate", {
+          id: "perm-1",
+          request: {
+            tool: "run_shell",
+            action: "Run shell command",
+            subject: "bun test",
+            scopes: [],
+          },
+          resolve: () => undefined,
+        });
+        emitter.emit("operator.gate", {
+          id: "mcp-trust",
+          question: "Trust this local MCP server?",
+          options: ["Trust and connect", "Cancel"],
+          resolve: () => undefined,
+        });
+        const rows = await frameRows(h);
+        expect(shell.overlayKind).toBe("permissions");
+        expect(shell.layout.heights.input_required).toBe(0);
+        expect(rows.some((row) => row.includes("INPUT REQUIRED"))).toBe(false);
+      } finally {
+        disposeGates();
+      }
+    });
+  });
+
+  test("worker ask_director waiting and OAuth-style notices never raise an INPUT REQUIRED row", async () => {
+    await withShell(async (shell, h) => {
+      setWorkerWaitAsks(shell, [WAITING_WORKER]);
+      setStatusFlash(shell, "OAuth token refresh needed");
+      const rows = await frameRows(h);
+      expect(rows.some((row) => row.includes("WORKER WAITING"))).toBe(true);
+      expect(shell.layout.heights.input_required).toBe(0);
+      expect(rows.some((row) => row.includes("INPUT REQUIRED"))).toBe(false);
+    });
+  });
 });

src/tui/operator-input-required.test.ts

@@ -69,6 +69,25 @@ describe("operator input required view model", () => {
     ).toBe(NO_OPERATOR_INPUT_REQUIRED);
   });
 
+  test("fails closed for an unrecognized marker string and an MCP-trust-shaped event", () => {
+    const wrongMarker = {
+      ...gate("one"),
+      source: "mcp-trust",
+    } as unknown as OperatorGateEvent;
+    expect(
+      addOperatorInputRequired(NO_OPERATOR_INPUT_REQUIRED, wrongMarker),
+    ).toBe(NO_OPERATOR_INPUT_REQUIRED);
+    const mcpTrust = {
+      id: "mcp-trust",
+      question: "Trust this local MCP server?",
+      options: ["Trust and connect", "Cancel"],
+      resolve: () => undefined,
+    } as unknown as OperatorGateEvent;
+    expect(addOperatorInputRequired(NO_OPERATOR_INPUT_REQUIRED, mcpTrust)).toBe(
+      NO_OPERATOR_INPUT_REQUIRED,
+    );
+  });
+
   test("keeps insertion selection and removes exactly the settled id", () => {
     const first = addOperatorInputRequired(
       NO_OPERATOR_INPUT_REQUIRED,

src/tui/product-host.test.ts

@@ -14,6 +14,8 @@ import {
   runOverlayAction,
 } from "./shell/overlay-list.js";
 import { handleListFilterKey } from "./shell/palette.js";
+import { PRIMARY_ASK_OPERATOR_SOURCE } from "./gate-events.js";
+import { NO_OPERATOR_INPUT_REQUIRED } from "./operator-input-required.js";
 import {
   decideRemoveKey,
   mountProductHost,
@@ -608,6 +610,39 @@ describe("mountProductHost", () => {
       destroyHarness();
     }
   });
+
+  test("host teardown drains a marked outstanding operator gate and clears its strip", async () => {
+    const { host, emitter, destroyHarness } = await mountHeadless();
+    try {
+      let resolved: unknown = "unset";
+      emitter.emit("operator.gate", {
+        id: "ask-teardown",
+        source: PRIMARY_ASK_OPERATOR_SOURCE,
+        question: "Continue?",
+        options: ["Yes", "No"],
+        resolve: (result: unknown) => {
+          resolved = result;
+        },
+      });
+      expect(
+        host.shell.operatorInputRequired.items.map((item) => item.id),
+      ).toEqual(["ask-teardown"]);
+      expect(host.shell.layout.heights.input_required).toBe(1);
+      expect(emitter.listenerCount("operator.gate")).toBe(1);
+      expect(emitter.listenerCount("permission.gate")).toBe(1);
+
+      host.dispose();
+
+      // The gate is drained by the teardown sweep, never left hanging.
+      expect(resolved).toEqual({ kind: "cancel" });
+      expect(host.shell.operatorInputRequired).toBe(NO_OPERATOR_INPUT_REQUIRED);
+      expect(host.shell.layout.heights.input_required).toBe(0);
+      expect(emitter.listenerCount("operator.gate")).toBe(0);
+      expect(emitter.listenerCount("permission.gate")).toBe(0);
+    } finally {
+      destroyHarness();
+    }
+  });
 });
 
 describe("flat type-to-filter model picker", () => {