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

Author: TheGreatAxios

src/agent/compaction.test.ts

@@ -21,6 +21,7 @@ import {
   LEGACY_COMPACT_SPACER_TEXT,
   compactorNoOpFloor,
 } from "../session/compactor.js";
+import { buildSummaryPrompt } from "../session/summarizer.js";
 
 const capabilities = {
   infer: (options?: unknown) => ({
@@ -903,6 +904,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);
@@ -911,6 +926,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

@@ -78,6 +78,10 @@ export function createCompactionGovernor(
   // instructions still fold with the default structured summary; a 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
@@ -386,6 +390,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;
@@ -398,13 +404,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 {

tests/unit/summarizer.test.ts

@@ -85,6 +85,14 @@ test("buildSummaryPrompt omits workflow preamble when none active", () => {
   expect(prompt).toContain("Session excerpt");
 });
 
+test("buildSummaryPrompt injects extra operator compact instructions", () => {
+  const prompt = buildSummaryPrompt(turns(), {
+    extraInstructions: "now do the UI audit",
+  });
+  expect(prompt).toContain("Operator compact instructions");
+  expect(prompt).toContain("now do the UI audit");
+});
+
 test("model summarizer returns the model output", async () => {
   const summarize = createModelSummarizer({
     getSource: () => source,