billion-context-dsh 0.2.2 → 0.2.3

package/README.en.md

@@ -3,7 +3,7 @@
 [English](./README.en.md) | [中文](./README.md)
 
 > **⚠️ Beta notice — not for production use**
-> This project (**v0.2.2**) 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.2.3**) 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 ⭐:
@@ -41,10 +41,11 @@ When conversations get long, the model runs out of context. Most tools hard-trun
 
 Unlike DSH's built-in auto-compaction (which replaces a range with an automatically generated summary), billion-context-dsh:
 
-- **Model-driven** — the model writes the summary itself; there is no second LLM summarization call (the ACP cost win)
+- **Model-driven** — the model writes the summary itself; there is no second LLM summarization call
 - **Advisory, never imperative** — automatic policy only *nudges*; the model decides whether and when to compress
 - **Durable & recoverable** — a compressed range becomes a checkpoint node, the originals stay in the append-only session log; `decompress` restores them, `search_context` finds information inside blocks
-- **Seq-based refs** — no message tags; surface seqs are carried by the nudge's range table, with auto-balanced range edges and `#callId` tolerance
+- **Long tasks hold steady** — every step builds on the results before it; key conclusions stay usable and compound, so very long tasks actually finish
+- **Context stays lean** — every request rides on a small, distilled slice of context with only the key information; no bulk compression of large ranges, so details don't decay with it — and tokens stay low
 
 This is the DeepSeek Harness port of [billion-context-pi](https://github.com/ranxianglei/billion-context-pi) (the Pi coding-agent adapter): the compression core ([acp-kernel](https://github.com/ranxianglei/acp-kernel)) is reused verbatim, and the adapter layer was rewritten against DSH's durable-surface model — see [docs](https://github.com/Tyan66666/billion-context-dsh/tree/main/docs) for the verified mapping.
 
@@ -129,7 +130,7 @@ DSH derives every model request from its append-only session log (the *surface*)
 | nudge ("efficiency note — compress early and keep context lean") | injected at `agent/pre-step` by the kernel's pressure decision — efficiency note + context breakdown + compression rules, tone aligned with kernel/pi; never an order |
 | `decompress` | read-only recovery of shadowed originals from the log |
 | `search_context` | scores block summaries + originals rebuilt from the log |
-| `acp_status` | block ledger + context pressure |
+| `acp_status` | CONTEXT BREAKDOWN (tool/text/summaries shares of the visible total) + compressed-block ledger + nudge decision line; no context-window rows; scope/view/tool/sort/limit drilldown supported |
 | block state | in-memory kernel state + **log-rebuilt ledger** (no sidecar files) |
 | tiered distillation (T2/T3) | re-compressing a block's summary node distills that block (tier 2); distilling a tier-2 block yields tier 3. Tier + kernel block ids are persisted to the log, so kernel state rehydrates from the log after a restart and stays distillable |
 
@@ -146,9 +147,9 @@ A walkthrough of the ACP philosophy this project inherits — how active context
 | Tool | What it does |
 | --- | --- |
 | `compress` | Replace a seq range with a dense summary you write (edges auto-balanced to tool-pair boundaries); re-compressing a block's summary node distills it (tier 2/3) |
-| `decompress` | Restore a previously compressed block's original content (read-only) |
+| `decompress` | Restore a previously compressed block's original content (read-only); accepts the `bN` ref shown by acp_status or a compaction id |
 | `search_context` | Search compressed block summaries and originals by keyword |
-| `acp_status` | Context usage, compressed blocks, compressible ranges |
+| `acp_status` | CONTEXT BREAKDOWN (tool/text/summaries shares of the visible total) + compressed-block ledger + nudge decision line; no context-window rows. Drilldown supported: `scope:"compressed"` per block, `scope:"uncompressed"` + `view:"messages"`/`"ranges"` per message/range, with `tool` filter, `sort` order and `limit` cap. Drilldown row refs are kernel ids (mN, size awareness only) — compress always uses the `Surface:` seqs |
 | `/acp` | status / compress / decompress from the command bar |
 
 ## Upstream & credits
@@ -169,7 +170,7 @@ This project reuses `acp-kernel`'s compression core and `billion-context-pi`'s d
 | Key | Default | Meaning |
 |---|---|---|
 | `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 |
+| `autoModelContextLimit` | `true` | Probe the model's real window from the model API (`agent.ctx.llm.resolveModelInfo`); fall back to the default on failure, the `/acp` command shows the window source (the `acp_status` model tool carries no window info) |
 | `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 |

package/README.md

@@ -3,7 +3,7 @@
 [中文](./README.md) | [English](./README.en.md)
 
 > **⚠️ 测试版声明——请勿用于生产环境**
-> 本项目（**v0.2.2**）仍处于开发中的测试版。[DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 本身也处于**公开测试版**阶段。**请勿将两者用于工程化 / 生产环境**——预期会有破坏性变更与粗糙之处。
+> 本项目（**v0.2.3**）仍处于开发中的测试版。[DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 本身也处于**公开测试版**阶段。**请勿将两者用于工程化 / 生产环境**——预期会有破坏性变更与粗糙之处。
 
 <p align="center">
 <strong>衷心感谢以下项目——请给它们一个 ⭐：</strong>
@@ -41,10 +41,11 @@
 
 与 DSH 内置的自动压缩（用自动生成的摘要替换一段范围）不同，billion-context-dsh：
 
-- **模型驱动** —— 摘要由模型自己书写，没有第二次 LLM 摘要调用（ACP 的成本优势）
+- **模型驱动** —— 摘要由模型自己书写，没有第二次 LLM 摘要调用
 - **只建议、不强令** —— 自动策略只 *nudge*（提醒），是否压缩、何时压缩由模型决定
 - **持久且可恢复** —— 压缩范围成为 checkpoint 节点，原文保留在 append-only 会话日志中；`decompress` 可恢复，`search_context` 可在块内查找
-- **基于 seq 引用** —— 不需要消息标签；surface seq 由 nudge 的范围表携带，范围边界自动平衡、容忍 `#callId` 片段
+- **长任务稳得住** —— 每一步都接着前面的成果走，关键结论持续可用、不断叠加，超长任务更容易跑完
+- **上下文始终精简** —— 每次请求都只用少量、精炼的上下文，只保留关键信息；不做大段统一压缩，细节不随之衰失，token 消耗自然更低
 
 这是 [billion-context-pi](https://github.com/ranxianglei/billion-context-pi)（Pi 编码代理适配器）在 DeepSeek Harness 上的移植：压缩内核（[acp-kernel](https://github.com/ranxianglei/acp-kernel)）原样复用，适配层针对 DSH 的 durable-surface 模型重写——经过验证的映射关系见 [docs](https://github.com/Tyan66666/billion-context-dsh/tree/main/docs)。
 
@@ -130,7 +131,7 @@ DSH 的每个模型请求都派生自其 append-only 会话日志（*surface*）
 | nudge（"效率提示——尽早压缩保持精简"） | 由内核的压力决策在 `agent/pre-step` 注入——效率通知 + 上下文分解 + 压缩规则，语气对齐 kernel/pi；绝非命令 |
 | `decompress` | 从日志只读恢复被遮蔽的原文 |
 | `search_context` | 对从日志重建的块摘要与原文打分 |
-| `acp_status` | 块账本与上下文压力 |
+| `acp_status` | CONTEXT BREAKDOWN（tool/text/summaries 占可见总量）+ 压缩块账本 + nudge 决策行；不含上下文窗口；支持 scope/view/tool/sort/limit 钻取 |
 | 块状态 | 内存内核状态 + **日志重建账本**（无旁车文件） |
 | 分层蒸馏（T2/T3） | 再次压缩某块的摘要节点 = 蒸馏该块（tier 2），蒸馏 tier-2 块得 tier 3；tier 与内核块 id 持久化进日志，重启后内核状态从日志再水合、可继续蒸馏 |
 
@@ -147,9 +148,9 @@ DSH 的每个模型请求都派生自其 append-only 会话日志（*surface*）
 | 工具 | 作用 |
 | --- | --- |
 | `compress` | 用你书写的紧凑摘要替换 seq 范围（边界自动平衡到 tool-call/result 配对点）；对某块的摘要节点再次压缩 = 分层蒸馏（tier 2/3） |
-| `decompress` | 恢复已压缩块的原始内容（只读） |
+| `decompress` | 恢复已压缩块的原始内容（只读）；接受 acp_status 显示的 `bN` 或 compaction id |
 | `search_context` | 按关键词搜索压缩块摘要与原文 |
-| `acp_status` | 上下文占用、压缩块、可压缩范围 |
+| `acp_status` | CONTEXT BREAKDOWN（tool/text/summaries 占可见总量）+ 压缩块账本 + nudge 决策行；不含上下文窗口。支持钻取：`scope:"compressed"` 逐块、`scope:"uncompressed"` + `view:"messages"`/`"ranges"` 逐消息/区间，`tool` 过滤、`sort` 排序、`limit` 截断。钻取行 ref 是内核 mN（仅供体量感知）——压缩始终用 `Surface:` 的 seq |
 | `/acp` | 从命令栏执行 status / compress / decompress |
 
 ## 上游项目与致谢
@@ -170,7 +171,7 @@ DSH 的每个模型请求都派生自其 append-only 会话日志（*surface*）
 | 键 | 默认值 | 含义 |
 |---|---|---|
 | `modelContextLimit` | 自动探测（回退 `128000`） | 用于内核压力决策的上下文窗口；显式配置时优先且跳过探测 |
-| `autoModelContextLimit` | `true` | 从模型 API 自动探测真实窗口（`agent.ctx.llm.resolveModelInfo`）；探测失败回退默认值，`acp_status` 展示窗口来源 |
+| `autoModelContextLimit` | `true` | 从模型 API 自动探测真实窗口（`agent.ctx.llm.resolveModelInfo`）；探测失败回退默认值，`/acp` 命令展示窗口来源（模型工具 `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% 自动压缩线遮蔽；显式配置优先 |

package/dist/index.js

@@ -48,7 +48,29 @@ function stringifyArgs(args) {
     return String(args);
   }
 }
-function projectEvent(event) {
+function toolCallIdOfResultEvent(event) {
+  if (event.type !== "tool/result") return null;
+  const message = event.data.message;
+  const block = Array.isArray(message?.content) ? message.content.find((candidate) => candidate?.type === "tool-result") : void 0;
+  const id = block?.toolCallId ?? message?.source?.callId;
+  return typeof id === "string" ? id : null;
+}
+function buildToolCallIndex(events) {
+  const index = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== "assistant/message") continue;
+    const content = event.data.message?.content;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      const candidate = block;
+      if (candidate !== null && typeof candidate === "object" && candidate.type === "tool-call" && typeof candidate.id === "string") {
+        index.set(candidate.id, typeof candidate.name === "string" ? candidate.name : "");
+      }
+    }
+  }
+  return index;
+}
+function projectEvent(event, toolNames) {
   switch (event.type) {
     case "user/message": {
       const text = extractText(event.data.content);
@@ -88,12 +110,13 @@ ${argStr}` : argStr || text;
       const message = event.data.message;
       const text = extractText(message?.content);
       if (text.length === 0) return [];
+      const key = toolCallIdOfResultEvent(event);
       return [{
         id: String(event.seq),
         role: "tool",
         contentType: "tool-result",
-        toolName: message?.toolName ?? "",
-        toolCallId: message?.toolCallId ?? "",
+        toolName: toolNames?.get(key ?? "") ?? "",
+        toolCallId: message?.toolCallId ?? key ?? "",
         text
       }];
     }
@@ -101,9 +124,10 @@ ${argStr}` : argStr || text;
       return [];
   }
 }
-function eventsToCoreMessages(events) {
+function eventsToCoreMessages(events, toolNames) {
+  const index = toolNames ?? buildToolCallIndex(events);
   const out = [];
-  for (const event of events) out.push(...projectEvent(event));
+  for (const event of events) out.push(...projectEvent(event, index));
   return out;
 }
 function surfaceEventsOf(session) {
@@ -359,13 +383,6 @@ function toolCallIdsOfEvent(event) {
   }
   return ids;
 }
-function toolCallIdOfResultEvent(event) {
-  if (event.type !== "tool/result") return null;
-  const message = event.data.message;
-  const block = Array.isArray(message?.content) ? message.content.find((candidate) => candidate?.type === "tool-result") : void 0;
-  const id = block?.toolCallId ?? message?.source?.callId;
-  return typeof id === "string" ? id : null;
-}
 function assistantProviderModel(event) {
   if (event.type === "assistant/message") {
     const message = event.data.message;
@@ -588,8 +605,12 @@ function buildCompressibleSeqRanges(session, opts = {}) {
 function surfaceSummary(session) {
   const nodes = session.surface.nodes;
   if (nodes.length === 0) return "empty";
-  const first = nodes[0];
-  const last = nodes[nodes.length - 1];
+  let first = nodes[0];
+  let last = nodes[0];
+  for (const seq of nodes) {
+    if (seq < first) first = seq;
+    if (seq > last) last = seq;
+  }
   return `${nodes.length} nodes, seqs ${first}..${last}`;
 }
 function blockRegistry(session) {
@@ -640,6 +661,11 @@ function compactionIdsOfKernelBlocks(session, kernelBlockIds) {
   const byKernel = new Map(blockRegistry(session).map((r) => [r.kernelBlockId, r.blockId]));
   return kernelBlockIds.map((id) => byKernel.get(id)).filter((id) => id !== void 0);
 }
+function blockIdOfKernelRef(session, kernelRef) {
+  if (!/^b\d+$/.test(kernelRef)) return null;
+  const entry = blockRegistry(session).find((r) => r.kernelBlockId === kernelRef);
+  return entry?.blockId ?? null;
+}
 function summarySeqOfKernelBlock(session, kernelBlockId) {
   const entry = blockRegistry(session).find((r) => r.kernelBlockId === kernelBlockId);
   return entry?.active ? entry.summarySeq : null;
@@ -755,7 +781,7 @@ var AcpStateStore = class {
 
 // src/tools.ts
 import { defineTool } from "@deepseek-ai/dsh-tools";
-import { defaultCountTokens as defaultCountTokens3 } from "acp-kernel";
+import { buildStatusReport, defaultCountTokens as defaultCountTokens3 } from "acp-kernel";
 
 // src/config.ts
 import { defaultConfig } from "acp-kernel";
@@ -874,10 +900,10 @@ var DEFAULT_PROMPTS = {
     footer: "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.\nSnapshot 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."
   },
   tools: {
-    compress: "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.",
-    decompress: "Recover the original content of a compressed block by its blockId (read-only; does not unshadow the range).",
+    compress: "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. Compress boundaries are SURFACE SEQS (acp_status Surface: row, latest nudge table) \u2014 NOT the block refs (bN, e.g. b1) that acp_status COMPRESSED BLOCKS shows, which are for decompress only. 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.",
+    decompress: "Recover the original content of a compressed block by its blockId \u2014 the kernel block ref `bN` shown by acp_status (e.g. b1), or a compaction id from search_context (read-only; does not unshadow the range).",
     searchContext: "Search inside compressed blocks (summaries and original content) for information the model no longer sees in context.",
-    acpStatus: "Report the ACP block ledger: compressed blocks, reclaimed tokens, and current context pressure."
+    acpStatus: 'Context status: overview of the current context \u2014 CONTEXT BREAKDOWN (tool/text/summaries token shares of the visible total), COMPRESSED BLOCKS ledger, and the nudge decision. No args = overview. Percentages are shares of the visible content, not the context window. Note: the block refs in COMPRESSED BLOCKS (bN, e.g. b1) are for decompress; compress uses the Surface: seq range, not bN. Drilldown: pass scope:"compressed" for a per-block list, or scope:"uncompressed" with view:"messages" (every visible message) / view:"ranges" (merged ranges); tool filters to one tool name, sort reorders (size/time/tool; age for compressed), limit caps rows (default 30). Drilldown row refs are kernel ids (mN) for size awareness only \u2014 compress always uses the Surface: seqs, never mN.'
   },
   systemPromptTemplate: `Active Context Pruning \u2014 model-driven context management
 
@@ -902,10 +928,10 @@ WHEN NOT TO COMPRESS:
 {howToCompressRules}
 
 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. 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 }).
+- 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. The block refs (bN, e.g. b1) in acp_status COMPRESSED BLOCKS are for decompress, NOT compress boundaries.
+- decompress: recover a compressed block's original content, read-only. decompress({ blockId }) \u2014 accept the bN ref shown by acp_status (e.g. b1) or a compaction id.
 - 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 right before compressing \u2014 the only seqs that never go stale are the ones you just read.
+- 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. Drilldown (scope/view/tool/sort/limit) lists per-message or per-block sizes; drilldown rows are kernel ids (mN) for size awareness \u2014 compress uses seqs, never mN.
 
 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.
 
@@ -1075,28 +1101,6 @@ function renderNudgeFromTemplates(nudge, emergency, session, prompts) {
   return parts.join("\n");
 }
 
-// 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 {
@@ -1177,6 +1181,20 @@ function unwrapCompressArgs(args) {
   if (content === void 0) return null;
   return { ...args, content };
 }
+function unwrapEnvelope(args) {
+  const envelope = args.arguments;
+  if (envelope === void 0) return args;
+  let inner = envelope;
+  if (typeof inner === "string") {
+    try {
+      inner = JSON.parse(inner);
+    } catch {
+      return args;
+    }
+  }
+  if (typeof inner !== "object" || inner === null || Array.isArray(inner)) return args;
+  return { ...args, ...inner };
+}
 async function handleCompress(env, args, exec) {
   const agent = requireAgent(exec);
   const session = agent.session;
@@ -1327,12 +1345,24 @@ async function handleCompress(env, args, exec) {
 ${[...warningLines, footer].filter((line) => line !== "").join("\n")}` };
 }
 var decompressParameters = {
-  blockId: { type: "string", required: true, description: "Block id from acp_status or search_context (the compaction id)." }
+  blockId: { type: "string", required: true, description: "Block id: the kernel block ref `bN` shown by acp_status (e.g. b1), or a compaction id / prefix from search_context." }
 };
-function handleDecompress(_env, args, exec) {
+function resolveBlockId(session, arg) {
+  const byKernelRef = blockIdOfKernelRef(session, arg);
+  if (byKernelRef !== null) return byKernelRef;
+  const ledger = rebuildBlockLedger(session.events);
+  const byPrefix = ledger.find((entry) => entry.blockId.startsWith(arg));
+  return byPrefix?.blockId ?? null;
+}
+function handleDecompress(_env, rawArgs, exec) {
+  const args = unwrapEnvelope(rawArgs);
   const session = requireAgent(exec).session;
+  const blockId = resolveBlockId(session, args.blockId);
+  if (blockId === null) {
+    return { text: `decompress: block "${args.blockId}" not found (see acp_status for the block list)` };
+  }
   const ledger = rebuildBlockLedger(session.events);
-  const block = ledger.find((entry) => entry.blockId.startsWith(args.blockId));
+  const block = ledger.find((entry) => entry.blockId === blockId);
   if (block === void 0) {
     return { text: `decompress: block "${args.blockId}" not found (see acp_status for the block list)` };
   }
@@ -1353,7 +1383,8 @@ var searchParameters = {
   query: { type: "string", required: true, description: "Search terms to find inside compressed blocks." },
   limit: { type: "integer", description: "Maximum results (default 5)." }
 };
-function handleSearch(_env, args, exec) {
+function handleSearch(_env, rawArgs, exec) {
+  const args = unwrapEnvelope(rawArgs);
   const session = requireAgent(exec).session;
   const ledger = rebuildBlockLedger(session.events);
   const terms = args.query.toLowerCase().split(/\s+/).filter(Boolean);
@@ -1374,26 +1405,63 @@ ${original}`.toLowerCase();
 ` + top.map((hit) => `  - ${hit.blockId} (score ${hit.score}): ${hit.summary.slice(0, 160)}`).join("\n") + "\n\nDecompress with: decompress({ blockId })"
   };
 }
-var statusParameters = {};
-async function handleStatus(env, _args, exec) {
+var statusParameters = {
+  scope: {
+    type: "string",
+    enum: ["compressed", "uncompressed"],
+    description: 'Drilldown scope: "compressed" lists compressed blocks, "uncompressed" lists visible messages. Omit for the overview.'
+  },
+  view: {
+    type: "string",
+    enum: ["ranges", "messages"],
+    description: 'Drilldown view under scope:"uncompressed": "ranges" merges visible messages into ranges (default), "messages" lists every message.'
+  },
+  tool: {
+    type: "string",
+    description: 'Filter drilldown rows to one tool name (scope:"uncompressed" + view:"messages" only).'
+  },
+  sort: {
+    type: "string",
+    enum: ["size", "time", "tool", "age"],
+    description: 'Row order: size (default, most tokens first), time, tool; "age" applies to compressed blocks.'
+  },
+  limit: {
+    type: "integer",
+    description: "Cap on rows or blocks shown (default 30)."
+  }
+};
+function isCheckpointEvent(event) {
+  if (event.type !== "user/message") return false;
+  const source = event.data.source;
+  return source?.plugin === "compact";
+}
+async function handleStatus(env, rawArgs, exec) {
+  const args = unwrapEnvelope(rawArgs);
   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 = resolveTokenCount(agent, coreMessages);
-  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)) {
-    lines.push(`  - ${block.blockId.slice(0, 8)}: seqs ${block.start}..${block.end} (${block.shadowedSeqs.length} msgs) \u2014 ${block.summary.slice(0, 80)}`);
+  const state = env.store.stateFor(session);
+  const surface = surfaceEventsOf(session);
+  const toolNames = buildToolCallIndex(surface);
+  const coreMessages = allLogMessages(session);
+  const surfaceMessages = eventsToCoreMessages(surface, toolNames);
+  const tokenCount = resolveTokenCount(agent, surfaceMessages);
+  const config = kernelConfigFor(env);
+  const turn = env.kernel.processTurn({ messages: coreMessages, state, config, tokenCount });
+  const statusMessages = eventsToCoreMessages(
+    surface.filter((event) => !isCheckpointEvent(event)),
+    toolNames
+  );
+  const report = buildStatusReport(turn.state, statusMessages, defaultCountTokens3, args);
+  const lines = [report];
+  if (args.scope === void 0) {
+    const nudge = turn.nudge;
+    if (nudge !== void 0) {
+      lines.push("", `Nudge: ${nudge.shouldInject ? "ACTIVE" : "idle"} \u2014 ${nudge.reason}`);
+    }
+  }
+  lines.push("", `Surface: ${surfaceSummary(session)}`);
+  if (args.scope === "uncompressed") {
+    lines.push("", "Note: drilldown rows are kernel refs (mN) for size awareness \u2014 compress uses the Surface: seqs above, never mN.");
   }
   return { text: lines.join("\n") };
 }
@@ -1441,6 +1509,30 @@ function makeTools(env) {
 
 // src/commands.ts
 import { defaultCountTokens as defaultCountTokens4 } from "acp-kernel";
+
+// 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/commands.ts
 async function statusText(env, agent) {
   const session = agent.session;
   const ledger = rebuildBlockLedger(session.events);
@@ -1497,8 +1589,9 @@ function compressText(env, agent, args) {
 function decompressText(_env, agent, args) {
   if (args.length < 1) return "/acp decompress <blockId>";
   const session = agent.session;
+  const blockId = blockIdOfKernelRef(session, args[0]);
   const ledger = rebuildBlockLedger(session.events);
-  const block = ledger.find((entry) => entry.blockId.startsWith(args[0]));
+  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)`;
   const parts = expandShadowedSeqs(session, block.blockId).map((seq) => extractEventText(session.events[seq])).filter((text) => text.length > 0);
   return `Block ${block.blockId} \u2014 ${block.summary}