fix(compaction): spend operator arming on overflow recovery

Overflow compact left /handoff armed, so the pivot folded a
second time. Keepers pin empty-trailing cancel, noop-after-idle
cancel, and TUI uncertain noop.

Author: TheGreatAxios

src/agent/compaction.test.ts

@@ -1627,4 +1627,57 @@ describe("handoff arming (/handoff)", () => {
     expect(prompt).not.toContain("keep the UI audit");
     expect(prompt).not.toContain("Operator compact instructions");
   });
+
+  test("empty trailing then cancel restores committed extras", () => {
+    const governor = createCompactionGovernor(undefined);
+    governor.syncFromTurns(tenTurns);
+    expect(governor.requestHandoff("keep the UI audit")).toBe("armed");
+    governor.interceptIdleContinuation(
+      pivot("keep the UI audit"),
+      capabilities,
+    );
+    expect(governor.requestHandoff("   ")).toBe("armed");
+    expect(governor.extraInstructions).toBeUndefined();
+    governor.cancelManual();
+    expect(governor.extraInstructions).toBe("keep the UI audit");
+  });
+
+  test("noop then cancel after a restored idle fold has already fired does not re-arm idle", () => {
+    const governor = createCompactionGovernor(undefined);
+    governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
+    expect(
+      governor.noteIdleTurn(inferenceDone(overThreshold), [
+        { type: "reply", content: "done" },
+      ]),
+    ).toBe(true);
+    expect(governor.requestHandoff("now do the UI audit")).toBe("armed");
+    governor.cancelManual();
+    expect(
+      governor.interceptIdleContinuation(emptyMessage(), capabilities),
+    ).not.toBeNull();
+    governor.syncFromTurns(threeTurns);
+    expect(governor.requestHandoff("wipe this")).toBe("noop");
+    governor.cancelManual();
+    expect(
+      governor.interceptIdleContinuation(emptyMessage(), capabilities),
+    ).toBeNull();
+  });
+
+  test("overflow then handoff does not double-fold", () => {
+    const governor = createCompactionGovernor(undefined);
+    governor.syncFromTurns(tenTurns);
+    expect(governor.requestHandoff("now do the UI audit")).toBe("armed");
+    const overflow = governor.interceptOverflow(overflowError(), capabilities);
+    expect(overflow).not.toBeNull();
+    expect(overflow?.find((a) => a.type === "compact")).toMatchObject({
+      reason: "context-overflow",
+    });
+    expect(
+      governor.interceptIdleContinuation(
+        pivot("now do the UI audit"),
+        capabilities,
+      ),
+    ).toBeNull();
+    expect(governor.extraInstructions).toBe("now do the UI audit");
+  });
 });

src/agent/compaction.ts

@@ -480,7 +480,9 @@ export function createCompactionGovernor(
     }
     if (overflowRecoveries >= MAX_OVERFLOW_RECOVERIES) return null;
     overflowRecoveries++;
-    pending = false;
+    // Overflow compact spends any operator arming so a queued handoff
+    // pivot cannot fold again after this recovery. Sticky extras stay.
+    clearManualArming();
     postCompactInfer = true;
     noteCompactIssued();
     return [

src/tui/runner/handoff.test.ts

@@ -151,6 +151,19 @@ describe("runner /handoff wiring", () => {
     expect(h.cancelled).toBe(0);
   });
 
+  test("an uncertain noop pivot does not cancelManualCompact", async () => {
+    const h = setUpHandoffHarness();
+    h.setArming("noop");
+    h.setSendResult({
+      status: "uncertain",
+      detail: "network reset",
+    });
+    expect(h.requestHandoff("ship the dashboard")).toBeUndefined();
+    await flushSends();
+    expect(h.sent).toHaveLength(1);
+    expect(h.cancelled).toBe(0);
+  });
+
   test("a rejected noop pivot send does not cancelManualCompact", async () => {
     const h = setUpHandoffHarness();
     h.setArming("noop");