Carry an outstanding gate's count across a turn boundary

Interrupting or settling a turn does not close the permission/operator
overlay still on screen, so a gate raised in one turn can still be
sitting open when the next turn starts, or after the current one has
already settled. Resetting blockedGateCount to zero on every turn
transition lost track of that gate: its eventual close would land
against whatever turn happened to be live by then, either dropping
that turn's own exemption early or silently reviving a settled turn's
status to "running".

Turn resets now carry the prior count forward instead of dropping it,
and only mark a fresh turn "blocked" rather than "running" when a
carried-over gate is still open. A terminal reset (done, stopped,
failed) is left with its terminal status intact, since every one of
those already satisfies the watchdog's exemption on its own.

Author: TheGreatAxios

src/tui-opentui/turn-state.test.ts

@@ -206,6 +206,44 @@ describe("turn transitions", () => {
     expect(allClosed.blockedGateCount).toBe(0)
     expect(allClosed.lastActivityAt).toBe(9)
   })
+
+  test("a gate still open at interrupt keeps its count into the next turn", () => {
+    // The overlay is not closed by an interrupt — nothing else resolves it —
+    // so a turn that ends while a gate is still outstanding must not lose
+    // count of it: the eventual close belongs to this gate, not to whatever
+    // turn happens to be live when the operator finally answers.
+    const interrupted = turnStateOnInterrupt(
+      turnStateGateOpened(turnStateOnSubmit(initialTurnState(0), 1)),
+      2,
+    )
+    expect(interrupted.status).toBe("stopped")
+    expect(interrupted.blockedGateCount).toBe(1)
+
+    const nextTurn = turnStateOnSubmit(interrupted, 3)
+    expect(nextTurn.status).toBe("blocked")
+    expect(nextTurn.blockedGateCount).toBe(1)
+
+    // The stale gate from before the interrupt finally resolves — it must
+    // settle the count the new turn inherited, not resurrect a status the
+    // new turn never asked for.
+    const resolved = turnStateGateClosed(nextTurn, 9)
+    expect(resolved.status).toBe("running")
+    expect(resolved.blockedGateCount).toBe(0)
+  })
+
+  test("closing a stale gate after the turn settled does not resurrect it", () => {
+    const done = turnStateFromEvent(
+      turnStateGateOpened(turnStateOnSubmit(initialTurnState(0), 1)),
+      { type: "inference.done", data: {} },
+      2,
+    )
+    expect(done.status).toBe("done")
+    expect(done.blockedGateCount).toBe(1)
+
+    const resolved = turnStateGateClosed(done, 9)
+    expect(resolved.status).toBe("done")
+    expect(resolved.blockedGateCount).toBe(0)
+  })
 })
 
 describe("repetition tracking", () => {

src/tui-opentui/turn-state.ts

@@ -169,11 +169,31 @@ export function initialTurnState(nowMs: number): TurnState {
   }
 }
 
+/**
+ * Reset to a fresh turn state, except an outstanding gate's count carries
+ * across the boundary rather than being dropped. Interrupting or settling a
+ * turn does not close the permission/operator overlay still on screen —
+ * nothing else resolves it — so losing count of it here would let its
+ * eventual `turnStateGateClosed` decrement an unrelated later turn's count
+ * instead, either dropping that turn's own exemption early or masking a
+ * stall it never earned. The status this resets to (`"stopped"`, `"done"`,
+ * ...) is left as given: every one of those is already `!== "running"`,
+ * which is all the watchdog requires, so there is no need to relabel it
+ * `"blocked"` and risk `turnStateGateClosed` later reviving it to `"running"`.
+ */
+function carryBlockedGateCount(prior: TurnState, fresh: TurnState): TurnState {
+  return prior.blockedGateCount === 0
+    ? fresh
+    : { ...fresh, blockedGateCount: prior.blockedGateCount }
+}
+
 /** Operator submitted a prompt: the run is live and awaiting first tokens. */
 export function turnStateOnSubmit(state: TurnState, nowMs: number): TurnState {
   return {
     ...state,
-    status: "running",
+    // A gate left over from a prior turn still blocks the operator from
+    // doing anything else, so the new turn inherits the exemption too.
+    status: state.blockedGateCount > 0 ? "blocked" : "running",
     isProcessing: true,
     awaitingResponse: true,
     streamingType: null,
@@ -188,13 +208,15 @@ export function turnStateOnSubmit(state: TurnState, nowMs: number): TurnState {
     repeatingSinceTokenCount: null,
     cycleFingerprint: null,
     consecutiveMatchingCycles: 0,
-    blockedGateCount: 0,
   }
 }
 
 /** Ctrl+C / watchdog abort: nothing is in flight and no prompt may be replayed. */
-export function turnStateOnInterrupt(_state: TurnState, nowMs: number): TurnState {
-  return { ...initialTurnState(nowMs), status: "stopped" }
+export function turnStateOnInterrupt(state: TurnState, nowMs: number): TurnState {
+  return carryBlockedGateCount(state, {
+    ...initialTurnState(nowMs),
+    status: "stopped",
+  })
 }
 
 /**
@@ -529,11 +551,11 @@ export function turnStateFromEvent(
           lastActivityAt: nowMs,
         }
       }
-      return {
+      return carryBlockedGateCount(state, {
         ...initialTurnState(nowMs),
         status: "done",
         quota: state.quota,
-      }
+      })
 
     /**
      * The other turn terminator: `agent.send()` resolves on connector.reply,
@@ -545,11 +567,11 @@ export function turnStateFromEvent(
       if (state.activeToolCalls.length > 0) {
         return { ...state, awaitingResponse: false, lastActivityAt: nowMs }
       }
-      return {
+      return carryBlockedGateCount(state, {
         ...initialTurnState(nowMs),
         status: "done",
         quota: state.quota,
-      }
+      })
 
     case "inference.error": {
       const quota = quotaFromInferenceError(event.data, nowMs)
@@ -561,15 +583,24 @@ export function turnStateFromEvent(
     }
 
     case "reactor.done":
-      return { ...initialTurnState(nowMs), quota: state.quota }
+      return carryBlockedGateCount(state, {
+        ...initialTurnState(nowMs),
+        quota: state.quota,
+      })
 
     case "reactor.error":
-      return { ...initialTurnState(nowMs), status: "failed" }
+      return carryBlockedGateCount(state, {
+        ...initialTurnState(nowMs),
+        status: "failed",
+      })
 
     case "run":
       return event.state === "busy"
         ? turnStateOnSubmit(state, nowMs)
-        : { ...initialTurnState(nowMs), quota: state.quota }
+        : carryBlockedGateCount(state, {
+            ...initialTurnState(nowMs),
+            quota: state.quota,
+          })
 
     default:
       return state