fix(compaction): no-op cancelManual once the handoff fold is spent

Restoring snapshots after the fold (or after a noop arm) wiped sticky
extras and re-armed a second idle compact.

Author: TheGreatAxios

src/agent/compaction.test.ts

@@ -1527,4 +1527,104 @@ describe("handoff arming (/handoff)", () => {
       reason: "context-threshold",
     });
   });
+
+  test("cancelManual after an idle fold keeps extras and does not re-arm", () => {
+    const governor = createCompactionGovernor(undefined);
+    governor.syncFromTurns(tenTurns);
+    expect(governor.requestHandoff("keep the UI audit")).toBe("armed");
+    expect(
+      governor.interceptIdleContinuation(
+        pivot("keep the UI audit"),
+        capabilities,
+      ),
+    ).not.toBeNull();
+    governor.cancelManual();
+    expect(governor.extraInstructions).toBe("keep the UI audit");
+    expect(
+      governor.interceptIdleContinuation(emptyMessage(), capabilities),
+    ).toBeNull();
+  });
+
+  test("cancelManual after a tool-pause fold keeps extras and does not re-arm", () => {
+    const governor = createCompactionGovernor(undefined);
+    governor.syncFromTurns(tenTurns);
+    expect(governor.requestHandoff("keep the UI audit")).toBe("armed");
+    expect(
+      governor.interceptActions(toolDone(), inferAction, capabilities),
+    ).not.toBeNull();
+    governor.cancelManual();
+    expect(governor.extraInstructions).toBe("keep the UI audit");
+    expect(
+      governor.interceptIdleContinuation(emptyMessage(), capabilities),
+    ).toBeNull();
+  });
+
+  test("cancelManual after a fired idle fold does not restore a second idle compact", () => {
+    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");
+    expect(
+      governor.interceptIdleContinuation(
+        pivot("now do the UI audit"),
+        capabilities,
+      ),
+    ).not.toBeNull();
+    governor.cancelManual();
+    expect(
+      governor.interceptIdleContinuation(emptyMessage(), capabilities),
+    ).toBeNull();
+  });
+
+  test("noop then cancelManual does not wipe extras from a prior fold", () => {
+    const governor = createCompactionGovernor(undefined);
+    governor.syncFromTurns(tenTurns);
+    expect(governor.requestHandoff("keep the UI audit")).toBe("armed");
+    governor.interceptIdleContinuation(
+      pivot("keep the UI audit"),
+      capabilities,
+    );
+    governor.syncFromTurns(threeTurns);
+    expect(governor.requestHandoff("wipe this")).toBe("noop");
+    governor.cancelManual();
+    expect(governor.extraInstructions).toBe("keep the UI audit");
+  });
+
+  test("double requestHandoff then cancel restores committed extras, not the first uncommitted", () => {
+    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("first uncommitted")).toBe("armed");
+    expect(governor.requestHandoff("second uncommitted")).toBe("armed");
+    governor.cancelManual();
+    expect(governor.extraInstructions).toBe("keep the UI audit");
+  });
+
+  test("empty trailing after a successful fold uses the default structured summary", () => {
+    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();
+    const prompt = buildSummaryPrompt(
+      tenTurns,
+      governor.extraInstructions !== undefined
+        ? { extraInstructions: governor.extraInstructions }
+        : undefined,
+    );
+    expect(prompt).not.toContain("keep the UI audit");
+    expect(prompt).not.toContain("Operator compact instructions");
+  });
 });

src/agent/compaction.ts

@@ -569,10 +569,15 @@ export function createCompactionGovernor(
   // the single operator fold, because firing clears the arming.
   function requestHandoff(instructions: string): HandoffArming {
     if (turnCount <= MIN_TURNS_TO_COMPACT) return "noop";
-    idlePendingAtHandoff = idlePending;
-    extraInstructionsAtHandoff = extraInstructions;
+    // Snapshot only the committed pre-pivot state. A second request while still
+    // armed replaces the pending extras; cancel must not restore the first
+    // uncommitted pivot.
+    if (!manualPending) {
+      idlePendingAtHandoff = idlePending;
+      extraInstructionsAtHandoff = extraInstructions;
+    }
     const trimmed = instructions.trim();
-    if (trimmed.length > 0) extraInstructions = trimmed;
+    extraInstructions = trimmed.length > 0 ? trimmed : undefined;
     manualPending = true;
     idlePending = true;
     if (requestContinuation !== undefined) {
@@ -582,12 +587,14 @@ export function createCompactionGovernor(
   }
 
   // Disarm after a pivot send that never delivered: without this the next
-  // operator message would fold unexpectedly. Threshold `pending` is independent
-  // of the failed pivot and must still fire at the next tool pause. Restore
-  // idlePending and extraInstructions from the requestHandoff snapshots so a
-  // cancelled pivot neither invents an idle fold nor wipes a prior successful
-  // fold's guidance.
+  // operator message would fold unexpectedly. Already-fired or never-armed
+  // cancels are no-ops so they cannot restore snapshots over sticky extras or
+  // re-arm a spent idle fold. Threshold `pending` is independent of the failed
+  // pivot and must still fire at the next tool pause. Restore idlePending and
+  // extraInstructions from the requestHandoff snapshots so a cancelled pivot
+  // neither invents an idle fold nor wipes a prior successful fold's guidance.
   function cancelManual(): void {
+    if (!manualPending) return;
     const thresholdPending = pending;
     clearManualArming();
     pending = thresholdPending;

src/tui/runner/commands.ts

@@ -284,14 +284,18 @@ export function createCommandLayer(
       // starts the next assistant turn — even a "noop" fold still pivots to
       // the operator's new goal without needing `/clear`.
       const pivot = trimmed.length > 0 ? trimmed : HANDOFF_DEFAULT_PIVOT;
+      const disarmOnMiss = arming === "armed";
       void send(userInboundMessage(pivot, [])).then(
         (result) => {
           // A pivot that never delivered must not leave a stale arming behind
-          // to fold the next innocent operator message.
-          if (result.status !== "accepted") director.cancelManualCompact();
+          // to fold the next innocent operator message. Noop never armed, so
+          // cancel would restore snapshots from a prior fold and wipe extras.
+          if (disarmOnMiss && result.status !== "accepted") {
+            director.cancelManualCompact();
+          }
         },
         () => {
-          director.cancelManualCompact();
+          if (disarmOnMiss) director.cancelManualCompact();
         },
       );
       return undefined;

src/tui/runner/handoff.test.ts

@@ -111,6 +111,7 @@ describe("runner /handoff wiring", () => {
     await flushSends();
     expect(h.sent).toHaveLength(1);
     expect(h.sent[0]?.content).toBe("ship the dashboard");
+    expect(h.cancelled).toBe(0);
   });
 
   test("noop fold without instructions reports instead of sending a blank pivot", async () => {
@@ -136,6 +137,29 @@ describe("runner /handoff wiring", () => {
     expect(h.cancelled).toBe(1);
   });
 
+  test("an undelivered noop pivot does not cancelManualCompact", async () => {
+    const h = setUpHandoffHarness();
+    h.setArming("noop");
+    h.setSendResult({
+      status: "not-delivered",
+      reason: "agent-closed",
+      detail: "closed",
+    });
+    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");
+    h.setSendThrows("boom");
+    expect(h.requestHandoff("ship the dashboard")).toBeUndefined();
+    await flushSends();
+    expect(h.cancelled).toBe(0);
+  });
+
   test("a rejected pivot send disarms as well", async () => {
     const h = setUpHandoffHarness();
     h.setSendThrows("boom");