fix(compaction): restore idle arming and prior fold guidance on cancel

Author: TheGreatAxios

src/agent/compaction.test.ts

@@ -23,6 +23,7 @@ import {
   LEGACY_COMPACT_SPACER_TEXT,
   compactorNoOpFloor,
 } from "../session/compactor.js";
+import { buildSummaryPrompt } from "../session/summarizer.js";
 
 const capabilities = {
   infer: (options?: unknown) => ({
@@ -1433,6 +1434,20 @@ describe("handoff arming (/handoff)", () => {
     ).toBeNull();
   });
 
+  test("cancelManual restores extraInstructions from a prior successful 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,
+    );
+    expect(governor.extraInstructions).toBe("keep the UI audit");
+    expect(governor.requestHandoff("failed pivot: drop this")).toBe("armed");
+    governor.cancelManual();
+    expect(governor.extraInstructions).toBe("keep the UI audit");
+  });
+
   test("cancelManual clears sticky extraInstructions from a failed pivot", () => {
     const governor = createCompactionGovernor(undefined);
     governor.syncFromTurns(tenTurns);
@@ -1441,6 +1456,55 @@ describe("handoff arming (/handoff)", () => {
     expect(governor.extraInstructions).toBeUndefined();
   });
 
+  test("failed-pivot instructions are not in a later threshold summary prompt", () => {
+    const governor = createCompactionGovernor(undefined);
+    governor.syncFromTurns(tenTurns);
+    expect(governor.requestHandoff("now do the UI audit")).toBe("armed");
+    governor.cancelManual();
+    governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
+    expect(
+      governor.interceptActions(toolDone(), inferAction, capabilities),
+    ).not.toBeNull();
+    const prompt = buildSummaryPrompt(
+      tenTurns,
+      governor.extraInstructions !== undefined
+        ? { extraInstructions: governor.extraInstructions }
+        : undefined,
+    );
+    expect(prompt).not.toContain("now do the UI audit");
+    expect(prompt).not.toContain("Operator compact instructions");
+  });
+
+  test("cancelManual does not invent pending", () => {
+    const governor = createCompactionGovernor(undefined);
+    governor.syncFromTurns(tenTurns);
+    expect(governor.requestHandoff("now do the UI audit")).toBe("armed");
+    governor.cancelManual();
+    expect(
+      governor.interceptActions(toolDone(), inferAction, capabilities),
+    ).toBeNull();
+  });
+
+  test("cancelManual restores idlePending so an idle threshold fold still fires", () => {
+    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();
+    const actions = governor.interceptIdleContinuation(
+      emptyMessage(),
+      capabilities,
+    );
+    expect(actions).not.toBeNull();
+    expect(actions?.find((a) => a.type === "compact")).toMatchObject({
+      reason: "context-threshold",
+    });
+  });
+
   test("threshold pending survives cancelManual so a tool pause still folds", () => {
     const governor = createCompactionGovernor(undefined);
     governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);

src/agent/compaction.ts

@@ -124,6 +124,10 @@ export function createCompactionGovernor(
   // non-empty argument is kept for later auto-folds and written into the
   // compact record.
   let extraInstructions: string | undefined;
+  // Snapshots taken at requestHandoff so cancelManual can restore the
+  // pre-pivot idle arming and a prior successful fold's guidance.
+  let idlePendingAtHandoff = false;
+  let extraInstructionsAtHandoff: string | undefined;
   let postCompactInfer = false;
   // Idle empty compact needs a post-compact decide cycle to adopt the shrunk
   // turns for the meter, but must not start a new inference (there is no
@@ -565,6 +569,8 @@ 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;
     const trimmed = instructions.trim();
     if (trimmed.length > 0) extraInstructions = trimmed;
     manualPending = true;
@@ -577,13 +583,16 @@ 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. Sticky
-  // extraInstructions belong to a successful fold, not a cancelled one.
+  // 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 {
     const thresholdPending = pending;
     clearManualArming();
     pending = thresholdPending;
-    extraInstructions = undefined;
+    idlePending = idlePendingAtHandoff;
+    extraInstructions = extraInstructionsAtHandoff;
   }
 
   return {