Stop compaction spacer text from becoming a model echo loop

Harness spacers were a natural-language token the model could copy as a
finished turn. Frozen-prefix matching then treated the echo as
harness-inserted, so idle compact re-armed and the prefix grew.

Author: TheGreatAxios

CHANGELOG.md

@@ -30,6 +30,9 @@ 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.
 
 ## [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 an assistant spacer between them so the prompt head can remain in the provider KV cache. 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, 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:
 
 - **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

@@ -8,7 +8,12 @@ import type {
 } from "@intx/types/runtime";
 import { createCompactionGovernor } from "./compaction.js";
 import { compactionResumeDeltaFor, compactionThresholdFor } from "../provider/context-window.js";
-import { COMPACTOR_KEEP_RECENT_TURNS, compactorNoOpFloor } from "../session/compactor.js";
+import {
+  COMPACTOR_KEEP_RECENT_TURNS,
+  COMPACT_SPACER_TEXT,
+  LEGACY_COMPACT_SPACER_TEXT,
+  compactorNoOpFloor,
+} from "../session/compactor.js";
 
 const capabilities = {
   infer: (options?: unknown) => ({ type: "infer", ...(options !== undefined ? { options } : {}) }),
@@ -37,10 +42,16 @@ function turnsOfLength(count: number, textLength: number): ConversationTurn[] {
   })) as unknown as ConversationTurn[];
 }
 
-function inferenceDone(input: number): Extract<ReactorInboundEvent, { type: "inference.done" }> {
+function inferenceDone(
+  input: number,
+  text = "",
+): Extract<ReactorInboundEvent, { type: "inference.done" }> {
   return {
     type: "inference.done",
-    turn: { role: "assistant", content: [] },
+    turn: {
+      role: "assistant",
+      content: text.length > 0 ? [{ type: "text", text }] : [],
+    },
     usage: usage(input),
     source: { sourceId: "s", provider: "p", model: "m" },
   } as unknown as Extract<ReactorInboundEvent, { type: "inference.done" }>;
@@ -443,4 +454,49 @@ describe("compaction governor", () => {
     expect(actions).not.toBeNull();
     expect(actions?.some((a) => a.type === "compact")).toBe(true);
   });
+
+  test("consecutive threshold and idle compacts are bounded without a non-echo turn", () => {
+    const governor = createCompactionGovernor(() => {});
+    const echo = LEGACY_COMPACT_SPACER_TEXT;
+    governor.noteInferenceDone(inferenceDone(overThreshold, echo), tenTurns);
+    expect(governor.interceptActions(toolDone(), inferAction, capabilities)).not.toBeNull();
+
+    governor.noteInferenceDone(inferenceDone(overThreshold, echo), tenTurns);
+    governor.noteInferenceDone(inferenceDone(overThreshold + resumeDelta, echo), tenTurns);
+    expect(governor.interceptActions(toolDone(), inferAction, capabilities)).not.toBeNull();
+
+    governor.noteInferenceDone(inferenceDone(overThreshold + resumeDelta, echo), tenTurns);
+    governor.noteInferenceDone(inferenceDone(overThreshold + 2 * resumeDelta, echo), tenTurns);
+    expect(governor.interceptActions(toolDone(), inferAction, capabilities)).toBeNull();
+    governor.noteIdleTurn(inferenceDone(overThreshold + 2 * resumeDelta, echo), [
+      { type: "reply", content: "done" },
+    ]);
+    expect(governor.interceptIdleContinuation(emptyMessage(), capabilities)).toBeNull();
+
+    governor.noteInferenceDone(
+      inferenceDone(overThreshold + 3 * resumeDelta, "real work"),
+      tenTurns,
+    );
+    expect(governor.interceptActions(toolDone(), inferAction, capabilities)).not.toBeNull();
+  });
+
+  test("spacer-echo terminal does not arm idle compact", () => {
+    let continuations = 0;
+    const governor = createCompactionGovernor(() => continuations++);
+    governor.noteInferenceDone(inferenceDone(overThreshold, LEGACY_COMPACT_SPACER_TEXT), tenTurns);
+    governor.noteIdleTurn(inferenceDone(overThreshold, LEGACY_COMPACT_SPACER_TEXT), [
+      { type: "reply", content: LEGACY_COMPACT_SPACER_TEXT },
+    ]);
+    expect(continuations).toBe(0);
+    governor.noteIdleTurn(inferenceDone(overThreshold, COMPACT_SPACER_TEXT), [
+      { type: "reply", content: COMPACT_SPACER_TEXT },
+    ]);
+    expect(continuations).toBe(0);
+    expect(governor.interceptIdleContinuation(emptyMessage(), capabilities)).toBeNull();
+
+    governor.noteIdleTurn(inferenceDone(overThreshold, "done"), [
+      { type: "reply", content: "done" },
+    ]);
+    expect(continuations).toBe(1);
+  });
 });

src/agent/compaction.ts

@@ -10,7 +10,12 @@ import {
   compactionThresholdFor,
   contextTokensFromUsage,
 } from "../provider/context-window.js";
-import { COMPACTOR_KEEP_RECENT_TURNS, compactorNoOpFloor } from "../session/compactor.js";
+import {
+  COMPACTOR_KEEP_RECENT_TURNS,
+  assistantTextIsCompactSpacerEcho,
+  compactorNoOpFloor,
+  isCompactSpacerEchoTurn,
+} from "../session/compactor.js";
 import { createContextEstimate, estimateOverheadTokens } from "./context-estimate.js";
 import { onTurnBoundary } from "./reactor-events.js";
 
@@ -22,6 +27,7 @@ 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;
+const MAX_CONSECUTIVE_THRESHOLD_COMPACTS = 2;
 
 // A compact action runs in its own reactor cycle, after which the reactor
 // idles until the next inbound event. Worker loops (sub-agents, the coding
@@ -45,6 +51,7 @@ export function createCompactionGovernor(
   // operator question to answer). Distinct from postCompactInfer.
   let postCompactMeter = false;
   let overflowRecoveries = 0;
+  let consecutiveThresholdCompacts = 0;
   // Set whenever the arming decision fell back to the local estimate because
   // the provider omitted usage or reported zero, so callers rendering a meter
   // can flag the number as approximate instead of implying provider-grade
@@ -90,11 +97,28 @@ export function createCompactionGovernor(
     awaitingPostCompactMeasurement = true;
   }
 
+  function atThresholdCompactCap(): boolean {
+    return consecutiveThresholdCompacts >= MAX_CONSECUTIVE_THRESHOLD_COMPACTS;
+  }
+
+  function issueThresholdCompact(): void {
+    consecutiveThresholdCompacts++;
+    noteCompactIssued();
+  }
+
+  function isSpacerEchoTerminal(event: ReactorInboundEvent, actions: ReactorAction[]): boolean {
+    if (event.type === "inference.done" && isCompactSpacerEchoTurn(event.turn)) return true;
+    return actions.some((a) => a.type === "reply" && assistantTextIsCompactSpacerEcho(a.content));
+  }
+
   function noteInferenceDone(
     event: Extract<ReactorInboundEvent, { type: "inference.done" }>,
     turns: readonly ConversationTurn[],
   ): void {
     overflowRecoveries = 0;
+    if (!isCompactSpacerEchoTurn(event.turn)) {
+      consecutiveThresholdCompacts = 0;
+    }
     if (requestContinuation === undefined) return;
     syncFromTurns(turns);
     lastModel = event.source?.model;
@@ -138,9 +162,10 @@ export function createCompactionGovernor(
     if (event.type !== "tool.done") return null;
     if (!pending && !(usingEstimate && isOverThreshold(estimate.tokens))) return null;
     if (!actions.some((a) => a.type === "infer")) return null;
+    if (atThresholdCompactCap()) return null;
     pending = false;
     postCompactInfer = true;
-    noteCompactIssued();
+    issueThresholdCompact();
     requestContinuation?.();
     return [
       ...actions.filter((a) => a.type !== "infer"),
@@ -154,7 +179,9 @@ export function createCompactionGovernor(
   // compact when it (or the operator's next message) arrives.
   function noteIdleTurn(event: ReactorInboundEvent, actions: ReactorAction[]): void {
     if (!pending || idlePending || requestContinuation === undefined) return;
+    if (atThresholdCompactCap()) return;
     if (!onTurnBoundary(event)) return;
+    if (isSpacerEchoTerminal(event, actions)) return;
     const terminal =
       actions.some((a) => a.type === "reply" || a.type === "wait") &&
       !actions.some((a) => a.type === "infer" || a.type === "execute_tools");
@@ -168,6 +195,10 @@ export function createCompactionGovernor(
     capabilities: ReactorCapabilities,
   ): ReactorAction[] | null {
     if (!idlePending || event.type !== "message.received") return null;
+    if (atThresholdCompactCap()) {
+      idlePending = false;
+      return null;
+    }
     idlePending = false;
     pending = false;
     const content = typeof event.message.content === "string" ? event.message.content : "";
@@ -180,7 +211,7 @@ export function createCompactionGovernor(
     } else {
       postCompactMeter = true;
     }
-    noteCompactIssued();
+    issueThresholdCompact();
     requestContinuation?.();
     return [capabilities.compact(COMPACTOR_NAME, "context-threshold")];
   }

src/agent/director.ts

@@ -10,7 +10,11 @@ import type {
   ConversationTurn,
   RetryPolicy,
 } from "@intx/types/runtime";
-import { type SessionMetadata, type TaskBoundary } from "../session/compactor.js";
+import {
+  type SessionMetadata,
+  type TaskBoundary,
+  isCompactSpacerEchoTurn,
+} from "../session/compactor.js";
 import type { WorkflowCoordinator } from "../workflows/coordinator.js";
 import { createCompactionGovernor, type CompactionGovernor } from "./compaction.js";
 import { onTurnBoundary } from "./reactor-events.js";
@@ -98,6 +102,9 @@ function ensureCycleSettlesWithReply(
 const MAX_OPEN_TASK_NUDGES = 3;
 const MAX_DECLINED_OPEN_TASK_NUDGES = 2;
 const MAX_INFERENCE_RECOVERIES = 2;
+const MAX_SPACER_ECHO_NUDGES = 2;
+
+const SPACER_ECHO_NUDGE = "Continue the task. Do not repeat internal markers.";
 
 const IDLE_OPEN_TASK_NUDGE =
   "\n\nYou are ending your turn while tasks are still open (todo/doing). " +
@@ -394,6 +401,7 @@ class ChatDirectorImpl extends DefaultDirector {
   private idleTerminationNudges = 0;
   private declinedTerminationNudges = 0;
   private inferenceRecoveries = 0;
+  private spacerEchoNudges = 0;
   private lastInferenceTurnHadContent = false;
   private operatorJustResponded = false;
   private tasks: Task[] = [];
@@ -633,6 +641,7 @@ class ChatDirectorImpl extends DefaultDirector {
       this.idleTerminationNudges = 0;
       this.declinedTerminationNudges = 0;
       this.inferenceRecoveries = 0;
+      this.spacerEchoNudges = 0;
       this.toolOnlyStreak = 0;
       this.toolOnlyNudgeFired = false;
       this.pendingToolOnlyNudge = false;
@@ -682,9 +691,10 @@ class ChatDirectorImpl extends DefaultDirector {
     if (onTurnBoundary(event)) {
       this.turnCount++;
       const hasToolCalls = event.turn.content.some((b) => b.type === "tool_call");
-      const hasText = event.turn.content.some(
-        (b) => b.type === "text" && typeof b.text === "string" && b.text.length > 0,
-      );
+      const hasText =
+        event.turn.content.some(
+          (b) => b.type === "text" && typeof b.text === "string" && b.text.length > 0,
+        ) && !isCompactSpacerEchoTurn(event.turn);
       this.lastInferenceTurnHadContent = hasToolCalls || hasText;
 
       // toolOnlyStreak is narration-sensitive: any turn with text clears it
@@ -795,6 +805,14 @@ class ChatDirectorImpl extends DefaultDirector {
       this.compaction.noteInferenceDone(event, turns);
     }
 
+    if (event.type === "inference.done" && isCompactSpacerEchoTurn(event.turn)) {
+      if (this.spacerEchoNudges < MAX_SPACER_ECHO_NUDGES) {
+        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];
 

src/context-compactor.test.ts

@@ -8,6 +8,8 @@ import {
   buildLLMTurnSummary,
   COMPACTED_PREFIX,
   COMPACT_SPACER_TEXT,
+  LEGACY_COMPACT_SPACER_TEXT,
+  isHarnessCompactSpacer,
   type SessionMetadata,
 } from "./session/compactor.js";
 import { createModelSummarizer } from "./session/summarizer.js";
@@ -627,6 +629,65 @@ describe("createPruningCompactor — prefix-stable summaries (CL-6914)", () => {
     ).toBe(true);
   });
 
+  test("harness spacer has no model and uses the non-lexical 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(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);
+  });
+
+  test("frozen prefix does not absorb a model-emitted spacer", 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: LEGACY_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);
+    if (harness !== undefined) {
+      expect(harness.model).toBeUndefined();
+      expect(firstText(harness)).toBe(COMPACT_SPACER_TEXT);
+      expect(harness).not.toBe(echo);
+    }
+  });
+
+  test("legacy harness spacer without model still freezes", 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 legacySpacer = makeTurn({
+      role: "assistant",
+      content: [{ type: "text", text: LEGACY_COMPACT_SPACER_TEXT }],
+    });
+    const grown = grow([summary!, legacySpacer], 16, "round2");
+    const output2 = (await compactor.apply(grown, mockStrategyCtx)).output;
+    expect(output2[0]).toBe(summary);
+    expect(output2[1]).toBe(legacySpacer);
+    expect(isHarnessCompactSpacer(legacySpacer)).toBe(true);
+  });
+
   test("empty-fold keep-set returns the input unchanged", async () => {
     const compactor = createPruningCompactor({
       keepRecentTurns: 1,