fix(compaction): restore extraInstructions after director rebuild

The compact record stored operator instructions but a new governor
on /model, interrupt, or resume never read them, so later auto-folds
used the default structured prompt.

Author: TheGreatAxios

docs/ARCHITECTURE.md

@@ -204,7 +204,7 @@ When a cycle's input tokens cross a threshold, the director compacts the inferen
 
 The `ollama` table key is the bare provider segment; the harness stamps slash-form on `sourceId` (`ollama/default` / `ollama/<instance>`), with `provider: openai-compatible` (`buildOpenAISource`) and a bare model (`llama3` / `qwen3`). Idle-recompress disable matches via `isOllamaProviderId` on that `sourceId` (`src/provider/ollama.ts`), not by looking up slash-form as a table key.
 
-- **Operator `/compact`** — A first-class slash command folds now without waiting for the occupancy governor. Optional trailing instructions go to the summarizer (empty uses the default structured fold) and are stored on the compact record so later auto-folds still see them. An in-flight turn uses the same pair-safe compact-then-continue hop as threshold compact; an idle compact shows the fold and does not start a new turn.
+- **Operator `/compact`** — A first-class slash command folds now without waiting for the occupancy governor. Optional trailing instructions go to the summarizer (empty uses the default structured fold) and are stored on the compact record so later auto-folds still see them. Director rebuild (`/model`, interrupt, resume) restores those instructions from the latest compact record's parameters. An in-flight turn uses the same pair-safe compact-then-continue hop as threshold compact; an idle compact shows the fold and does not start a new turn.
 - **Overflow recovery** — A `context_overflow` inference error would otherwise become a terminal error reply; the governor compacts and retries instead, bounded so a history the compactor cannot shrink does not loop forever. Overflow ignores hysteresis for the compact itself.
 
 The TTL window is measured from the last `inference.done` (every inference rewrites the provider's prefix cache) with one fire per window per compact of any kind, and it never fires with a tool batch outstanding — stall pings can arrive mid-work. The consecutive-compact cap shared with the threshold path still bounds compact→infer→compact. Prompt-caching the summary call itself is an explicit non-goal: the fold carries no cache options.

src/agent/compaction.test.ts

@@ -9,7 +9,9 @@ import type {
 import {
   COMPACTION_CONTINUATION_EVENT,
   OPERATOR_COMPACT_REASON,
+  compactFloorNoopNotice,
   createCompactionGovernor,
+  stickyExtraInstructionsFromRecords,
 } from "./compaction.js";
 import {
   compactionResumeDeltaFor,
@@ -854,6 +856,82 @@ describe("compaction governor", () => {
     expect(governor.compactTurnCount).toBe(10);
     expect(governor.extraInstructions).toBe("keep the auth discussion");
   });
+
+  test("restoreExtraInstructions hydrates a new governor from a compact record", () => {
+    const written = {
+      strategy: "pruning-compactor",
+      version: "1",
+      parameters: { extraInstructions: "keep the auth discussion" },
+      reason: "compacted",
+      decisions: {},
+    };
+    expect(stickyExtraInstructionsFromRecords([written])).toBe(
+      "keep the auth discussion",
+    );
+
+    const rebuilt = createCompactionGovernor(undefined);
+    expect(rebuilt.extraInstructions).toBeUndefined();
+    rebuilt.restoreExtraInstructions(
+      stickyExtraInstructionsFromRecords([written]),
+    );
+    expect(rebuilt.extraInstructions).toBe("keep the auth discussion");
+    rebuilt.restoreExtraInstructions(undefined);
+    expect(rebuilt.extraInstructions).toBe("keep the auth discussion");
+  });
+
+  test("sticky extra instructions skip empty values and later non-pruning records", () => {
+    expect(
+      stickyExtraInstructionsFromRecords([
+        {
+          strategy: "other",
+          parameters: { extraInstructions: "ignore me" },
+        },
+        {
+          strategy: "pruning-compactor",
+          parameters: { extraInstructions: "  keep tests  " },
+        },
+        {
+          strategy: "pruning-compactor",
+          parameters: { extraInstructions: "older" },
+        },
+      ]),
+    ).toBe("keep tests");
+    expect(
+      stickyExtraInstructionsFromRecords([
+        {
+          strategy: "pruning-compactor",
+          parameters: { extraInstructions: "" },
+        },
+        {
+          strategy: "pruning-compactor",
+          parameters: { extraInstructions: 12 },
+        },
+      ]),
+    ).toBeUndefined();
+  });
+
+  test("second /compact during the apply-to-meter window does not double-fold", () => {
+    const governor = createCompactionGovernor(undefined);
+    governor.noteInferenceDone(inferenceDone(1000), tenTurns);
+    expect(governor.requestManual("keep the auth discussion")).toBe("kick");
+    expect(
+      governor.interceptIdleContinuation(emptyMessage(), capabilities),
+    ).not.toBeNull();
+
+    expect(governor.requestManual("also keep the billing notes")).toBe("armed");
+    expect(governor.extraInstructions).toBe("also keep the billing notes");
+    expect(
+      governor.interceptIdleContinuation(emptyMessage(), capabilities),
+    ).toBeNull();
+    expect(governor.resumeAfterCompact(emptyMessage())).toBe("meter");
+  });
+
+  test("noop /compact below the floor tells the operator instructions were not saved", () => {
+    expect(compactFloorNoopNotice("")).toBe("Nothing to compact yet.");
+    expect(compactFloorNoopNotice("keep the auth discussion")).toBe(
+      "Nothing to compact yet. Instructions were not saved.",
+    );
+  });
 });
 
 describe("provider-aware idle recompress (CL-8745)", () => {

src/agent/compaction.ts

@@ -68,6 +68,38 @@ export type ManualCompactOptions = {
   turns?: readonly ConversationTurn[];
 };
 
+type CompactRecordLike = {
+  strategy?: string;
+  parameters?: Record<string, unknown>;
+};
+
+function extraInstructionsFromCompactRecord(
+  record: CompactRecordLike,
+): string | undefined {
+  if (record.strategy !== COMPACTOR_NAME) return undefined;
+  const extra = record.parameters?.extraInstructions;
+  if (typeof extra !== "string") return undefined;
+  const trimmed = extra.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+/** Newest-commit-first: first pruning-compactor extraInstructions wins. */
+export function stickyExtraInstructionsFromRecords(
+  records: readonly CompactRecordLike[],
+): string | undefined {
+  for (const record of records) {
+    const extra = extraInstructionsFromCompactRecord(record);
+    if (extra !== undefined) return extra;
+  }
+  return undefined;
+}
+
+export function compactFloorNoopNotice(instructions: string): string {
+  return instructions.trim().length > 0
+    ? "Nothing to compact yet. Instructions were not saved."
+    : "Nothing to compact yet.";
+}
+
 /** Build the continuation re-entry action for a compacted governor cycle. */
 export function compactionContinuationAction(
   capabilities: ReactorCapabilities,
@@ -499,6 +531,9 @@ export function createCompactionGovernor(
     if (turnCount <= MIN_TURNS_TO_COMPACT) return "noop";
     const trimmed = instructions.trim();
     if (trimmed.length > 0) extraInstructions = trimmed;
+    // A compact is already in flight (apply-to-meter or post-compact infer).
+    // Keep sticky instructions but do not kick a second fold.
+    if (hasOutstandingContinuation()) return "armed";
     manualPending = true;
     if (options?.inFlight === true) return "armed";
     if (idlePending) return "armed";
@@ -510,6 +545,12 @@ export function createCompactionGovernor(
     return "kick";
   }
 
+  function restoreExtraInstructions(value: string | undefined): void {
+    const trimmed = value?.trim();
+    if (trimmed === undefined || trimmed.length === 0) return;
+    extraInstructions = trimmed;
+  }
+
   return {
     get estimatedTokens(): number {
       return estimate.tokens;
@@ -527,6 +568,7 @@ export function createCompactionGovernor(
       return turnCount;
     },
     requestManual,
+    restoreExtraInstructions,
     syncFromTurns,
     noteInferenceDone,
     notePostCompact,

src/agent/director.ts

@@ -816,6 +816,10 @@ class ChatDirectorImpl extends DefaultDirector {
     return this.compaction.extraInstructions;
   }
 
+  restoreCompactInstructions(value: string | undefined): void {
+    this.compaction.restoreExtraInstructions(value);
+  }
+
   getCompactTurnCount(): number {
     return this.compaction.compactTurnCount;
   }
@@ -1418,5 +1422,6 @@ export interface ChatDirector extends ReactorDirector {
     options?: ManualCompactOptions,
   ): ManualCompactArming;
   getCompactInstructions(): string | undefined;
+  restoreCompactInstructions(value: string | undefined): void;
   getCompactTurnCount(): number;
 }

src/context-compactor.test.ts

@@ -15,6 +15,10 @@ import {
   type SessionMetadata,
 } from "./session/compactor.js";
 import { createModelSummarizer } from "./session/summarizer.js";
+import {
+  createCompactionGovernor,
+  stickyExtraInstructionsFromRecords,
+} from "./agent/compaction.js";
 import type {
   ConversationTurn,
   InferenceSource,
@@ -786,6 +790,44 @@ describe("createPruningCompactor — operator extra instructions", () => {
       "keep the auth discussion",
     );
   });
+
+  test("a rebuilt governor still passes stored extra instructions into the next fold", async () => {
+    const turns: ConversationTurn[] = [
+      makeTurn({ role: "assistant", content: [{ type: "text", text: "a" }] }),
+      makeTurn({ role: "assistant", content: [{ type: "text", text: "b" }] }),
+      makeTurn({ role: "user", content: [{ type: "text", text: "recent" }] }),
+    ];
+    const written = await createPruningCompactor({
+      keepRecentTurns: 1,
+      summaryMaxChars: 500,
+      summaryContext: () => ({ extraInstructions: "keep the auth discussion" }),
+      summarize: async () => "summary text",
+    }).apply(turns, mockStrategyCtx);
+
+    const rebuilt = createCompactionGovernor(undefined);
+    rebuilt.restoreExtraInstructions(
+      stickyExtraInstructionsFromRecords([written.record]),
+    );
+
+    let captured: { extraInstructions?: string } | undefined;
+    const next = await createPruningCompactor({
+      keepRecentTurns: 1,
+      summaryMaxChars: 500,
+      summaryContext: () => {
+        const extra = rebuilt.extraInstructions;
+        return extra !== undefined ? { extraInstructions: extra } : undefined;
+      },
+      summarize: async (_folded, ctx) => {
+        captured = ctx;
+        return "later summary";
+      },
+    }).apply(turns, mockStrategyCtx);
+
+    expect(captured?.extraInstructions).toBe("keep the auth discussion");
+    expect(next.record.parameters.extraInstructions).toBe(
+      "keep the auth discussion",
+    );
+  });
 });
 
 describe("createPruningCompactor — consolidated handoff (CL-7521)", () => {

src/director.test.ts

@@ -6,7 +6,10 @@ import {
   CHAT_TOOLS_ACTIVATE_EVENT,
 } from "./agent/director.js";
 import type { WorkflowCoordinator } from "./workflows/coordinator.js";
-import { COMPACTION_CONTINUATION_EVENT } from "./agent/compaction.js";
+import {
+  COMPACTION_CONTINUATION_EVENT,
+  stickyExtraInstructionsFromRecords,
+} from "./agent/compaction.js";
 import { createAgentToolset } from "./agent/tools.js";
 import { createAdvertisedToolset } from "./session/assemble-runtime.js";
 import { createPermissionGate } from "./permission/gate.js";
@@ -1142,6 +1145,26 @@ describe("chatDirector compaction", () => {
     );
     expect(afterCompact.some((a) => a.type === "done")).toBe(false);
   });
+
+  test("restoreCompactInstructions hydrates a rebuilt director from a compact record", () => {
+    const written = {
+      strategy: "pruning-compactor" as const,
+      version: "1",
+      parameters: { extraInstructions: "keep the auth discussion" },
+      reason: "compacted",
+      decisions: {},
+    };
+    const first = chatDirector("");
+    first.restoreCompactInstructions(
+      stickyExtraInstructionsFromRecords([written]),
+    );
+    expect(first.getCompactInstructions()).toBe("keep the auth discussion");
+
+    const rebuilt = chatDirector("");
+    expect(rebuilt.getCompactInstructions()).toBeUndefined();
+    rebuilt.restoreCompactInstructions(first.getCompactInstructions());
+    expect(rebuilt.getCompactInstructions()).toBe("keep the auth discussion");
+  });
 });
 
 describe("chatDirector LSP auto-activation", () => {

src/session/assemble-runtime.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { Agent } from "@intx/agent";
+import type { Agent, DirectorRegistry } from "@intx/agent";
 import type {
   AuditStore,
   Compactor,
@@ -11,6 +11,7 @@ import type {
 } from "@intx/types/runtime";
 
 import { withMockedModuleDuring } from "../../tests/helpers/mock-module.js";
+import type { ChatDirector } from "../agent/director.js";
 import {
   createAdvertisedToolset,
   loadSessionLocalSettings,
@@ -392,4 +393,73 @@ describe("assembleChatAgent", () => {
     expect(builtAgent).toBe(fakeAgent);
     expect(builtStorage).toBe(fakeStorage);
   });
+
+  test("rebuild restores extraInstructions from the latest compact record", async () => {
+    let records: {
+      strategy: string;
+      version: string;
+      parameters: Record<string, unknown>;
+      reason: string;
+      decisions: Record<string, unknown>;
+    }[] = [
+      {
+        strategy: "pruning-compactor",
+        version: "1",
+        parameters: { extraInstructions: "keep the auth discussion" },
+        reason: "compacted",
+        decisions: {},
+      },
+    ];
+    const fakeStorage = {
+      readBlob: async () => new Uint8Array(),
+      readManifestHistory: async () => records,
+    } as unknown as ContextStore;
+    const fakeAgent = { close: async () => undefined } as unknown as Agent;
+    const directorHolder: { instance?: ChatDirector } = {};
+
+    await withMockedModuleDuring(
+      import.meta.resolve("./optimized-context-store.js"),
+      (real: typeof import("./optimized-context-store.js")) => ({
+        ...real,
+        createSessionStores: async () => ({
+          storage: fakeStorage,
+          audit: stubAuditStore(),
+        }),
+      }),
+      async () => {
+        await withMockedModuleDuring(
+          import.meta.resolve("../agent/live-tool-dispatch.js"),
+          (real: typeof import("../agent/live-tool-dispatch.js")) => ({
+            ...real,
+            createAgentWithLiveToolDispatch: async (
+              _def: unknown,
+              env: { directors: DirectorRegistry },
+            ) => {
+              env.directors.defaultFactory()({}, {} as never, {
+                systemPrompt: "prompt",
+                toolDefinitions: [],
+                compactorNames: ["pruning-compactor"],
+              });
+              return fakeAgent;
+            },
+          }),
+          async () => {
+            const { assembleChatAgent } = await import("./assemble-runtime.js");
+            const { buildAgent } = assembleChatAgent(
+              stubChatAgentWiring({ directorHolder }),
+            );
+            await buildAgent();
+            expect(directorHolder.instance?.getCompactInstructions()).toBe(
+              "keep the auth discussion",
+            );
+            records = [];
+            await buildAgent();
+            expect(directorHolder.instance?.getCompactInstructions()).toBe(
+              "keep the auth discussion",
+            );
+          },
+        );
+      },
+    );
+  });
 });