billion-context-dsh 0.2.24 → 0.2.26

package/dist/index.js

@@ -3363,6 +3363,9 @@ function makePreview(text, query, len) {
   return prefix + text.slice(start, end).trim() + suffix;
 }
 
+// src/index.ts
+import { CONTEXT_WINDOW_EXCEEDED_CODE } from "@deepseek-ai/dsh-llm";
+
 // src/lru.ts
 var DEFAULT_SESSION_CACHE_LIMIT = 512;
 var LruMap = class extends Map {
@@ -3478,9 +3481,18 @@ function buildToolCallIndex(events) {
 }
 var SUMMARY_FRAME_PREFIX = "[Model-written summary \u2014 not user words; re-verify any obligations before relying on them]";
 function withSummaryFramePrefix(text) {
-  return text.startsWith(SUMMARY_FRAME_PREFIX) ? text : `${SUMMARY_FRAME_PREFIX}
+  if (text.startsWith(SUMMARY_FRAME_PREFIX)) return text;
+  if (isEngineWrittenSummary(text)) return text;
+  return `${SUMMARY_FRAME_PREFIX}
 ${text}`;
 }
+var ENGINE_SUMMARY_LEAD = "[engine-written summary \u2014 context-overflow emergency compaction";
+function isEngineWrittenSummary(text) {
+  return text.startsWith(ENGINE_SUMMARY_LEAD);
+}
+function overflowMarkerSummary(hiddenCount) {
+  return `${ENGINE_SUMMARY_LEAD}: ${hiddenCount} surface message(s) hidden because the provider rejected the request as exceeding the context window. The originals are intact in the session log \u2014 use search_context or decompress (see acp_status) to read them, or re-run the compress tool over this range to write a proper summary.]`;
+}
 function projectEvent(event, toolNames) {
   switch (event.type) {
     case "user/message": {
@@ -3606,7 +3618,12 @@ function contentBlocksOfEvent(event) {
 function isCheckpointNode(event) {
   if (event.type !== "user/message") return false;
   const source = event.data.source;
-  return source?.plugin === "compact";
+  return source?.plugin === "compact" || source?.kind === "compact-checkpoint";
+}
+function checkpointCompactionIdOf(event) {
+  if (!isCheckpointNode(event)) return null;
+  const source = event.data.source;
+  return typeof source?.compactionId === "string" ? source.compactionId : null;
 }
 var METADATA_PLUGINS = /* @__PURE__ */ new Set([
   "acp-nudge",
@@ -3619,17 +3636,44 @@ var REAL_CONTENT_PLUGINS = /* @__PURE__ */ new Set([
   "user-approval",
   "tools-ptc"
 ]);
+var REAL_CONTENT_KINDS = /* @__PURE__ */ new Set([
+  "runtime-context",
+  // dynamic-context snapshot (was '@deepseek-ai/dsh-system-prompt')
+  "ptc-mode"
+  // deferred tool context (was 'tools-ptc' / 'tools-code-mode')
+]);
+var AUDITED_RELAY_KINDS = /* @__PURE__ */ new Set([
+  "subagent-report",
+  "subagent-settled"
+]);
 var HOST_INSTRUCTION_KINDS = /* @__PURE__ */ new Set([
   "agent-instructions",
   // AGENTS.md injection (hook shape: {kind:'agent-instructions', form:'instructions'})
-  "skill-catalog"
+  "skill-catalog",
   // skill catalog (form:'catalog')
+  // Host compaction summary row (DSH >= 0.1.7; was plugin 'dsh-compaction-basic').
+  // That legacy name was never whitelisted, so its rows were barriers already —
+  // the renamed spelling keeps exactly that treatment instead of silently
+  // becoming foldable content (issue #169).
+  "compact-basic"
 ]);
+function sourcePluginOf(source) {
+  if (source === void 0 || typeof source !== "object") return void 0;
+  const kind = source.kind;
+  if (kind === "plugin") {
+    return typeof source.plugin === "string" && source.plugin.length > 0 ? source.plugin : void 0;
+  }
+  if (typeof kind === "string" && kind.startsWith("plugin:")) {
+    const name = kind.slice("plugin:".length);
+    return name.length > 0 ? name : void 0;
+  }
+  return void 0;
+}
 function isAgentInstructionsRow(event) {
   if (event.type !== "user/message") return false;
   const source = event.data.source;
   if (!source) return false;
-  return source.kind === "agent-instructions" || source.kind === "plugin" && source.plugin === "agent-instructions";
+  return source.kind === "agent-instructions" || sourcePluginOf(source) === "agent-instructions";
 }
 function classifySurfaceEvent(event) {
   if (isCheckpointNode(event)) return "checkpoint";
@@ -3638,20 +3682,26 @@ function classifySurfaceEvent(event) {
   if (!source) return "real";
   const kind = source.kind;
   if (kind === "user") return "real";
-  if (kind === "plugin") {
-    if (source.plugin !== void 0 && METADATA_PLUGINS.has(source.plugin)) return "metadata";
-    if (source.plugin !== void 0 && REAL_CONTENT_PLUGINS.has(source.plugin)) return "real";
+  const plugin = sourcePluginOf(source);
+  if (kind === "plugin" || plugin !== void 0) {
+    if (plugin !== void 0 && METADATA_PLUGINS.has(plugin)) return "metadata";
+    if (plugin !== void 0 && REAL_CONTENT_PLUGINS.has(plugin)) return "real";
     return "instruction";
   }
-  if (kind !== void 0 && HOST_INSTRUCTION_KINDS.has(kind)) return "instruction";
-  return "real";
+  if (typeof kind !== "string") return "real";
+  if (HOST_INSTRUCTION_KINDS.has(kind)) return "instruction";
+  if (REAL_CONTENT_KINDS.has(kind) || AUDITED_RELAY_KINDS.has(kind)) return "real";
+  return "instruction";
 }
 function isRealUserTurn(event) {
   if (event.type !== "user/message") return false;
   if (classifySurfaceEvent(event) !== "real") return false;
   const source = event.data.source;
-  if (source?.plugin !== void 0 && REAL_CONTENT_PLUGINS.has(source.plugin)) return false;
-  return source?.kind !== "subagent-report" && source?.kind !== "subagent-settled";
+  const plugin = sourcePluginOf(source);
+  if (plugin !== void 0 && REAL_CONTENT_PLUGINS.has(plugin)) return false;
+  const kind = source?.kind;
+  if (typeof kind === "string" && REAL_CONTENT_KINDS.has(kind)) return false;
+  return kind !== "subagent-report" && kind !== "subagent-settled";
 }
 
 // src/host-tokens.ts
@@ -4036,9 +4086,8 @@ function summarySeqIndex(events) {
   const index = /* @__PURE__ */ new Map();
   for (const event of events) {
     if (event.type !== "user/message") continue;
-    const source = event.data.source;
-    const compactionId = source?.plugin === "compact" ? source.compactionId : void 0;
-    if (compactionId !== void 0 && !index.has(compactionId)) index.set(compactionId, event.seq);
+    const compactionId = checkpointCompactionIdOf(event);
+    if (compactionId !== null && !index.has(compactionId)) index.set(compactionId, event.seq);
   }
   return index;
 }
@@ -4128,7 +4177,10 @@ function hideSurfaceSeqs(session, seqs, text, priceEvent = hostPriceEvent) {
   const body = text !== void 0 && text.trim().length > 0 ? text : PRUNE_NOTE;
   session.append("user/message", createUserMessage({
     content: [{ type: "text", text: body }],
-    source: { kind: "plugin", plugin: "billion-context-dsh" }
+    // V4 producer kind (issue #163): DSH ≥0.1.7's V4 admission rejects the
+    // legacy wrapper `{ kind: 'plugin', plugin: … }`; `plugin:<name>` is what
+    // the host's own V3→V4 migration emits and is accepted by 0.1.5 too.
+    source: { kind: "plugin:billion-context-dsh" }
   }), {
     surfaceOp: { op: "replace", startSeq: start, endSeq: end },
     sourceEventSeqs: [...seqs]
@@ -4436,10 +4488,10 @@ function blockRegistry(session) {
 }
 function blockRefForSummarySeq(session, seq) {
   const event = eventAtOf(session, seq);
-  if (event?.type !== "user/message") return null;
-  const source = event.data.source;
-  if (source?.plugin !== "compact" || source.compactionId === void 0) return null;
-  const entry = blockRegistry(session).find((r) => r.blockId === source.compactionId);
+  if (event === void 0) return null;
+  const compactionId = checkpointCompactionIdOf(event);
+  if (compactionId === null) return null;
+  const entry = blockRegistry(session).find((r) => r.blockId === compactionId);
   if (entry === void 0) return null;
   return entry.kernelBlockId;
 }
@@ -4459,10 +4511,8 @@ function summarySeqOfKernelBlock(session, kernelBlockId) {
 }
 function checkpointBlockIdOf(events, seq) {
   const event = events[seq];
-  if (event?.type !== "user/message") return null;
-  const source = event.data.source;
-  if (source?.plugin !== "compact" || source.compactionId === void 0) return null;
-  return source.compactionId;
+  if (event === void 0) return null;
+  return checkpointCompactionIdOf(event);
 }
 function expandShadowedSeqs(session, blockId) {
   const ledger = rebuildBlockLedger(sessionEventsOf(session));
@@ -4902,7 +4952,13 @@ function buildNudge(agent, env, lastNudgeTurn, emergencyNudges, onEmergencyCapHi
   );
   const message = createUserMessage2({
     content: [{ type: "text", text }],
-    source: { kind: "plugin", plugin: "acp-nudge" }
+    // V4 producer kind (issue #163): DSH ≥0.1.7's V4 admission rejects the
+    // legacy wrapper shape `{ kind: 'plugin', plugin: … }` outright (a wedged
+    // batch fails the NEXT turn with "format v4 message requires a
+    // producer-owned source kind"). `plugin:<name>` is exactly what the host's
+    // own V3→V4 migration emits for unregistered plugins, and DSH 0.1.5
+    // sessions accept it too (probe-verified), so no version gate is needed.
+    source: { kind: "plugin:acp-nudge" }
   });
   return { message, emergency };
 }
@@ -5022,7 +5078,7 @@ function windowSourceLabel(window) {
   if (window.source === "auto") {
     return `auto-detected from ${window.provider ?? "?"}/${window.model ?? "?"}`;
   }
-  if (window.probeFailed === true) return "default (auto-detection failed \u2014 see /acp config)";
+  if (window.probeFailed === true) return "default (auto-detection failed \u2014 see /acp-prune config)";
   return "default (auto-detection unavailable)";
 }
 function projectedContextWindow(agent) {
@@ -5879,7 +5935,7 @@ async function statusText(env, agent) {
     );
   }
   if (window.probeFailed === true) {
-    lines.push(`  \u26A0 window auto-detection failed \u2014 using the ${limit} fallback (change modelContextLimit or autoModelContextLimit via /acp config \u2014 or restart \u2014 to re-probe)`);
+    lines.push(`  \u26A0 window auto-detection failed \u2014 using the ${limit} fallback (change modelContextLimit or autoModelContextLimit via /acp-prune config \u2014 or restart \u2014 to re-probe)`);
   }
   const state = structuredClone(env.store.stateFor(session));
   const config = kernelConfigFor({ ...env, modelContextLimit: limit });
@@ -5902,18 +5958,18 @@ async function statusText(env, agent) {
 }
 function compressText(env, agent, args) {
   if (args.length < 3) {
-    return "/acp compress <startSeq> <endSeq> <summary...>";
+    return "/acp-prune compress <startSeq> <endSeq> <summary...>";
   }
   const startSeq = Number(args[0]);
   const endSeq = Number(args[1]);
   const summary = args.slice(2).join(" ");
   if (!Number.isInteger(startSeq) || !Number.isInteger(endSeq)) {
-    return "/acp compress: startSeq and endSeq must be integers";
+    return "/acp-prune compress: startSeq and endSeq must be integers";
   }
   const session = agent.session;
   const { start, end } = resolveSurfaceRange(session, startSeq, endSeq);
   if (blockRefForSummarySeq(session, start) !== null || blockRefForSummarySeq(session, end) !== null) {
-    return "/acp compress: the range touches a compressed block summary node \u2014 distill it with the compress tool (seq-based batch), not /acp compress";
+    return "/acp-prune compress: the range touches a compressed block summary node \u2014 distill it with the compress tool (seq-based batch), not /acp-prune compress";
   }
   const shadowed = shadowedSeqsOf(session, start, end);
   const instructionHits = guardedRowsInSpan(guardedSurfaceSeqsOf(session), shadowed);
@@ -5933,7 +5989,7 @@ function compressText(env, agent, args) {
   });
   return `Compressed seqs ${start}..${end} (${shadowed.length} messages) as block ${compactionId.slice(0, 8)}`;
 }
-var DECOMPRESS_USAGE = "/acp decompress <blockId> [offset] [limit]";
+var DECOMPRESS_USAGE = "/acp-prune decompress <blockId> [offset] [limit]";
 function decompressText(_env, agent, args) {
   if (args.length < 1) return DECOMPRESS_USAGE;
   const offset = args[1] === void 0 ? 0 : Number(args[1]);
@@ -5944,7 +6000,7 @@ function decompressText(_env, agent, args) {
   const blockId = blockIdOfKernelRef(session, args[0]);
   const ledger = rebuildBlockLedger(sessionEventsOf(session));
   const block = blockId === null ? ledger.find((entry) => entry.blockId.startsWith(args[0])) : ledger.find((entry) => entry.blockId === blockId);
-  if (block === void 0) return `block "${args[0]}" not found (see /acp status)`;
+  if (block === void 0) return `block "${args[0]}" not found (see /acp-prune status)`;
   const expanded = expandShadowedSeqs(session, block.blockId);
   const page = sliceDecompressPage(
     expanded,
@@ -5964,14 +6020,14 @@ function decompressText(_env, agent, args) {
     `Block ${block.blockId} \u2014 ${block.summary}`,
     `[messages ${page.offset + 1}..${page.offset + page.seqs.length} of ${page.total}]`
   ];
-  if (!page.exhausted) lines.push(`Continue with: /acp decompress ${block.blockId.slice(0, 8)} ${page.offset + page.seqs.length}`);
+  if (!page.exhausted) lines.push(`Continue with: /acp-prune decompress ${block.blockId.slice(0, 8)} ${page.offset + page.seqs.length}`);
   lines.push("", parts.join("\n\n") || "(no recoverable content)");
   return lines.join("\n");
 }
 function acpCommand(env) {
   return {
-    name: "acp",
-    description: "Active Context Pruning \u2014 model-driven context compression. Usage: /acp status | /acp compress <startSeq> <endSeq> <summary> | /acp decompress <blockId> [offset] [limit] | /acp config [list|set <key> <value>|reset <key>|all]",
+    name: "acp-prune",
+    description: "Active Context Pruning \u2014 model-driven context compression. Usage: /acp-prune status | /acp-prune compress <startSeq> <endSeq> <summary> | /acp-prune decompress <blockId> [offset] [limit] | /acp-prune config [list|set <key> <value>|reset <key>|all]",
     handler: async (invocation) => {
       const raw = invocation.rawInput.trim();
       if (raw === "" || raw === "status") {
@@ -5986,7 +6042,7 @@ function acpCommand(env) {
       if (raw.startsWith("decompress")) {
         return { kind: "success", text: decompressText(env, invocation.agent, raw.slice("decompress".length).trim().split(/\s+/)) };
       }
-      return { kind: "error", text: `unknown /acp subcommand "${raw.split(/\s+/)[0]}" \u2014 use status | compress | decompress | config` };
+      return { kind: "error", text: `unknown /acp-prune subcommand "${raw.split(/\s+/)[0]}" \u2014 use status | compress | decompress | config` };
     }
   };
 }
@@ -5998,7 +6054,7 @@ function isSettingsKey(key) {
 }
 function settingsWriteFailure(error) {
   if (error instanceof SettingsConflictError) {
-    return "conflict: another writer changed this setting at the same time \u2014 run /acp config again";
+    return "conflict: another writer changed this setting at the same time \u2014 run /acp-prune config again";
   }
   return `rejected: ${String(error)}`;
 }
@@ -6026,7 +6082,7 @@ function configListText(surface) {
   }
   lines.push("", "  changes apply to running sessions immediately (no restart)");
   lines.push("  coreOverrides (composition layer) merge LAST and beat these values on same-name keys");
-  lines.push("  /acp config reset <key> returns the key to the composition row / engine default");
+  lines.push("  /acp-prune config reset <key> returns the key to the composition row / engine default");
   return lines.join("\n");
 }
 async function configSetText(surface, key, rawValue) {
@@ -6088,13 +6144,13 @@ async function configText(env, rest) {
   const verb = args[0] ?? "list";
   if (verb === "list") return configListText(surface);
   if (verb === "set") {
-    if (args.length < 3) return "usage: /acp config set <key> <value> (e.g. /acp config set nudgeMaxContextLimitPct 0.72)";
+    if (args.length < 3) return "usage: /acp-prune config set <key> <value> (e.g. /acp-prune config set nudgeMaxContextLimitPct 0.72)";
     return configSetText(surface, args[1], args.slice(2).join(" "));
   }
   if (verb === "reset") {
     return configResetText(surface, args[1] ?? "all");
   }
-  return `unknown /acp config verb "${verb}" \u2014 use list | set <key> <value> | reset <key>|all`;
+  return `unknown /acp-prune config verb "${verb}" \u2014 use list | set <key> <value> | reset <key>|all`;
 }
 
 // src/system-prompt.ts
@@ -6107,6 +6163,9 @@ var DEFAULT_CONFIG = {
   autoTools: true,
   autoCommand: true,
   autoNudge: true,
+  // Same default as the host's compaction-basic policy: one owned retry per
+  // unrelieved overflow, then the original error is preserved.
+  maxOverflowRetries: 1,
   // Nudge thresholds: engine defaults 0.70/0.85 — deliberately below the
   // kernel/billion-context-pi 0.75/0.95. 0.95 leaves no room to act before
   // the API rejects, and the host's compaction-basic line (thresholdRatio
@@ -6120,7 +6179,11 @@ var DEFAULT_CONFIG = {
 function resolveAcpConfig(config = {}) {
   const resolved = resolvePresetThresholds({ ...DEFAULT_CONFIG, ...config }, config);
   assertNudgeThresholdOrder(resolved);
-  return resolved;
+  const maxOverflowRetries = resolved.maxOverflowRetries ?? 1;
+  if (!Number.isInteger(maxOverflowRetries) || maxOverflowRetries < 0) {
+    throw new Error(`maxOverflowRetries must be a non-negative integer (got ${maxOverflowRetries})`);
+  }
+  return { ...resolved, maxOverflowRetries };
 }
 function resolvePresetThresholds(base, config) {
   if (base.preset === void 0) return base;
@@ -6132,6 +6195,17 @@ function resolvePresetThresholds(base, config) {
     nudgeEmergencyThresholdPct: config.nudgeEmergencyThresholdPct ?? preset.nudgeEmergencyThresholdPct
   };
 }
+function presetFilledSettingsEntry(config) {
+  const entry = filterSettingsEntry(config);
+  if (config.preset === void 0) return entry;
+  const preset = resolvePreset(config.preset);
+  return {
+    ...entry,
+    nudgeMinContextLimitPct: config.nudgeMinContextLimitPct ?? preset.nudgeMinContextLimitPct,
+    nudgeMaxContextLimitPct: config.nudgeMaxContextLimitPct ?? preset.nudgeMaxContextLimitPct,
+    nudgeEmergencyThresholdPct: config.nudgeEmergencyThresholdPct ?? preset.nudgeEmergencyThresholdPct
+  };
+}
 function assertNudgeThresholdOrder(config) {
   const { nudgeMinContextLimitPct: min, nudgeMaxContextLimitPct: max, nudgeEmergencyThresholdPct: emergency } = config;
   const describe = `min ${min ?? "kernel default"} / max ${max ?? "kernel default"} / emergency ${emergency ?? "kernel default"}`;
@@ -6171,12 +6245,16 @@ var AcpCompactionEngine = class extends CompactionEngine {
   windowCache = /* @__PURE__ */ new Map();
   /** Live settings snapshot thunk (composition → user settings layer); swapped when the settings provider attaches (SettingsProvider.installSection). */
   readSettingsSource = () => resolveAcpSettings({});
-  /** The settings service, captured lazily for /acp config (undefined in provider-less processes). */
+  /** The settings service, captured lazily for /acp-prune config (undefined in provider-less processes). */
   settingsService;
-  /** /acp config read/write surface. */
+  /** /acp-prune config read/write surface. */
   settingsCommand;
   /** Per route the adapter's per-request output cap (the output reservation); null = undisclosed. */
   outputReservationCache = /* @__PURE__ */ new Map();
+  /** Per-agent context-overflow recovery budget (mirrors the host's `overflowRetries`). */
+  overflowRetries = /* @__PURE__ */ new Map();
+  /** Per-session overflow agents, so session progress can reset the recovery budget. */
+  overflowSessions = /* @__PURE__ */ new Map();
   constructor(ctx, config = {}) {
     super(ctx);
     this.config = resolveAcpConfig(config);
@@ -6185,7 +6263,7 @@ var AcpCompactionEngine = class extends CompactionEngine {
     this.kernel = createCore(ports);
     setDocCacheCap(128 * 1024 * 1024);
     this.store = new AcpStateStore();
-    const compositionEntry = filterSettingsEntry(config);
+    const compositionEntry = presetFilledSettingsEntry(config);
     let current = resolveAcpSettings(compositionEntry);
     this.readSettingsSource = () => current;
     const engine = this;
@@ -6202,6 +6280,12 @@ var AcpCompactionEngine = class extends CompactionEngine {
     this.settingsCommand = makeSettingsCommandSurface(() => this.settingsService, () => current);
     if (this.config.settingsEnabled !== false) {
       ctx.inject(["settings"], (settingsCtx) => {
+        if (typeof settingsCtx.settings?.installSection !== "function") {
+          this.ctx.logger.warn(
+            "billion-context-dsh: host settings service has no installSection (removed in dsh-settings >= 0.1.7) \u2014 the compaction-acp settings section is not registered; the six knobs keep their composition values and /acp-prune config reports the section unavailable"
+          );
+          return void 0;
+        }
         settingsCtx.settings.installSection(ctx, ACP_SETTINGS_NAMESPACE, AcpSettingsSchema, compositionEntry, {
           // The seam's source type follows the entry it registered, so `source`
           // is a partial view of the settings; re-resolve it into a
@@ -6223,7 +6307,7 @@ var AcpCompactionEngine = class extends CompactionEngine {
       kernel: this.kernel,
       store: this.store,
       // The settings-exposed knobs read LIVE from the settings source, so a
-      // settings.yaml edit (or /acp config set) hot-applies to every
+      // settings.yaml edit (or /acp-prune config set) hot-applies to every
       // subsequent call — consumers never see stale numbers. (ToolEnvironment
       // fields are readonly properties; getters satisfy them.)
       get modelContextLimit() {
@@ -6240,7 +6324,7 @@ var AcpCompactionEngine = class extends CompactionEngine {
       },
       coreOverrides: this.config.coreOverrides,
       // Display-only: which named preset produced the thresholds above (if any),
-      // so /acp status can name it. The resolved pct values above are what the
+      // so /acp-prune status can name it. The resolved pct values above are what the
       // kernel actually reads — this field never feeds kernelConfigFor.
       preset: this.config.preset,
       windowFor: (agent) => this.windowFor(agent),
@@ -6282,6 +6366,13 @@ var AcpCompactionEngine = class extends CompactionEngine {
       });
     }
     ctx.on("session/event", (session, event) => {
+      if (event.type === "assistant/message") {
+        const overflowAgent = this.overflowSessions.get(session);
+        if (overflowAgent !== void 0) {
+          this.overflowRetries.delete(overflowAgent);
+          this.overflowSessions.delete(session);
+        }
+      }
       if (event.type !== "tool/result") return;
       const message = event.data.message;
       const block = message.content[0];
@@ -6312,6 +6403,49 @@ var AcpCompactionEngine = class extends CompactionEngine {
       if (outcome === null) return decision;
       return { kind: "enter", messages: [...decision.messages, outcome.message] };
     });
+    ctx.on("agent/status", ({ agent, status }) => {
+      if (status !== "idle") return;
+      this.overflowRetries.delete(agent);
+      this.overflowSessions.delete(agent.session);
+    });
+    ctx.on("agent/request-error", async ({ agent, failure, signal }, next) => {
+      if (failure.code !== CONTEXT_WINDOW_EXCEEDED_CODE || signal.aborted) return next();
+      this.overflowSessions.set(agent.session, agent);
+      const retries = this.overflowRetries.get(agent) ?? 0;
+      const max = this.config.maxOverflowRetries ?? 1;
+      if (retries >= max) {
+        this.ctx.logger.warn(
+          `billion-context-dsh: context-overflow recovery budget spent (${max} retries) for session ${agent.session.id}; preserving the original request error`
+        );
+        return next();
+      }
+      const generation = agent.session.surface.replaceGeneration;
+      let result;
+      try {
+        result = await this.compactForOverflow(agent, signal);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!signal.aborted && agent.session.surface.replaceGeneration > generation) {
+          this.ctx.logger.warn(
+            `billion-context-dsh: context-overflow compaction failed after durable surface progress: ${message}; retrying from the replacement surface`
+          );
+          this.overflowRetries.set(agent, retries + 1);
+          return { kind: "retry" };
+        }
+        this.ctx.logger.warn(
+          `billion-context-dsh: context-overflow compaction failed: ${message}; ${signal.aborted ? "cancellation prevents retry" : "preserving the original request error"}`
+        );
+        return next();
+      }
+      if (signal.aborted || agent.session.surface.replaceGeneration <= generation) return next();
+      if (result !== null) {
+        this.ctx.logger.info(
+          `compaction (context overflow recovery): shadowed ${result.shadowedSeqs.length} surface nodes (seqs ${result.start}-${result.end}, ~${result.shadowedTokenCount} tokens)`
+        );
+      }
+      this.overflowRetries.set(agent, retries + 1);
+      return { kind: "retry" };
+    });
     const systemPrompt = ctx.get("systemPrompt");
     if (systemPrompt !== void 0) {
       systemPrompt.section({
@@ -6381,7 +6515,7 @@ var AcpCompactionEngine = class extends CompactionEngine {
       cap = probe.outputReservation;
       if (probe.contextWindow === null) {
         this.ctx.logger.warn(
-          `billion-context-dsh: context-window auto-detection failed for ${provider}/${model} \u2014 using the ${DEFAULT_CONTEXT_WINDOW} fallback (change modelContextLimit or autoModelContextLimit via /acp config \u2014 or restart \u2014 to re-probe)`
+          `billion-context-dsh: context-window auto-detection failed for ${provider}/${model} \u2014 using the ${DEFAULT_CONTEXT_WINDOW} fallback (change modelContextLimit or autoModelContextLimit via /acp-prune config \u2014 or restart \u2014 to re-probe)`
         );
         window = { limit: DEFAULT_CONTEXT_WINDOW, source: "default", provider, model, probeFailed: true };
         cap = null;
@@ -6435,6 +6569,81 @@ var AcpCompactionEngine = class extends CompactionEngine {
     if (cap === null || cap >= window.limit) return window;
     return { ...window, rawLimit: window.limit, outputReserved: cap, limit: window.limit - cap };
   }
+  /**
+   * Best-effort emergency compaction for one provider-confirmed context
+   * overflow: pick the largest eligible (guarded, tool-pairing-balanced)
+   * surface range and land the normal durable transaction with a fixed
+   * engine-written marker summary. No LLM call — the provider just rejected
+   * the request for being too large, so there is no model turn available to
+   * write a summary; the originals stay in the append-only log, so
+   * search_context still indexes them, decompress restores them, and the
+   * model can re-run the compress tool over the marker later to write a real
+   * summary. Returns null when nothing eligible exists (nothing to reclaim).
+   */
+  async compactForOverflow(agent, signal) {
+    signal.throwIfAborted();
+    const session = agent.session;
+    const state = this.store.stateFor(session);
+    const coreMessages = allLogMessages(session);
+    const surfaceMessages = eventsToCoreMessages(surfaceEventsOf(session));
+    const tokenCount = resolveTokenCount(agent, surfaceMessages);
+    const window = await this.windowFor(agent);
+    const config = kernelConfigFor({ ...this.env, modelContextLimit: window.limit });
+    const turn = this.kernel.processTurn({ messages: coreMessages, state, config, tokenCount, renderTags: "none" });
+    this.store.set(session, turn.state);
+    const byRaw = turn.state.messageRefs.byRaw;
+    let firstSeq;
+    let lastSeq;
+    for (const seq of session.surface.nodes) {
+      if (byRaw[String(seq)] === void 0) continue;
+      firstSeq ??= seq;
+      lastSeq = seq;
+    }
+    if (firstSeq === void 0 || lastSeq === void 0) return null;
+    const view = {
+      ranges: [{ startRef: byRaw[String(firstSeq)], endRef: byRaw[String(lastSeq)] }],
+      refs: { byRef: turn.state.messageRefs.byRef }
+    };
+    const ranges = buildCompressibleSeqRanges(session, view, {
+      preserveRecent: 5,
+      mediaPriceOf: meterMediaPriceResolver(agent, session)
+    });
+    if (ranges.length === 0) return null;
+    const best = ranges.reduce((largest, range) => range.tokens > largest.tokens ? range : largest);
+    const startRef = byRaw[String(best.start)];
+    const endRef = byRaw[String(best.end)];
+    if (startRef === void 0 || endRef === void 0) return null;
+    const summary = overflowMarkerSummary(best.count);
+    const applied = this.kernel.applyCompression({
+      ranges: [{ startRef, endRef, summary, topic: "context-overflow recovery" }],
+      messages: coreMessages,
+      state: turn.state,
+      config
+    });
+    if (applied.result.blocksCreated === 0) return null;
+    this.store.set(session, applied.state);
+    const previousIds = new Set(turn.state.blocks.map((block) => block.blockId));
+    const created = applied.state.blocks.find((block) => !previousIds.has(block.blockId));
+    if (created === void 0) return null;
+    const shadowed = shadowedSeqsOf(session, best.start, best.end);
+    if (shadowed.length === 0) return null;
+    const shadowedTokenCount = shadowedTokensViaMeter(session, shadowed, agent.ctx);
+    const { provider, model } = routeFor(agent);
+    runCompactionTransaction(session, {
+      start: best.start,
+      end: best.end,
+      shadowedSeqs: shadowed,
+      summary: [{ type: "text", text: summary }],
+      shadowedTokenCount,
+      provider,
+      model,
+      topic: "context-overflow recovery",
+      kernelBlockId: created.blockId,
+      directMessageIds: created.directMessageIds,
+      effectiveMessageIds: created.effectiveMessageIds
+    });
+    return { start: best.start, end: best.end, shadowedSeqs: shadowed, shadowedTokenCount };
+  }
   /** ACP is model-driven: automatic pressure policy never summarizes by itself. */
   async compactIfNeeded(_agent, _trigger, signal) {
     signal.throwIfAborted();