Distinguish a teardown deny from a grant-driven approval in the record

recordGrantDrain hardcoded "Auto-approved (already granted)" for any
request settled with no accept/cancel/autoDeny call site of its own —
but drain() (session teardown) also settles that way, denying
whatever is still queued. Every remaining request left the transcript
mislabeled as approved on exit. The row now reads the settled
outcome's allow flag to pick the right label.

Author: TheGreatAxios

src/tui-opentui/gate-wire.test.ts

@@ -711,6 +711,9 @@ describe("each gate decision appends exactly one transcript row", () => {
         expect(resolveCount).toBe(1)
         expect(resolved).toEqual({ allow: true })
         expect(shell.streamLog.length - before).toBe(1)
+        expect(shell.streamLog.at(-1)?.text).toContain(
+          "Auto-approved (already granted)",
+        )
       } finally {
         shell.dispose()
       }
@@ -744,11 +747,64 @@ describe("each gate decision appends exactly one transcript row", () => {
         expect(resolveCount).toBe(1)
         expect(shell.overlayList).toBeNull()
         expect(shell.streamLog.length - before).toBe(1)
+        expect(shell.streamLog.at(-1)?.text).toContain(
+          "Auto-approved (already granted)",
+        )
       } finally {
         shell.dispose()
       }
     })
   })
+
+  // drain() (src/permission/queue.ts) denies whatever is still queued on
+  // teardown — the same no-call-site path as a grant drain, but the
+  // opposite outcome. Mislabeling this "Auto-approved" would tell the
+  // operator a request ran when it was actually dropped unanswered.
+  test("disposing with a request still queued records it as denied, not approved", async () => {
+    await withTestRenderer(async (h) => {
+      const shell = createAppShell(h.renderer, {
+        terminal: { columns: 80, rows: 24 },
+        run: "idle",
+      })
+      const emitter = new EventEmitter()
+      // The currently-open request has no accept/cancel/autoDeny call site
+      // triggered before teardown either, so dispose must record it too —
+      // both entries go through the same no-call-site fallback as the
+      // queued one.
+      let openResolveCount = 0
+      let queuedResolveCount = 0
+      let queuedResolved: unknown
+      const dispose = wireGates(emitter, shell)
+      emitter.emit("permission.gate", {
+        request: baseRequest(),
+        resolve: () => {
+          openResolveCount += 1
+        },
+      })
+      // Occupies the overlay host so this second request queues instead of
+      // opening — dispose must deny it without ever displaying it.
+      const before = shell.streamLog.length
+      emitter.emit("permission.gate", {
+        request: baseRequest({ tool: "queued_tool" }),
+        resolve: (outcome: unknown) => {
+          queuedResolveCount += 1
+          queuedResolved = outcome
+        },
+      })
+
+      dispose()
+
+      expect(openResolveCount).toBe(1)
+      expect(queuedResolveCount).toBe(1)
+      expect(queuedResolved).toEqual({ allow: false })
+      expect(shell.streamLog.length - before).toBe(2)
+      for (const row of shell.streamLog.slice(-2)) {
+        expect(row.text).toContain("Denied (session ended)")
+        expect(row.text).not.toContain("Auto-approved")
+      }
+      shell.dispose()
+    })
+  })
 })
 
 describe("permission.gate auto-deny", () => {

src/tui-opentui/gate-wire.ts

@@ -232,19 +232,28 @@ function recordDecision(
 }
 
 /**
- * Write a row for a request a newly-minted grant drained without a prompt.
- * Every other terminal path (accept, Esc, timeout, abort) writes its own row
- * at its own call site; this one covers the path that has none — reconcile()
- * settles the queue entry directly, with no accept/cancel/autoDeny callback
- * to hang a record onto. Without this, the operator's only trace of the
- * highest-consequence event in the queue (a request that ran without being
- * shown) is the transient grant-recorded flash, gone once it scrolls off.
+ * Write a row for a request settled with no accept/cancel/autoDeny call site
+ * of its own to hang a record onto: reconcile() (a newly-minted grant
+ * covering this queued request) and drain() (session teardown denying
+ * whatever is still queued) both settle the queue entry directly. Every
+ * other terminal path (accept, Esc, timeout, abort) already writes its own
+ * row at its own call site. Without this, the operator's only trace of the
+ * highest-consequence event in the queue — a request that ran, or was
+ * dropped, without ever being shown — is the transient grant-recorded flash
+ * (nothing at all for teardown), gone once it scrolls off.
  */
-function recordGrantDrain(shell: AppShell, request: PermissionRequest): void {
+function recordSilentSettle(
+  shell: AppShell,
+  request: PermissionRequest,
+  outcome: ApprovalOutcome,
+): void {
   const body = middleEllipsis(permissionBodyFromRequest(request), 500)
+  const label = outcome.allow
+    ? "Auto-approved (already granted)"
+    : "Denied (session ended)"
   appendStreamRow(shell, {
     role: "system",
-    text: `${body}\n→ Auto-approved (already granted)`,
+    text: `${body}\n→ ${label}`,
     meta: "permission",
   })
 }
@@ -388,24 +397,25 @@ export function wireGates(
       permissionQueue.settle(id, outcome)
     // Set immediately before every call to settle() from a known call site
     // (accept, Esc, autoDeny), each of which writes its own row right after.
-    // reconcile() (src/permission/queue.ts) settles an entry directly, with
-    // no call site of its own — the resolve callback below falls back to
-    // recordGrantDrain whenever this is still false, so a request that ran
-    // without ever being shown still leaves a trace.
+    // reconcile() and drain() (src/permission/queue.ts) both settle an entry
+    // directly, with no call site of their own — the resolve callback below
+    // falls back to recordSilentSettle whenever this is still false, so a
+    // request that ran, or was dropped, without ever being shown still
+    // leaves a trace.
     let recorded = false
     const id = permissionQueue.enqueue(ev.request, (outcome) => {
       clearTimers()
       // Captured before closeInsetOverlay below, which — when this entry is
       // the one on screen — reentrantly invokes this same overlay's onCancel
       // (see the comment on `settle` above) and would otherwise set
       // `recorded` out from under this check before it runs.
-      const needsGrantDrainRecord = !recorded
+      const needsSilentSettleRecord = !recorded
       if (openedGeneration === undefined) {
         unqueue(open)
       } else if (openedGeneration === overlayGeneration) {
         closeInsetOverlay(shell)
       }
-      if (needsGrantDrainRecord) recordGrantDrain(shell, ev.request)
+      if (needsSilentSettleRecord) recordSilentSettle(shell, ev.request, outcome)
       resolve(outcome)
     })