billion-context-dsh 0.1.5 → 0.1.7

package/README.en.md

@@ -3,7 +3,7 @@
 [English](./README.en.md) | [中文](./README.md)
 
 > **⚠️ Beta notice — not for production use**
-> This project (**v0.1.5**) is a work-in-progress beta. The [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) itself is also in **public beta**. **Do not use either in engineering / production environments** — expect breaking changes and rough edges.
+> This project (**v0.1.7**) is a work-in-progress beta. The [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) itself is also in **public beta**. **Do not use either in engineering / production environments** — expect breaking changes and rough edges.
 
 <p align="center">
 <strong>Built with gratitude on top of these projects</strong> — please give them a ⭐:
@@ -73,7 +73,7 @@ That's it. Then add a composition row where a compaction backend is expected —
     - id: compaction-acp
       name: 'billion-context-dsh'
       config:
-        modelContextLimit: 128000   # default; the pressure window
+        modelContextLimit: 128000   # optional; omit to auto-detect the model's real window (fallback 128000)
 ```
 
 **Per-mode — an agent preset's `compaction` realm.** First *disable (or delete) the realm's existing `dsh-compaction-basic` row*, then mount this engine — two backends cannot coexist in the same realm:
@@ -87,7 +87,7 @@ That's it. Then add a composition row where a compaction backend is expected —
 - id: compaction-acp
   name: 'billion-context-dsh'
   config:
-    modelContextLimit: 128000   # default; the pressure window
+    modelContextLimit: 128000   # optional; omit to auto-detect the model's real window (fallback 128000)
 ```
 
 > **One context manager per agent.** Two backends providing `ctx.compaction` collide — never run both in the same realm. Full install & verification guide: [docs/INSTALL.md](docs/INSTALL.md).
@@ -142,10 +142,11 @@ This project reuses `acp-kernel`'s compression core and `billion-context-pi`'s d
 
 | Key | Default | Meaning |
 |---|---|---|
-| `modelContextLimit` | `128000` | Context window used for the kernel's pressure decisions |
-| `nudgeMinContextLimitPct` | kernel default `0.45` | Nudge window lower bound (usage fraction) — same default as billion-context-pi |
-| `nudgeMaxContextLimitPct` | kernel default `0.75` | Over-limit line: above this the nudge fires regardless of growth |
-| `nudgeEmergencyThresholdPct` | kernel default `0.95` | Emergency nudge (bypasses the per-turn dedup) |
+| `modelContextLimit` | auto-detected (fallback `128000`) | Context window used for the kernel's pressure decisions; an explicit value wins and skips the probe |
+| `autoModelContextLimit` | `true` | Probe the model's real window from the model API (`agent.ctx.llm.resolveModelInfo`); fall back to the default on failure, `acp_status` shows the window source |
+| `nudgeMinContextLimitPct` | kernel default `0.45` | Nudge window lower bound (usage fraction) — validation only; the growth-driven trigger has no percentage floor — same default as billion-context-pi |
+| `nudgeMaxContextLimitPct` | engine default `0.70` (kernel/pi default `0.75`) | Over-limit line: above this the nudge fires regardless of growth — deliberately below the host compaction-basic 80% auto-compaction line so the forced nudge fires first; an explicit value wins |
+| `nudgeEmergencyThresholdPct` | engine default `0.85` (kernel/pi default `0.95`) | Emergency nudge (bypasses the per-turn dedup) — lowered from `0.95`: at 95% the model has no room to act and the 80% auto-compaction line shadows it; an explicit value wins |
 | `coreOverrides` | — | Any other acp-kernel `Config` override (billion-context-pi's `coreOverrides` escape hatch) |
 | `autoTools` | `true` | Register the four model tools on `ctx.tools` |
 | `autoCommand` | `true` | Register the `/acp` command on `ctx.commands` |

package/README.md

@@ -3,7 +3,7 @@
 [中文](./README.md) | [English](./README.en.md)
 
 > **⚠️ 测试版声明——请勿用于生产环境**
-> 本项目（**v0.1.5**）仍处于开发中的测试版。[DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 本身也处于**公开测试版**阶段。**请勿将两者用于工程化 / 生产环境**——预期会有破坏性变更与粗糙之处。
+> 本项目（**v0.1.7**）仍处于开发中的测试版。[DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 本身也处于**公开测试版**阶段。**请勿将两者用于工程化 / 生产环境**——预期会有破坏性变更与粗糙之处。
 
 <p align="center">
 <strong>衷心感谢以下项目——请给它们一个 ⭐：</strong>
@@ -75,7 +75,7 @@ npm install billion-context-dsh
     - id: compaction-acp
       name: 'billion-context-dsh'
       config:
-        modelContextLimit: 128000   # 默认；压力窗口
+        modelContextLimit: 128000   # 可选；省略时自动探测模型真实窗口（回退 128000）
 ```
 
 **单模式生效（agent preset 的 `compaction` realm）**。先在该 realm 内*禁用（或删除）原有的 `dsh-compaction-basic` 行*，再插入本引擎——同一 realm 内两个后端不能并存：
@@ -89,7 +89,7 @@ npm install billion-context-dsh
 - id: compaction-acp
   name: 'billion-context-dsh'
   config:
-    modelContextLimit: 128000   # 默认；压力窗口
+    modelContextLimit: 128000   # 可选；省略时自动探测模型真实窗口（回退 128000）
 ```
 
 > **每个 agent 只留一个上下文管理器。** 两个后端同时 provide `ctx.compaction` 会冲突——同一 realm 内切勿并存。完整安装与验证指南见 [docs/INSTALL.md](docs/INSTALL.md)。
@@ -144,10 +144,11 @@ DSH 的每个模型请求都派生自其 append-only 会话日志（*surface*）
 
 | 键 | 默认值 | 含义 |
 |---|---|---|
-| `modelContextLimit` | `128000` | 用于内核压力决策的上下文窗口 |
-| `nudgeMinContextLimitPct` | 内核默认 `0.45` | Nudge 窗口下界（用量占比）——与 billion-context-pi 相同的默认值 |
-| `nudgeMaxContextLimitPct` | 内核默认 `0.75` | 过限线：超过此值则无论增长与否都触发 nudge |
-| `nudgeEmergencyThresholdPct` | 内核默认 `0.95` | 紧急 nudge（绕过每轮去重） |
+| `modelContextLimit` | 自动探测（回退 `128000`） | 用于内核压力决策的上下文窗口；显式配置时优先且跳过探测 |
+| `autoModelContextLimit` | `true` | 从模型 API 自动探测真实窗口（`agent.ctx.llm.resolveModelInfo`）；探测失败回退默认值，`acp_status` 展示窗口来源 |
+| `nudgeMinContextLimitPct` | 内核默认 `0.45` | Nudge 窗口下界（用量占比）——仅作配置校验，增长路径的触发没有百分比下限——与 billion-context-pi 相同的默认值 |
+| `nudgeMaxContextLimitPct` | engine 默认 `0.70`（内核/pi 默认 `0.75`） | 过限线：超过此值则无论增长与否都触发 nudge——刻意低于宿主 compaction-basic 的 80% 自动压缩线，保证强制 nudge 先触发；显式配置优先 |
+| `nudgeEmergencyThresholdPct` | engine 默认 `0.85`（内核/pi 默认 `0.95`） | 紧急 nudge（绕过每轮去重）——从 `0.95` 下调：95% 时模型已无操作空间且会被 80% 自动压缩线遮蔽；显式配置优先 |
 | `coreOverrides` | — | 任何其他 acp-kernel `Config` 覆盖（billion-context-pi 的 `coreOverrides` 逃生口） |
 | `autoTools` | `true` | 在 `ctx.tools` 注册四个模型工具 |
 | `autoCommand` | `true` | 在 `ctx.commands` 注册 `/acp` 命令 |

package/dist/config.d.ts

@@ -7,15 +7,19 @@
  * growth ratio 5%, protected last messages 5). Every knob is optional — an
  * omitted value keeps the kernel default, so the behavior matches the Pi
  * adapter exactly unless a deployment opts out.
+ *
+ * NOTE: `AcpCompactionEngine` (src/index.ts) ships its own engine-level
+ * defaults 0.70/0.85 for the two nudge thresholds on top of this layer, so an
+ * engine with no explicit config lands on 0.70/0.85, not 0.75/0.95.
  * @module billion-context-dsh/config
  */
 import { type Config } from 'acp-kernel';
 /** The kernel-facing knobs shared by the nudge path and the compress tool. */
 export interface KernelConfigInput {
     readonly modelContextLimit: number;
-    /** Nudge window lower bound (usage fraction). Kernel default: 0.45. */
+    /** Nudge window lower bound (usage fraction; validation only — the growth-driven trigger has no percentage floor). Kernel default: 0.45. */
     readonly nudgeMinContextLimitPct?: number;
-    /** Nudge window upper bound — over-limit. Kernel default: 0.75. */
+    /** Nudge window upper bound — over-limit guarantee line. Kernel default: 0.75. */
     readonly nudgeMaxContextLimitPct?: number;
     /** Emergency nudge threshold (bypasses per-turn dedup). Kernel default: 0.95. */
     readonly nudgeEmergencyThresholdPct?: number;

package/dist/index.d.ts

@@ -28,23 +28,44 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { CompactionEngine, type CompactionAgentContext, type CompactionResult, type CompactionTrigger, type ManualCompactAgentContext } from '@deepseek-ai/dsh-compaction';
 import { type CompressionCore } from 'acp-kernel';
+import type { Agent } from '@deepseek-ai/dsh-agent';
 import { AcpStateStore } from './state.ts';
+import { type AcpWindow } from './window.ts';
 export { AcpStateStore } from './state.ts';
 export { kernelConfigFor, type KernelConfigInput } from './config.ts';
 export { ACP_SYSTEM_PROMPT, ACP_SYSTEM_PROMPT_ORDER } from './system-prompt.ts';
 export { makeTools, type ToolEnvironment } from './tools.ts';
 export { acpCommand } from './commands.ts';
 export { buildNudge, type NudgeEnvironment, type NudgeOutcome } from './nudge.ts';
-export { rebuildBlockLedger, resolveSurfaceRange, runCompactionTransaction, shadowedSeqsOf, findOpenTurn, assertNoActiveCompaction, blockRegistry, blockRefForSummarySeq, compactionIdsOfKernelBlocks, summarySeqOfKernelBlock, expandShadowedSeqs, type AcpBlockLedgerEntry, type CompactionTransactionInput, } from './region.ts';
+export { DEFAULT_CONTEXT_WINDOW, detectContextWindow, windowSourceLabel, type AcpWindow, } from './window.ts';
+export { AlreadyCompressedRangeError, rebuildBlockLedger, resolveSurfaceRange, runCompactionTransaction, shadowedSeqsOf, findOpenTurn, assertNoActiveCompaction, blockRegistry, blockRefForSummarySeq, compactionIdsOfKernelBlocks, summarySeqOfKernelBlock, expandShadowedSeqs, type AcpBlockLedgerEntry, type CompactionTransactionInput, type ResolvedSurfaceRange, } from './region.ts';
 export { eventsToCoreMessages, projectEvent, surfaceEventsOf, extractEventText } from './messages.ts';
 export interface AcpConfig {
-    /** The context window used for pressure decisions. Default 128000. */
-    readonly modelContextLimit: number;
-    /** Nudge window lower bound (usage fraction). Kernel default 0.45 — same as billion-context-pi. */
+    /**
+     * The context window used for pressure decisions, in tokens. When omitted,
+     * `autoModelContextLimit` (default true) probes the model's real window via
+     * `agent.ctx.llm.resolveModelInfo(provider, model)`; an explicit value
+     * always wins and disables the probe.
+     */
+    readonly modelContextLimit?: number;
+    /** Probe the model's real context window from the LLM runtime. Default true. */
+    readonly autoModelContextLimit: boolean;
+    /** Nudge window lower bound (usage fraction; validation only — the growth-driven trigger has no percentage floor). Kernel default 0.45 — same as billion-context-pi. */
     readonly nudgeMinContextLimitPct?: number;
-    /** Nudge window upper bound (over-limit). Kernel default 0.75 — same as billion-context-pi. */
+    /**
+     * Nudge window upper bound — over-limit guarantee line: above this the
+     * kernel injects a nudge regardless of growth or cadence. Engine default
+     * 0.70 (deliberately BELOW the kernel/billion-context-pi default 0.75 and
+     * the host compaction-basic auto-compaction line 0.80, so the forced nudge
+     * always fires first); an explicit value wins.
+     */
     readonly nudgeMaxContextLimitPct?: number;
-    /** Emergency nudge threshold (bypasses per-turn dedup). Kernel default 0.95 — same as billion-context-pi. */
+    /**
+     * Emergency nudge threshold (bypasses the per-turn dedup). Engine default
+     * 0.85 (down from the kernel/billion-context-pi default 0.95: 95% leaves
+     * the model no room to act before the API rejects, and the host's 80%
+     * compaction-basic line shadows it in standard/code/cordis modes).
+     */
     readonly nudgeEmergencyThresholdPct?: number;
     /** Any other acp-kernel Config override (billion-context-pi's `coreOverrides` escape hatch). */
     readonly coreOverrides?: Partial<import('acp-kernel').Config>;
@@ -69,7 +90,17 @@ export declare class AcpCompactionEngine extends CompactionEngine {
     /** Resolved engine configuration. */
     readonly config: AcpConfig;
     private readonly lastNudgeTurn;
+    /** Per provider/model route the resolved window (probe failures cached too). */
+    private readonly windowCache;
     constructor(ctx: Context, config?: Partial<AcpConfig>);
+    /**
+     * Resolve the effective context window for an agent. An explicitly
+     * configured `modelContextLimit` always wins (no probe). Otherwise probe the
+     * model's real window via `agent.ctx.llm.resolveModelInfo` (cached per
+     * provider/model route, probe failures cached too) and fall back to
+     * DEFAULT_CONTEXT_WINDOW when auto-detection is disabled or unavailable.
+     */
+    windowFor(agent: Agent): Promise<AcpWindow>;
     /** ACP is model-driven: automatic pressure policy never summarizes by itself. */
     compactIfNeeded(_agent: CompactionAgentContext, _trigger: CompactionTrigger, signal: AbortSignal): Promise<CompactionResult | null>;
     /** Explicit idle-session compaction: ACP leaves the decision to the model. */

package/dist/index.js

@@ -163,14 +163,61 @@ function hasPlainRef(session, seq) {
       return false;
   }
 }
+var AlreadyCompressedRangeError = class extends Error {
+  constructor(start, end, coveringBlockIds) {
+    super(
+      `billion-context-dsh: seq ${start}..${end} already compressed \u2014 no live content remains in that span`
+    );
+    this.start = start;
+    this.end = end;
+    this.coveringBlockIds = coveringBlockIds;
+    this.name = "AlreadyCompressedRangeError";
+  }
+  start;
+  end;
+  coveringBlockIds;
+};
+function recoverStaleRange(session, start, end) {
+  if (session.events[start] === void 0 || session.events[end] === void 0) {
+    const failedEdge = session.events[start] === void 0 ? start : end;
+    return { kind: "unresolvable", failedEdge };
+  }
+  const liveInside = session.surface.nodes.filter((seq) => seq >= start && seq <= end).sort((a, b) => a - b);
+  const plain = liveInside.filter((seq) => !isCheckpointNode(session.events[seq]));
+  if (plain.length === 0) {
+    const coveringBlockIds = rebuildBlockLedger(session.events).filter((entry) => entry.shadowedSeqs.some((seq) => seq >= start && seq <= end)).map((entry) => entry.blockId);
+    return { kind: "already-compressed", coveringBlockIds };
+  }
+  return { kind: "ok", start: plain[0], end: plain[plain.length - 1] };
+}
 function resolveSurfaceRange(session, start, end) {
   const nodes = session.surface.nodes;
-  const requestedStartIdx = nodes.indexOf(start);
-  const requestedEndIdx = nodes.indexOf(end);
+  if (start > end) {
+    throw new Error(`billion-context-dsh: reversed range ${start}..${end}`);
+  }
+  let requestedStartIdx = nodes.indexOf(start);
+  let requestedEndIdx = nodes.indexOf(end);
+  let recovered = false;
   if (requestedStartIdx < 0 || requestedEndIdx < 0) {
-    throw new Error(
-      `billion-context-dsh: seq ${start}..${end} not in the current surface \u2014 surface seqs are sparse message nodes (only user/message, assistant/message, tool/result events); consult acp_status for the current surface range`
-    );
+    const stale = recoverStaleRange(session, start, end);
+    if (stale.kind === "unresolvable") {
+      throw new Error(
+        `billion-context-dsh: seq ${start}..${end} not in the current surface \u2014 edge seq ${stale.failedEdge} is not in this session's log. Surface seqs are sparse message nodes (only user/message, assistant/message, tool/result events); consult acp_status for the current surface range`
+      );
+    }
+    if (stale.kind === "already-compressed") {
+      throw new AlreadyCompressedRangeError(start, end, stale.coveringBlockIds);
+    }
+    start = stale.start;
+    end = stale.end;
+    recovered = true;
+    requestedStartIdx = nodes.indexOf(start);
+    requestedEndIdx = nodes.indexOf(end);
+    if (requestedStartIdx < 0 || requestedEndIdx < 0) {
+      throw new Error(
+        `billion-context-dsh: seq ${start}..${end} not in the current surface \u2014 consult acp_status for the current surface range`
+      );
+    }
   }
   if (requestedStartIdx > requestedEndIdx) {
     throw new Error(`billion-context-dsh: reversed range ${start}..${end}`);
@@ -189,7 +236,12 @@ function resolveSurfaceRange(session, start, end) {
     endIdx -= 1;
   }
   if (startIdx <= endIdx && nodes[startIdx] <= nodes[endIdx]) {
-    return { start: nodes[startIdx], end: nodes[endIdx] };
+    return recovered ? { start: nodes[startIdx], end: nodes[endIdx], recovered: true } : { start: nodes[startIdx], end: nodes[endIdx] };
+  }
+  if (recovered) {
+    throw new Error(
+      `billion-context-dsh: no tool-pairing-balanced live remainder around seq ${start}..${end} \u2014 narrow the range or consult acp_status for the current surface`
+    );
   }
   startIdx = requestedStartIdx;
   endIdx = requestedEndIdx;
@@ -528,6 +580,28 @@ function kernelConfigFor(input) {
   return defaultConfig(input.modelContextLimit, overrides);
 }
 
+// src/window.ts
+var DEFAULT_CONTEXT_WINDOW = 128e3;
+function windowSourceLabel(window) {
+  if (window.source === "explicit") return "configured";
+  if (window.source === "auto") {
+    return `auto-detected from ${window.provider ?? "?"}/${window.model ?? "?"}`;
+  }
+  return "default (auto-detection unavailable)";
+}
+async function detectContextWindow(agent, provider, model) {
+  const llm = agent.ctx?.get?.("llm");
+  if (llm?.resolveModelInfo === void 0) return null;
+  try {
+    const info = await llm.resolveModelInfo(provider, model);
+    const window = info?.context?.contextWindow;
+    if (typeof window === "number" && Number.isInteger(window) && window > 0) return window;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 // src/tools.ts
 function textOutput() {
   return {
@@ -592,30 +666,51 @@ async function handleCompress(env, args, exec) {
   const turn = env.kernel.processTurn({ messages: coreMessages, state, config, tokenCount });
   env.store.set(session, turn.state);
   const byRaw = turn.state.messageRefs.byRaw;
-  const ranges = args.content.map((range) => {
+  const ranges = [];
+  const alreadyCompressedNotes = [];
+  for (const range of args.content) {
     const startSeq = parseSeq(range.startSeq);
     const endSeq = parseSeq(range.endSeq);
-    const { start, end } = resolveSurfaceRange(session, startSeq, endSeq);
-    const startBlockRef = blockRefForSummarySeq(session, start);
-    const endBlockRef = blockRefForSummarySeq(session, end);
-    const startRef = startBlockRef ?? byRaw[String(start)];
-    const endRef = endBlockRef ?? byRaw[String(end)];
+    let resolved;
+    try {
+      resolved = resolveSurfaceRange(session, startSeq, endSeq);
+    } catch (error) {
+      if (error instanceof AlreadyCompressedRangeError) {
+        const covering = error.coveringBlockIds;
+        const blockNote = covering.length === 0 ? "" : ` (block ${covering[0].slice(0, 8)}${covering.length > 1 ? ` +${covering.length - 1} more` : ""})`;
+        alreadyCompressedNotes.push(
+          `  seqs ${error.start}..${error.end} already compressed${blockNote} \u2014 nothing to reclaim; decompress to recover the originals`
+        );
+        continue;
+      }
+      throw error;
+    }
+    const startBlockRef = blockRefForSummarySeq(session, resolved.start);
+    const endBlockRef = blockRefForSummarySeq(session, resolved.end);
+    const startRef = startBlockRef ?? byRaw[String(resolved.start)];
+    const endRef = endBlockRef ?? byRaw[String(resolved.end)];
     if (startRef === void 0 || endRef === void 0) {
       throw new Error(
-        `billion-context-dsh: seq ${start}..${end} has no assigned ref \u2014 the range must be on the current surface (run acp_status for the live seq list)`
+        `billion-context-dsh: seq ${resolved.start}..${resolved.end} has no assigned ref \u2014 the range must be on the current surface (run acp_status for the live seq list)`
       );
     }
-    return {
+    ranges.push({
+      ...resolved,
       startSeq,
       endSeq,
-      start,
-      end,
       startRef,
       endRef,
       summary: range.summary,
       ...(range.topic ?? args.topic) === void 0 ? {} : { topic: range.topic ?? args.topic }
-    };
-  });
+    });
+  }
+  if (ranges.length === 0) {
+    const text = ["Compressed 0 block(s), ~0 tokens reclaimed.", ...alreadyCompressedNotes];
+    if (alreadyCompressedNotes.length > 0) {
+      text.push("  (all requested ranges were already compressed \u2014 decompress a block to recover its originals)");
+    }
+    return { text: text.join("\n") };
+  }
   const applied = env.kernel.applyCompression({
     ranges: ranges.map(({ startRef, endRef, summary, topic }) => ({ startRef, endRef, summary, topic })),
     messages: coreMessages,
@@ -648,9 +743,7 @@ async function handleCompress(env, args, exec) {
   }
   const lines = [];
   let skippedRanges = 0;
-  for (let index = 0; index < ranges.length; index += 1) {
-    const range = ranges[index];
-    const original = args.content[index];
+  for (const range of ranges) {
     const key = `${range.startRef}::${range.endRef}`;
     const block = blockByRangeKey.get(key);
     if (block === void 0) {
@@ -672,7 +765,7 @@ async function handleCompress(env, args, exec) {
       start,
       end,
       shadowedSeqs: shadowed,
-      summary: [{ type: "text", text: original.summary }],
+      summary: [{ type: "text", text: range.summary }],
       shadowedTokenCount: shadowedTokens,
       provider: agent.options.provider ?? "",
       model: agent.options.model ?? "",
@@ -687,13 +780,15 @@ async function handleCompress(env, args, exec) {
     });
     const adjusted = start !== range.startSeq || end !== range.endSeq;
     const tierLabel = tier === 1 ? "" : `, tier ${tier}`;
+    const note = range.recovered === true ? ` (seqs ${range.startSeq}..${range.endSeq} were already shadowed \u2014 compressed the live remainder ${start}..${end})` : adjusted ? ` (adjusted from ${range.startSeq}..${range.endSeq} to balanced edges)` : "";
     lines.push(
-      `  block ${compactionId.slice(0, 8)}: seqs ${start}..${end}, ${shadowed.length} messages shadowed${tierLabel}` + (adjusted ? ` (adjusted from ${range.startSeq}..${range.endSeq} to balanced edges)` : "")
+      `  block ${compactionId.slice(0, 8)}: seqs ${start}..${end}, ${shadowed.length} messages shadowed${tierLabel}${note}`
     );
   }
   const summaryLine = `Compressed ${applied.result.blocksCreated} block(s), ~${applied.result.tokensCompressed} tokens reclaimed.`;
-  const warningLines = [...freeWarnings.map((warning) => `  ${warning}`), ...lines];
-  const footer = skippedRanges > 0 ? `  (${skippedRanges} range(s) skipped \u2014 see warnings above)` : "";
+  const totalSkipped = skippedRanges + alreadyCompressedNotes.length;
+  const warningLines = [...freeWarnings.map((warning) => `  ${warning}`), ...alreadyCompressedNotes, ...lines];
+  const footer = totalSkipped > 0 ? `  (${totalSkipped} range(s) skipped \u2014 see warnings above)` : "";
   return { text: `${summaryLine}
 ${[...warningLines, footer].filter((line) => line !== "").join("\n")}` };
 }
@@ -746,18 +841,21 @@ ${original}`.toLowerCase();
   };
 }
 var statusParameters = {};
-function handleStatus(env, _args, exec) {
-  const session = requireAgent(exec).session;
+async function handleStatus(env, _args, exec) {
+  const agent = requireAgent(exec);
+  const session = agent.session;
   const ledger = rebuildBlockLedger(session.events);
   const totalTokens = ledger.reduce((sum, block) => sum + block.shadowedTokenCount, 0);
   const coreMessages = eventsToCoreMessages(surfaceEventsOf(session));
   const estimated = coreMessages.reduce((sum, message) => sum + defaultCountTokens2(message.text ?? ""), 0);
-  const limit = env.modelContextLimit;
+  const window = env.windowFor === void 0 ? { limit: env.modelContextLimit, source: "explicit" } : await env.windowFor(agent);
+  const limit = window.limit;
   const lines = [
     `ACP status \u2014 session ${session.id}`,
     `  blocks: ${ledger.length}`,
     `  tokens compressed: ${totalTokens}`,
     `  estimated context: ${estimated} / ${limit} (${Math.round(estimated / limit * 100)}%)`,
+    `  context window: ${limit} (${windowSourceLabel(window)})`,
     `  surface: ${surfaceSummary(session)}`
   ];
   for (const block of ledger.slice(0, 10)) {
@@ -769,7 +867,7 @@ function makeTools(env) {
   return [
     defineTool({
       name: "compress",
-      description: "Replace older conversation ranges with dense summaries you write. Each message seq is a surface reference. Single range: compress({ content: [{ startSeq, endSeq, summary }] }). Batch multiple unrelated ranges in one call (each content entry becomes its own block); keep ranges disjoint. Never compress content the current step is actively using.",
+      description: "Replace older conversation ranges with dense summaries you write. Each message seq is a surface reference. Single range: compress({ content: [{ startSeq, endSeq, summary }] }). Batch multiple unrelated ranges in one call (each content entry becomes its own block); keep ranges disjoint. Never compress content the current step is actively using. Seq refs must come from the CURRENT surface (acp_status or the latest nudge): a span whose edges were shadowed by an earlier compress is auto-remapped to its still-live content, a fully compressed span is reported as already compressed, and invented/other-session seqs fail with guidance.",
       parameters: compressParameters,
       output: textOutput(),
       async execute(args, exec) {
@@ -800,7 +898,7 @@ function makeTools(env) {
       parameters: statusParameters,
       output: textOutput(),
       execute(args, exec) {
-        return Promise.resolve(handleStatus(env, args, exec));
+        return handleStatus(env, args, exec);
       }
     })
   ];
@@ -808,18 +906,20 @@ function makeTools(env) {
 
 // src/commands.ts
 import { defaultCountTokens as defaultCountTokens3 } from "acp-kernel";
-function statusText(env, agent) {
+async function statusText(env, agent) {
   const session = agent.session;
   const ledger = rebuildBlockLedger(session.events);
   const totalTokens = ledger.reduce((sum, block) => sum + block.shadowedTokenCount, 0);
   const coreMessages = eventsToCoreMessages(surfaceEventsOf(session));
   const estimated = coreMessages.reduce((sum, message) => sum + defaultCountTokens3(message.text ?? ""), 0);
-  const limit = env.modelContextLimit;
+  const window = env.windowFor === void 0 ? { limit: env.modelContextLimit, source: "explicit" } : await env.windowFor(agent);
+  const limit = window.limit;
   const lines = [
     `ACP status \u2014 session ${session.id}`,
     `  blocks: ${ledger.length}`,
     `  tokens compressed: ${totalTokens}`,
-    `  estimated context: ${estimated} / ${limit} (${Math.round(estimated / limit * 100)}%)`
+    `  estimated context: ${estimated} / ${limit} (${Math.round(estimated / limit * 100)}%)`,
+    `  context window: ${limit} (${windowSourceLabel(window)})`
   ];
   for (const block of ledger.slice(0, 10)) {
     const tier = block.tier > 1 ? ` [T${block.tier}]` : "";
@@ -877,7 +977,7 @@ function acpCommand(env) {
     handler: async (invocation) => {
       const raw = invocation.rawInput.trim();
       if (raw === "" || raw === "status") {
-        return { kind: "success", text: statusText(env, invocation.agent) };
+        return { kind: "success", text: await statusText(env, invocation.agent) };
       }
       if (raw.startsWith("compress")) {
         return { kind: "success", text: compressText(env, invocation.agent, raw.slice("compress".length).trim().split(/\s+/)) };
@@ -904,7 +1004,8 @@ function rangeTable(session) {
     `Surface: ${surfaceSummary(session)}`,
     "Compressible ranges (suggestions only \u2014 compress any consumed span; refs are surface seqs):",
     ...lines,
-    "Compress with: compress({ content: [{ startSeq, endSeq, summary }] }) \u2014 content is an array: batch multiple unrelated segments in one call, each entry its own block. Keep ranges disjoint."
+    "Compress with: compress({ content: [{ startSeq, endSeq, summary }] }) \u2014 content is an array: batch multiple unrelated segments in one call, each entry its own block. Keep ranges disjoint.",
+    "Snapshot taken at nudge time: the seqs go stale once the surface moves (a later compress shadows them), so re-run acp_status for fresh refs before compressing."
   ].join("\n");
 }
 function measuredTokenCount(agent, coreMessages) {
@@ -963,10 +1064,10 @@ YOU decide whether and when to compress context. Nothing forces you: the injecte
 ${COMPRESS_PHILOSOPHY}
 
 Compression tools (refs are SURFACE SEQS, not ids):
-- compress: replace one or more seq ranges, each with your own dense summary. Single range: compress({ content: [{ startSeq, endSeq, summary }] }). Batch multiple unrelated segments in one call (each entry becomes its own block): compress({ content: [{ startSeq: 1, endSeq: 5, summary: '...' }, { startSeq: 12, endSeq: 18, summary: '...' }] }). Keep ranges disjoint \u2014 overlapping entries in one batch are skipped. Edges are auto-balanced to tool-call/result boundaries; a trailing #callId fragment in a seq is ignored. Ranges must be on the current surface \u2014 stale seqs fail with guidance.
+- compress: replace one or more seq ranges, each with your own dense summary. Single range: compress({ content: [{ startSeq, endSeq, summary }] }). Batch multiple unrelated segments in one call (each entry becomes its own block): compress({ content: [{ startSeq: 1, endSeq: 5, summary: '...' }, { startSeq: 12, endSeq: 18, summary: '...' }] }). Keep ranges disjoint \u2014 overlapping entries in one batch are skipped. Edges are auto-balanced to tool-call/result boundaries; a trailing #callId fragment in a seq is ignored. Seq refs must be on the current surface: seqs from older nudges or earlier compresses go stale as the surface moves, so a stale span is auto-remapped to its still-live remainder (the result reports the adjusted span), a fully compressed span is reported as already compressed, and invented/other-session seqs fail with guidance.
 - decompress: recover a compressed block's original content, read-only. decompress({ blockId }).
 - search_context: find information inside compressed blocks BEFORE decompressing. search_context({ query }).
-- acp_status: current context usage and the live compressible-range list. Run it before compressing when in doubt.
+- acp_status: current context usage and the live compressible-range list. Run it right before compressing \u2014 the only seqs that never go stale are the ones you just read.
 
 Tiered compression: each compressed block appears on the surface as one summary node. Compressing that node again DISTILLS the block (tier 2): the parent summary folds into your new summary and the original messages are freed. Distilling a tier-2 block yields tier 3. Distill when a summary itself is consumed \u2014 decompress on the tier-2 block recovers the full originals.
 
@@ -975,10 +1076,17 @@ var ACP_SYSTEM_PROMPT_ORDER = 150;
 
 // src/index.ts
 var DEFAULT_CONFIG = {
-  modelContextLimit: 128e3,
+  autoModelContextLimit: true,
   autoTools: true,
   autoCommand: true,
-  autoNudge: true
+  autoNudge: true,
+  // 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
+  // 0.80) shadows it in standard/code/cordis modes; 0.70 keeps the forced
+  // over-limit nudge ahead of that 80% line. Explicit values always win.
+  nudgeMaxContextLimitPct: 0.7,
+  nudgeEmergencyThresholdPct: 0.85
 };
 function resolveAcpConfig(config = {}) {
   return { ...DEFAULT_CONFIG, ...config };
@@ -991,6 +1099,8 @@ var AcpCompactionEngine = class extends CompactionEngine {
   /** Resolved engine configuration. */
   config;
   lastNudgeTurn = /* @__PURE__ */ new Map();
+  /** Per provider/model route the resolved window (probe failures cached too). */
+  windowCache = /* @__PURE__ */ new Map();
   constructor(ctx, config = {}) {
     super(ctx);
     this.config = resolveAcpConfig(config);
@@ -999,11 +1109,13 @@ var AcpCompactionEngine = class extends CompactionEngine {
     const env = {
       kernel: this.kernel,
       store: this.store,
-      modelContextLimit: this.config.modelContextLimit,
+      // Initial value before any probe; windowFor() replaces it per pre-step.
+      modelContextLimit: this.config.modelContextLimit ?? DEFAULT_CONTEXT_WINDOW,
       nudgeMinContextLimitPct: this.config.nudgeMinContextLimitPct,
       nudgeMaxContextLimitPct: this.config.nudgeMaxContextLimitPct,
       nudgeEmergencyThresholdPct: this.config.nudgeEmergencyThresholdPct,
-      coreOverrides: this.config.coreOverrides
+      coreOverrides: this.config.coreOverrides,
+      windowFor: (agent) => this.windowFor(agent)
     };
     const tools = ctx.get("tools");
     if (tools !== void 0) {
@@ -1041,7 +1153,8 @@ var AcpCompactionEngine = class extends CompactionEngine {
       ctx.on("agent/pre-step", async (payload, next) => {
         const decision = await next();
         if (decision.kind === "reject") return decision;
-        const outcome = buildNudge(payload.agent, env, this.lastNudgeTurn);
+        const window = await this.windowFor(payload.agent);
+        const outcome = buildNudge(payload.agent, { ...env, modelContextLimit: window.limit }, this.lastNudgeTurn);
         if (outcome === null) return decision;
         return { kind: "enter", messages: [...decision.messages, outcome.message] };
       });
@@ -1055,6 +1168,32 @@ var AcpCompactionEngine = class extends CompactionEngine {
       });
     }
   }
+  /**
+   * Resolve the effective context window for an agent. An explicitly
+   * configured `modelContextLimit` always wins (no probe). Otherwise probe the
+   * model's real window via `agent.ctx.llm.resolveModelInfo` (cached per
+   * provider/model route, probe failures cached too) and fall back to
+   * DEFAULT_CONTEXT_WINDOW when auto-detection is disabled or unavailable.
+   */
+  async windowFor(agent) {
+    if (this.config.modelContextLimit !== void 0) {
+      return { limit: this.config.modelContextLimit, source: "explicit" };
+    }
+    const provider = agent.options.provider ?? "";
+    const model = agent.options.model ?? "";
+    const key = `${provider}\0${model}`;
+    const cached = this.windowCache.get(key);
+    if (cached !== void 0) return cached;
+    let window;
+    if (!this.config.autoModelContextLimit) {
+      window = { limit: DEFAULT_CONTEXT_WINDOW, source: "default", provider, model };
+    } else {
+      const detected = await detectContextWindow(agent, provider, model);
+      window = detected === null ? { limit: DEFAULT_CONTEXT_WINDOW, source: "default", provider, model } : { limit: detected, source: "auto", provider, model };
+    }
+    this.windowCache.set(key, window);
+    return window;
+  }
   /** ACP is model-driven: automatic pressure policy never summarizes by itself. */
   async compactIfNeeded(_agent, _trigger, signal) {
     signal.throwIfAborted();
@@ -1084,6 +1223,8 @@ export {
   ACP_SYSTEM_PROMPT_ORDER,
   AcpCompactionEngine,
   AcpStateStore,
+  AlreadyCompressedRangeError,
+  DEFAULT_CONTEXT_WINDOW,
   acpCommand,
   assertNoActiveCompaction,
   blockRefForSummarySeq,
@@ -1091,6 +1232,7 @@ export {
   buildNudge,
   compactionIdsOfKernelBlocks,
   index_default as default,
+  detectContextWindow,
   eventsToCoreMessages,
   expandShadowedSeqs,
   extractEventText,
@@ -1104,6 +1246,7 @@ export {
   runCompactionTransaction,
   shadowedSeqsOf,
   summarySeqOfKernelBlock,
-  surfaceEventsOf
+  surfaceEventsOf,
+  windowSourceLabel
 };
 //# sourceMappingURL=index.js.map