Identify compaction spacers by harness producer identity

Missing model is not a producer id (replay sanitizer fills it), and a format-category sentinel can be dropped by adapters. Stamp reserved model harness, keep a visible sentinel, and keep exhausted spacer echoes on workflow and open-task rails.

Author: TheGreatAxios

CHANGELOG.md

@@ -30,9 +30,10 @@ parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
   impersonating Reject; Escape still denies.
 - After context compaction, ChatGPT Codex requests keep the operating prompt as
   instructions.
-- Compaction spacers are a non-lexical harness sentinel rather than
-  model-echoable prose. Spacer-only replies are treated as incomplete.
-  Frozen-prefix matching ignores model-emitted copies of the marker.
+- Compaction spacers stamp a reserved harness producer id and a visible
+  sentinel. Spacer-only replies are incomplete and stay on open-task and
+  workflow rails. Frozen-prefix matching ignores model-emitted copies of the
+  marker.
 
 ## [0.3.18] - 2026-09-08
 

docs/ARCHITECTURE.md

@@ -162,7 +162,7 @@ The agent maintains an optional **`manage_tasks`** list (create/update via the h
 
 #### Context compaction (the compaction governor)
 
-When a cycle's input tokens cross a threshold, the director compacts the inference-facing history (the full run is always retained in the context store). The threshold is **model-aware** — roughly 60% of the active model's real context window — so small-window models compact early enough to avoid provider context-overflow while large-window models do not compact prematurely. The compacted prefix is **append-only across passes**: the existing compacted user turn stays byte-identical; new folds become later summary turns with a harness-inserted, non-lexical assistant spacer (identified by a missing `model` field plus the sentinel, including a legacy `[compaction]` token) between them so the prompt head can remain in the provider KV cache. Model-emitted copies of the spacer are not frozen. The governor covers three cases:
+When a cycle's input tokens cross a threshold, the director compacts the inference-facing history (the full run is always retained in the context store). The threshold is **model-aware** — roughly 60% of the active model's real context window — so small-window models compact early enough to avoid provider context-overflow while large-window models do not compact prematurely. The compacted prefix is **append-only across passes**: the existing compacted user turn stays byte-identical; new folds become later summary turns with a harness-inserted assistant spacer (identified by reserved `model: "harness"`, plus a visible sentinel; persisted `[compaction]` tokens without a producer still freeze) between them so the prompt head can remain in the provider KV cache. Model-emitted copies of the spacer are not frozen. Spacer-only model replies are incomplete: ChatDirector nudges, then falls through loop-protection, workflow-idle, and open-task rails rather than empty-settling with work still open. The governor covers three cases:
 
 - **Threshold at a tool pause** — Once over threshold, the follow-up `infer` after a tool batch is swapped for a `compact` cycle, and inference resumes via a host continuation message. After a compact that remains over the high watermark, the governor uses **growth hysteresis** (wait for usage to grow by ~10% of the window) instead of re-arming on every cycle; dropping under 60% is not required.
 - **Idle (end-of-turn)** — An interactive turn can end with a reply and then sit idle with no tool batch to intercept; the governor requests a continuation at that pause and compacts when it arrives. An operator message that races the continuation still compacts first, then re-enters inference to answer it.

src/agent/compaction.test.ts

@@ -57,6 +57,20 @@ function inferenceDone(
   } as unknown as Extract<ReactorInboundEvent, { type: "inference.done" }>;
 }
 
+function inferenceDoneWithTools(
+  input: number,
+): Extract<ReactorInboundEvent, { type: "inference.done" }> {
+  return {
+    type: "inference.done",
+    turn: {
+      role: "assistant",
+      content: [{ type: "tool_call", id: "c1", name: "read_file", arguments: { path: "a.ts" } }],
+    },
+    usage: usage(input),
+    source: { sourceId: "s", provider: "p", model: "m" },
+  } as unknown as Extract<ReactorInboundEvent, { type: "inference.done" }>;
+}
+
 function inferenceDoneWithoutUsage(): Extract<ReactorInboundEvent, { type: "inference.done" }> {
   return {
     type: "inference.done",
@@ -455,7 +469,7 @@ describe("compaction governor", () => {
     expect(actions?.some((a) => a.type === "compact")).toBe(true);
   });
 
-  test("consecutive threshold and idle compacts are bounded without a non-echo turn", () => {
+  test("consecutive threshold and idle compacts are bounded until occupancy", () => {
     const governor = createCompactionGovernor(() => {});
     const echo = LEGACY_COMPACT_SPACER_TEXT;
     governor.noteInferenceDone(inferenceDone(overThreshold, echo), tenTurns);
@@ -477,6 +491,9 @@ describe("compaction governor", () => {
       inferenceDone(overThreshold + 3 * resumeDelta, "real work"),
       tenTurns,
     );
+    expect(governor.interceptActions(toolDone(), inferAction, capabilities)).toBeNull();
+
+    governor.noteInferenceDone(inferenceDoneWithTools(overThreshold + 4 * resumeDelta), tenTurns);
     expect(governor.interceptActions(toolDone(), inferAction, capabilities)).not.toBeNull();
   });
 

src/agent/compaction.ts

@@ -27,6 +27,11 @@ const COMPACTOR_NAME = "pruning-compactor";
 // would spend a reactor cycle that shrinks nothing.
 const MIN_TURNS_TO_COMPACT = compactorNoOpFloor(COMPACTOR_KEEP_RECENT_TURNS);
 const MAX_OVERFLOW_RECOVERIES = 2;
+// Last-ditch bound on compact→infer→compact when the post-compact infer never
+// occupies the loop. Reset on tool-call occupancy or when a post-compact
+// measurement lands at or under the high watermark (that infer is not itself
+// a compact). Do not reset merely because assistant text ≠ spacer. Overflow
+// recoveries (above) reset on any successful inference.done instead.
 const MAX_CONSECUTIVE_THRESHOLD_COMPACTS = 2;
 
 // A compact action runs in its own reactor cycle, after which the reactor
@@ -107,6 +112,9 @@ export function createCompactionGovernor(
   }
 
   function isSpacerEchoTerminal(event: ReactorInboundEvent, actions: ReactorAction[]): boolean {
+    // Fail-closed only. ChatDirector owns spacer-echo completeness (nudge, then
+    // loop-protection / workflow / open-task rails). This just refuses to treat
+    // that incomplete wait or reply as an idle-compact pause.
     if (event.type === "inference.done" && isCompactSpacerEchoTurn(event.turn)) return true;
     return actions.some((a) => a.type === "reply" && assistantTextIsCompactSpacerEcho(a.content));
   }
@@ -116,7 +124,7 @@ export function createCompactionGovernor(
     turns: readonly ConversationTurn[],
   ): void {
     overflowRecoveries = 0;
-    if (!isCompactSpacerEchoTurn(event.turn)) {
+    if (event.turn.content.some((block) => block.type === "tool_call")) {
       consecutiveThresholdCompacts = 0;
     }
     if (requestContinuation === undefined) return;
@@ -133,6 +141,7 @@ export function createCompactionGovernor(
     }
     if (contextTokens <= compactionThresholdFor(lastModel)) {
       tokensAtLastCompact = undefined;
+      consecutiveThresholdCompacts = 0;
     }
     // Assign, don't OR: an under-threshold follow-up must disarm a sticky
     // pending left from an earlier over-threshold turn (e.g. after the

src/agent/director.ts

@@ -76,11 +76,13 @@ function inferWithNudge(
 //
 // Assumes a terminal bare wait always means the turn is over. That holds for
 // every current wait path: DefaultDirector in conversational mode (the only
-// mode ChatDirector uses) yields one only on an empty model turn, and its halt
-// path already carries a reply; the compaction, workflow, and open-task
-// rewrites either keep those terminals or replace them with an infer.
-// A future wait that pauses mid-turn while expecting more work must not be
-// settled here.
+// mode ChatDirector uses) yields one only on an empty model turn; exhausted
+// spacer-echo incompleteness uses the same wait so loop-protection, workflow,
+// and open-task rails can rewrite it to infer first. This helper only settles
+// a leftover wait into an empty reply. The halt path already carries a reply;
+// compaction, workflow, and open-task rewrites either keep those terminals or
+// replace them with an infer. A future wait that pauses mid-turn while
+// expecting more work must not be settled here.
 function ensureCycleSettlesWithReply(
   actions: ReactorAction | ReactorAction[],
   capabilities: ReactorCapabilities,
@@ -720,7 +722,12 @@ class ChatDirectorImpl extends DefaultDirector {
         if (hasToolCalls) {
           this.workflowIdleTurns = 0;
         } else {
-          this.workflowIdleTurns++;
+          // Echo-nudge cycles are incompleteness, not a contentful idle beat.
+          // Count them only after the echo budget is spent so the step-nudge
+          // rail still has its three turns before the stuck reply.
+          const spacerEchoStillNudging =
+            isCompactSpacerEchoTurn(event.turn) && this.spacerEchoNudges < MAX_SPACER_ECHO_NUDGES;
+          if (!spacerEchoStillNudging) this.workflowIdleTurns++;
         }
       }
       for (const block of event.turn.content) {
@@ -810,11 +817,15 @@ class ChatDirectorImpl extends DefaultDirector {
         this.spacerEchoNudges++;
         return inferWithNudge(capabilities, SPACER_ECHO_NUDGE);
       }
-      return capabilities.wait();
     }
 
     const base = await super.decide(event, state, capabilities);
-    const baseActions = Array.isArray(base) ? base : [base];
+    let baseActions = Array.isArray(base) ? base : [base];
+    const spacerEchoExhausted =
+      event.type === "inference.done" && isCompactSpacerEchoTurn(event.turn);
+    if (spacerEchoExhausted) {
+      baseActions = baseActions.map((a) => (a.type === "reply" ? capabilities.wait() : a));
+    }
 
     this.compaction.noteIdleTurn(event, baseActions);
     const compacted = this.compaction.interceptActions(event, baseActions, capabilities);
@@ -834,12 +845,11 @@ class ChatDirectorImpl extends DefaultDirector {
 
     const coordinator = this.workflowCoordinator;
     if (coordinator?.isActive() && !coordinator.currentStepIsGate()) {
-      const actions = Array.isArray(base) ? base : [base];
-      const hasTerminal = actions.some((a) => a.type === "wait" || a.type === "reply");
-      if (hasTerminal && this.lastInferenceTurnHadContent) {
+      const hasTerminal = baseActions.some((a) => a.type === "wait" || a.type === "reply");
+      if (hasTerminal && (this.lastInferenceTurnHadContent || spacerEchoExhausted)) {
         if (this.operatorJustResponded) {
           this.operatorJustResponded = false;
-          return base;
+          return baseActions;
         }
         if (this.workflowIdleTurns >= 3) {
           if (hasActiveTasks(this.tasks)) this.logTerminationWithOpenTasks("workflow-idle-stall");
@@ -858,7 +868,7 @@ class ChatDirectorImpl extends DefaultDirector {
           `\n\nYou have not yet completed this workflow step. ` +
           `If this step is complete, ${stepClause}. ` +
           `Otherwise continue working with tools.`;
-        const passThrough = actions.filter(
+        const passThrough = baseActions.filter(
           (a): a is Exclude<ReactorAction, { type: "wait" } | { type: "reply" }> =>
             a.type !== "wait" && a.type !== "reply",
         );
@@ -890,7 +900,7 @@ class ChatDirectorImpl extends DefaultDirector {
       }
     }
 
-    return base;
+    return baseActions;
   }
 }
 

src/context-compactor.test.ts

@@ -9,6 +9,7 @@ import {
   COMPACTED_PREFIX,
   COMPACT_SPACER_TEXT,
   LEGACY_COMPACT_SPACER_TEXT,
+  HARNESS_COMPACT_SPACER_MODEL,
   isHarnessCompactSpacer,
   type SessionMetadata,
 } from "./session/compactor.js";
@@ -629,13 +630,13 @@ describe("createPruningCompactor — prefix-stable summaries (CL-6914)", () => {
     ).toBe(true);
   });
 
-  test("harness spacer has no model and uses the non-lexical sentinel", async () => {
+  test("harness spacer is stamped with the reserved producer id and a visible sentinel", async () => {
     const compactor = createPruningCompactor({ keepRecentTurns: 2, summaryMaxChars: 500 });
     const output1 = (await compactor.apply(grow([], 16, "round1"), mockStrategyCtx)).output;
     const output2 = (await compactor.apply(grow(output1, 16, "round2"), mockStrategyCtx)).output;
     const spacer = output2.find(isHarnessCompactSpacer);
     expect(spacer).toBeDefined();
-    expect(spacer?.model).toBeUndefined();
+    expect(spacer!.model).toBe(HARNESS_COMPACT_SPACER_MODEL);
     expect(firstText(spacer!)).toBe(COMPACT_SPACER_TEXT);
     expect(firstText(spacer!)).not.toBe(LEGACY_COMPACT_SPACER_TEXT);
     expect(COMPACT_SPACER_TEXT).not.toBe(LEGACY_COMPACT_SPACER_TEXT);
@@ -665,11 +666,40 @@ describe("createPruningCompactor — prefix-stable summaries (CL-6914)", () => {
     expect(output2.slice(0, frozenLen)).not.toContain(echo);
     expect(isHarnessCompactSpacer(echo)).toBe(false);
     const harness = output2.find(isHarnessCompactSpacer);
-    if (harness !== undefined) {
-      expect(harness.model).toBeUndefined();
-      expect(firstText(harness)).toBe(COMPACT_SPACER_TEXT);
-      expect(harness).not.toBe(echo);
+    expect(harness).toBeDefined();
+    expect(harness!.model).toBe(HARNESS_COMPACT_SPACER_MODEL);
+    expect(firstText(harness!)).toBe(COMPACT_SPACER_TEXT);
+    expect(harness).not.toBe(echo);
+  });
+
+  test("frozen prefix does not absorb a model-stamped new-sentinel echo", async () => {
+    const compactor = createPruningCompactor({ keepRecentTurns: 2, summaryMaxChars: 500 });
+    const output1 = (await compactor.apply(grow([], 16, "round1"), mockStrategyCtx)).output;
+    const summary = output1.find((t) => firstText(t).startsWith(COMPACTED_PREFIX));
+    expect(summary).toBeDefined();
+    const echo = makeTurn({
+      role: "assistant",
+      model: "omen-alpha",
+      content: [{ type: "text", text: COMPACT_SPACER_TEXT }],
+    });
+    const output2 = (await compactor.apply(grow([summary!, echo], 16, "round2"), mockStrategyCtx))
+      .output;
+
+    let frozenLen = 0;
+    while (
+      frozenLen < output2.length &&
+      firstText(output2[frozenLen]!).startsWith(COMPACTED_PREFIX)
+    ) {
+      frozenLen++;
+      if (frozenLen < output2.length && isHarnessCompactSpacer(output2[frozenLen]!)) frozenLen++;
     }
+    expect(output2.slice(0, frozenLen)).not.toContain(echo);
+    expect(isHarnessCompactSpacer(echo)).toBe(false);
+    const harness = output2.find(isHarnessCompactSpacer);
+    expect(harness).toBeDefined();
+    expect(harness!.model).toBe(HARNESS_COMPACT_SPACER_MODEL);
+    expect(firstText(harness!)).toBe(COMPACT_SPACER_TEXT);
+    expect(harness).not.toBe(echo);
   });
 
   test("legacy harness spacer without model still freezes", async () => {

src/director.test.ts

@@ -1177,4 +1177,51 @@ describe("chatDirector spacer echo", () => {
     );
     expect(afterReset.some((a) => a.type === "infer")).toBe(true);
   });
+
+  test("after echo-cap with open tasks, falls through to open-task rails", async () => {
+    const director = createChatDirector("base", [], { onTasksChange: () => {} });
+    await director.decide(
+      makeInferenceDoneEvent([
+        {
+          id: "mt",
+          name: "manage_tasks",
+          args: { action: "create", tasks: [{ id: "t1", title: "work", status: "doing" }] },
+        },
+      ]),
+      mockState,
+      mockCapabilities,
+    );
+    for (let i = 0; i < 2; i++) {
+      const nudged = actionsArray(
+        await director.decide(
+          spacerInferenceDone(LEGACY_COMPACT_SPACER_TEXT),
+          mockState,
+          mockCapabilities,
+        ),
+      );
+      expect(nudged.some((a) => a.type === "infer")).toBe(true);
+    }
+    const afterCap = actionsArray(
+      await director.decide(spacerInferenceDone(COMPACT_SPACER_TEXT), mockState, mockCapabilities),
+    );
+    expect(afterCap.some((a) => a.type === "infer")).toBe(true);
+    expect(afterCap.some((a) => a.type === "reply" && "content" in a && a.content === "")).toBe(
+      false,
+    );
+    for (let i = 0; i < 2; i++) {
+      const nudged = actionsArray(
+        await director.decide(
+          spacerInferenceDone(COMPACT_SPACER_TEXT),
+          mockState,
+          mockCapabilities,
+        ),
+      );
+      expect(nudged.some((a) => a.type === "infer")).toBe(true);
+    }
+    const exhausted = actionsArray(
+      await director.decide(spacerInferenceDone(COMPACT_SPACER_TEXT), mockState, mockCapabilities),
+    );
+    expect(exhausted.some((a) => a.type === "infer")).toBe(false);
+    expect(exhausted.some((a) => a.type === "reply")).toBe(true);
+  });
 });

src/provider/replay-sanitizer.test.ts

@@ -14,6 +14,12 @@ import {
   THINKING_ONLY_OMITTED,
   withReplaySanitizer,
 } from "./replay-sanitizer.js";
+import {
+  COMPACT_SPACER_TEXT,
+  COMPACTED_PREFIX,
+  HARNESS_COMPACT_SPACER_MODEL,
+  isHarnessCompactSpacer,
+} from "../session/compactor.js";
 
 const GROK_SIGNATURE = "grok-opaque-signature-blob";
 
@@ -400,4 +406,32 @@ describe("withReplaySanitizer", () => {
     expect(body.input.some((item) => item.type === "reasoning")).toBe(true);
     expect(body.input.some((item) => item.type === "function_call")).toBe(true);
   });
+
+  it("keeps a harness compact spacer as a role-alternating assistant turn", () => {
+    const spacer: ConversationTurn = {
+      role: "assistant",
+      model: HARNESS_COMPACT_SPACER_MODEL,
+      content: [{ type: "text", text: COMPACT_SPACER_TEXT }],
+      timestamp: 2,
+    };
+    const turns = sanitizeReplayTurns(
+      [
+        {
+          role: "user",
+          content: [{ type: "text", text: `${COMPACTED_PREFIX} earlier` }],
+          timestamp: 1,
+        },
+        spacer,
+        {
+          role: "user",
+          content: [{ type: "text", text: `${COMPACTED_PREFIX} later` }],
+          timestamp: 3,
+        },
+      ],
+      "claude-opus-4",
+    );
+    expect(turns.map((t) => t.role)).toEqual(["user", "assistant", "user"]);
+    expect(turns[1]?.content).toEqual([{ type: "text", text: COMPACT_SPACER_TEXT }]);
+    expect(isHarnessCompactSpacer(turns[1]!)).toBe(true);
+  });
 });