fix(compaction): fold fat anchors into the handoff not the live prompt

Unexcerpted edit_file pairs were riding the live fold as score-10
anchors and holding occupancy over the 60% trigger. The live set is
now the thin spine plus a token-capped tail: file-edit bodies go in
the fat handoff, images count against the tail budget, superseded
reads still stub when the tail is the whole transcript, and a still-
over fold notifies the operator without weakening the occupancy latch.

Author: TheGreatAxios

src/agent/chat-event-subscribers.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 import {
   CHAT_TASKS_CHANGED_EVENT,
   CHAT_TOOLS_ACTIVATE_EVENT,
+  COMPACTION_FOLD_NONCONVERGED_EVENT,
 } from "./director.js";
 import { handleChatDirectorEvent } from "./chat-event-subscribers.js";
 import type { Task } from "./tasks.js";
@@ -119,4 +120,28 @@ describe("handleChatDirectorEvent", () => {
     expect(dispatched).toBe(false);
     expect(log.calls).toEqual([]);
   });
+
+  test("dispatches a fold-nonconverged notice", () => {
+    const seen: string[] = [];
+    const log = makeLog();
+    const handled = handleChatDirectorEvent(
+      {
+        type: COMPACTION_FOLD_NONCONVERGED_EVENT,
+        data: { notice: "Context fold did not reduce occupancy." },
+      },
+      {
+        onTasksChanged: () => {
+          throw new Error("unexpected tasks-changed dispatch");
+        },
+        onToolsActivate: () => {
+          throw new Error("unexpected tools-activate dispatch");
+        },
+        onFoldNonConverged: (notice) => seen.push(notice),
+      },
+      log.log,
+    );
+    expect(handled).toBe(true);
+    expect(seen).toEqual(["Context fold did not reduce occupancy."]);
+    expect(log.calls).toEqual([]);
+  });
 });

src/agent/chat-event-subscribers.ts

@@ -10,14 +10,17 @@ import { type } from "arktype";
 import {
   CHAT_TASKS_CHANGED_EVENT,
   CHAT_TOOLS_ACTIVATE_EVENT,
+  COMPACTION_FOLD_NONCONVERGED_EVENT,
   ChatTasksChangedDataSchema,
   ChatToolsActivateDataSchema,
+  CompactionFoldNonConvergedDataSchema,
 } from "./director.js";
 import type { Task } from "./tasks.js";
 
 export interface ChatDirectorEventHandlers {
   onTasksChanged: (tasks: Task[]) => void;
   onToolsActivate: (names: string[]) => void;
+  onFoldNonConverged?: (notice: string) => void;
 }
 
 export type ChatDirectorEventDebugLog = (
@@ -58,5 +61,17 @@ export function handleChatDirectorEvent(
     handlers.onToolsActivate(parsed.names);
     return true;
   }
+  if (event.type === COMPACTION_FOLD_NONCONVERGED_EVENT) {
+    const parsed = CompactionFoldNonConvergedDataSchema(event.data);
+    if (parsed instanceof type.errors) {
+      logDebug(
+        "chat fold-nonconverged event dropped invalid payload: {error}",
+        { error: parsed.summary },
+      );
+      return true;
+    }
+    handlers.onFoldNonConverged?.(parsed.notice);
+    return true;
+  }
   return false;
 }

src/agent/compaction.test.ts

@@ -10,8 +10,13 @@ import {
   COMPACTION_CONTINUATION_EVENT,
   OPERATOR_COMPACT_REASON,
   createCompactionGovernor,
+  foldNonConvergedNotice,
   stickyExtraInstructionsFromRecords,
 } from "./compaction.js";
+import {
+  COMPACTION_FOLD_NONCONVERGED_EVENT,
+  createChatDirector,
+} from "./director.js";
 import {
   compactionWideResumeDeltaFor,
   compactionThresholdFor,
@@ -157,7 +162,10 @@ describe("compaction governor", () => {
       governor.interceptActions(toolDone(), inferAction, capabilities),
     ).toBeNull();
 
-    governor.noteInferenceDone(inferenceDone(overThreshold), turnsOfLength(1, 1));
+    governor.noteInferenceDone(
+      inferenceDone(overThreshold),
+      turnsOfLength(1, 1),
+    );
     expect(
       governor.interceptActions(toolDone(), inferAction, capabilities),
     ).toBeNull();
@@ -705,7 +713,10 @@ describe("compaction governor", () => {
 
   test("manual compact no-ops below the compactor floor", () => {
     const governor = createCompactionGovernor(undefined);
-    governor.noteInferenceDone(inferenceDone(overThreshold), turnsOfLength(1, 1));
+    governor.noteInferenceDone(
+      inferenceDone(overThreshold),
+      turnsOfLength(1, 1),
+    );
     expect(governor.requestManual("focus on tests")).toBe("noop");
     expect(governor.extraInstructions).toBeUndefined();
     expect(
@@ -844,6 +855,103 @@ describe("post-compact above-threshold latch (CL-9006)", () => {
     expect(governor.foldNonConverged).toBe(true);
   });
 
+  test("foldNonConvergedNotice names the still-over fold for the operator", () => {
+    expect(foldNonConvergedNotice()).toMatch(/did not reduce occupancy/i);
+    expect(foldNonConvergedNotice()).toMatch(/paused/i);
+  });
+
+  test("ChatDirector emits the non-convergence notice once after a still-over fold", async () => {
+    const director = createChatDirector("sys", [], {});
+    const caps: ReactorCapabilities = {
+      infer: () => ({ type: "infer" }),
+      executeTools: () => ({ type: "execute_tools", calls: [] }),
+      suspend: (gate) => ({ type: "suspend", gate }),
+      fork: (mode, forkId) => ({ type: "fork", mode, forkId }),
+      emit: (eventType, data) => ({ type: "emit", eventType, data }),
+      reply: (content: string) => ({ type: "reply", content }),
+      checkpoint: (message = "") => ({ type: "checkpoint", message }),
+      compact: (compactor, reason) => ({ type: "compact", compactor, reason }),
+      wait: () => ({ type: "wait" }),
+      done: () => ({ type: "done" }),
+    };
+    const manyTurns = {
+      turns: Array.from({ length: 8 }, () => ({
+        role: "assistant" as const,
+        content: [],
+        model: "test-model",
+        timestamp: 0,
+      })),
+      activeForks: [],
+      pendingOperations: [],
+      activeGates: [],
+      tokenUsage: usage(overThreshold),
+      lastCycleUsage: null,
+      lastCycleSource: null,
+      sessionId: "test-session",
+    };
+    const done = (input: number): ReactorInboundEvent =>
+      ({
+        type: "inference.done",
+        turn: {
+          role: "assistant",
+          content: [
+            {
+              type: "tool_call",
+              id: "call-1",
+              name: "read_file",
+              arguments: { path: "x.ts" },
+            },
+          ],
+          model: "test-model",
+          timestamp: 0,
+        },
+        usage: usage(input),
+        source: {
+          sourceId: "test",
+          provider: "openai",
+          model: "test-model",
+        },
+      }) as ReactorInboundEvent;
+    const toolDoneEvent = {
+      type: "tool.done",
+      result: { callId: "call-1", content: "ok", isError: false },
+    } as ReactorInboundEvent;
+
+    await director.decide(done(overThreshold), manyTurns as never, caps);
+    await director.decide(toolDoneEvent, manyTurns as never, caps);
+    const post = await director.decide(
+      done(overThreshold),
+      manyTurns as never,
+      caps,
+    );
+    const arr = Array.isArray(post) ? post : [post];
+    const notices = arr.filter(
+      (a) =>
+        a.type === "emit" &&
+        "eventType" in a &&
+        a.eventType === COMPACTION_FOLD_NONCONVERGED_EVENT,
+    );
+    expect(notices).toHaveLength(1);
+    expect(notices[0]).toMatchObject({
+      data: { notice: foldNonConvergedNotice() },
+    });
+
+    const again = await director.decide(
+      done(overThreshold + 1),
+      manyTurns as never,
+      caps,
+    );
+    const againArr = Array.isArray(again) ? again : [again];
+    expect(
+      againArr.filter(
+        (a) =>
+          a.type === "emit" &&
+          "eventType" in a &&
+          a.eventType === COMPACTION_FOLD_NONCONVERGED_EVENT,
+      ),
+    ).toHaveLength(0);
+  });
+
   test("the consecutive-compact cap holds across tool-call occupancy", () => {
     const governor = createCompactionGovernor(() => undefined);
     governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
@@ -1207,7 +1315,9 @@ describe("handoff arming (/handoff)", () => {
     {
       title: "noop then cancelManual does not wipe extras from a prior fold",
       fire: "idle",
-      midRequests: [{ turns: turnsOfLength(1, 1), text: "wipe this", result: "noop" }],
+      midRequests: [
+        { turns: turnsOfLength(1, 1), text: "wipe this", result: "noop" },
+      ],
     },
     {
       title:

src/agent/compaction.ts

@@ -103,6 +103,11 @@ export function compactFloorNoopNotice(instructions: string): string {
     : "Nothing to compact yet.";
 }
 
+/** Operator-facing notice after a fold whose post-compact occupancy is still over threshold. */
+export function foldNonConvergedNotice(): string {
+  return "Context fold did not reduce occupancy below the compact threshold. Further automatic folds are paused until usage drops.";
+}
+
 /** Run-record `provider:model` (or slash form) as a LastCycleSource. */
 export function lastCycleSourceFromRunModel(
   model: string | undefined,

src/agent/director.ts

@@ -20,6 +20,7 @@ import type { WorkflowCoordinator } from "../workflows/coordinator.js";
 import {
   compactionContinuationAction,
   createCompactionGovernor,
+  foldNonConvergedNotice,
   type CompactionGovernor,
   type HandoffArming,
   type ManualCompactArming,
@@ -457,6 +458,8 @@ function applyManageTasksToolCall(
 // (inference., tool., reactor., fork.).
 export const CHAT_TASKS_CHANGED_EVENT = "custom.chat.tasks.changed";
 export const CHAT_TOOLS_ACTIVATE_EVENT = "custom.chat.tools.activate";
+export const COMPACTION_FOLD_NONCONVERGED_EVENT =
+  "custom.compaction.fold_nonconverged";
 export const CREDENTIAL_RECOVERY_INTERCHANGE_TYPE =
   "system.credential.refresh" as const;
 export const ChatTasksChangedDataSchema = type({
@@ -465,6 +468,9 @@ export const ChatTasksChangedDataSchema = type({
 export const ChatToolsActivateDataSchema = type({
   names: "string[]",
 });
+export const CompactionFoldNonConvergedDataSchema = type({
+  notice: "string",
+});
 
 export interface ChatDirectorOptions {
   // CL-7919: task-boundary classification and workflow coordination are not
@@ -1273,7 +1279,15 @@ class ChatDirectorImpl extends DefaultDirector {
     const cycled = state.lastCycleSource?.sourceId;
     if (cycled !== undefined && cycled !== "") this.currentSourceId = cycled;
     if (onTurnBoundary(event)) {
+      const wasNonConverged = this.compaction.foldNonConverged;
       this.compaction.noteInferenceDone(event, turns);
+      if (this.compaction.foldNonConverged && !wasNonConverged) {
+        this.pendingEmits.push(
+          capabilities.emit(COMPACTION_FOLD_NONCONVERGED_EVENT, {
+            notice: foldNonConvergedNotice(),
+          }),
+        );
+      }
     }
 
     if (