billion-context-dsh 0.2.1 → 0.2.3

package/dist/index.js

@@ -16,7 +16,7 @@ import {
   toolPairingBalancedAfter,
   toolPairingBalancedBefore
 } from "@deepseek-ai/dsh-compaction";
-import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { createAssistantMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { defaultCountTokens } from "acp-kernel";
 
 // src/messages.ts
@@ -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) {
@@ -347,7 +371,191 @@ function isCheckpointNode(event) {
   const source = event.data.source;
   return source?.plugin === "compact";
 }
+function toolCallIdsOfEvent(event) {
+  if (event.type !== "assistant/message") return [];
+  const content = event.data.message?.content;
+  if (!Array.isArray(content)) return [];
+  const ids = [];
+  for (const block of content) {
+    if (block === null || typeof block !== "object") continue;
+    const b = block;
+    if (b.type === "tool-call" && typeof b.id === "string") ids.push(b.id);
+  }
+  return ids;
+}
+function assistantProviderModel(event) {
+  if (event.type === "assistant/message") {
+    const message = event.data.message;
+    return {
+      provider: typeof message?.source?.provider === "string" ? message.source.provider : "billion-context-dsh",
+      model: typeof message?.source?.model === "string" ? message.source.model : "surface-prune"
+    };
+  }
+  return { provider: "billion-context-dsh", model: "surface-prune" };
+}
+function hideSurfaceSeqs(session, seqs, provider, model, text) {
+  if (seqs.length === 0) return;
+  const start = seqs[0];
+  const end = seqs[seqs.length - 1];
+  let shadowedTokenCount = 0;
+  for (const seq of seqs) {
+    const event = session.events[seq];
+    if (event !== void 0) shadowedTokenCount += defaultCountTokens(extractEventText(event));
+  }
+  session.append("compaction/prune", {
+    shadowedRange: { start, end },
+    shadowedSeqs: [...seqs],
+    shadowedTokenCount
+  });
+  if (text !== void 0) {
+    session.append("user/message", createUserMessage({
+      content: [{ type: "text", text }],
+      source: { kind: "plugin", plugin: "billion-context-dsh" }
+    }), {
+      surfaceOp: { op: "replace", start, end },
+      sourceEventSeqs: [...seqs]
+    });
+    return;
+  }
+  session.append("assistant/message", {
+    turn: findOpenTurn(session.events) ?? 0,
+    step: 0,
+    message: createAssistantMessage({ content: [], source: { provider, model } })
+  }, {
+    surfaceOp: { op: "replace", start, end },
+    sourceEventSeqs: [...seqs]
+  });
+}
+function hideCompressToolPair(session, callId, resultSeq) {
+  let callSeq = null;
+  for (const event of session.events) {
+    if (event.type !== "assistant/message") continue;
+    if (toolCallIdsOfEvent(event).includes(callId)) {
+      callSeq = event.seq;
+      break;
+    }
+  }
+  if (callSeq === null) return false;
+  const callNodeIds = toolCallIdsOfEvent(session.events[callSeq]);
+  if (callNodeIds.length !== 1 || callNodeIds[0] !== callId) return false;
+  let resolvedResultSeq = resultSeq ?? null;
+  if (resolvedResultSeq === null) {
+    for (const event of session.events) {
+      if (event.type === "tool/result" && toolCallIdOfResultEvent(event) === callId) {
+        resolvedResultSeq = event.seq;
+        break;
+      }
+    }
+  }
+  if (resolvedResultSeq === null) return false;
+  const nodes = session.surface.nodes;
+  const startIdx = nodes.indexOf(callSeq);
+  const endIdx = nodes.indexOf(resolvedResultSeq);
+  if (startIdx < 0 || endIdx < 0 || endIdx - startIdx !== 1) return false;
+  const { provider, model } = assistantProviderModel(session.events[callSeq]);
+  const resultEvent = session.events[resolvedResultSeq];
+  const resultText = resultEvent === void 0 ? "" : extractEventText(resultEvent);
+  hideSurfaceSeqs(session, [callSeq, resolvedResultSeq], provider, model, resultText.trim().length > 0 ? resultText : void 0);
+  return true;
+}
+function stripOrphanedSurfaceToolMessages(session, inFlightCallIds = /* @__PURE__ */ new Set()) {
+  const nodes = session.surface.nodes;
+  const callIdsBySeq = /* @__PURE__ */ new Map();
+  const open = /* @__PURE__ */ new Map();
+  const orphanResultSeqs = [];
+  const brokenResults = /* @__PURE__ */ new Map();
+  for (let index = 0; index < nodes.length; index += 1) {
+    const seq = nodes[index];
+    const event = session.events[seq];
+    if (event === void 0) continue;
+    if (event.type === "assistant/message") {
+      const ids = toolCallIdsOfEvent(event);
+      if (ids.length === 0) continue;
+      callIdsBySeq.set(seq, ids);
+      for (const id of ids) {
+        if (!open.has(id)) open.set(id, { seq, index });
+      }
+    } else if (event.type === "tool/result") {
+      const id = toolCallIdOfResultEvent(event);
+      if (id === null) continue;
+      const call = open.get(id);
+      if (call === void 0) {
+        orphanResultSeqs.push(seq);
+        continue;
+      }
+      const callNodeIds = callIdsBySeq.get(call.seq);
+      let adjacent = false;
+      if (callNodeIds !== void 0) {
+        adjacent = true;
+        for (let mid = call.index + 1; mid < index; mid += 1) {
+          const midEvent = session.events[nodes[mid]];
+          if (midEvent === void 0 || midEvent.type !== "tool/result") {
+            adjacent = false;
+            break;
+          }
+          const midId = toolCallIdOfResultEvent(midEvent);
+          if (midId === null || !callNodeIds.includes(midId)) {
+            adjacent = false;
+            break;
+          }
+        }
+      }
+      open.delete(id);
+      if (!adjacent) brokenResults.set(seq, call.seq);
+    }
+  }
+  const brokenIdsByCallSeq = /* @__PURE__ */ new Map();
+  for (const [resultSeq, callSeq] of brokenResults) {
+    const id = toolCallIdOfResultEvent(session.events[resultSeq]);
+    if (id !== null) {
+      const list = brokenIdsByCallSeq.get(callSeq) ?? [];
+      list.push(id);
+      brokenIdsByCallSeq.set(callSeq, list);
+    }
+  }
+  const hiddenSet = new Set(orphanResultSeqs);
+  for (const resultSeq of brokenResults.keys()) hiddenSet.add(resultSeq);
+  for (const [callSeq, ids] of callIdsBySeq) {
+    const brokenIds = brokenIdsByCallSeq.get(callSeq);
+    const allUnpaired = !ids.some((candidate) => inFlightCallIds.has(candidate)) && ids.every((candidate) => open.has(candidate) || brokenIds?.includes(candidate) === true);
+    if (allUnpaired) hiddenSet.add(callSeq);
+  }
+  const hidden = [...hiddenSet].sort((a, b) => a - b);
+  let count = 0;
+  for (const seq of hidden) {
+    const event = session.events[seq];
+    if (event === void 0) continue;
+    const { provider, model } = assistantProviderModel(event);
+    hideSurfaceSeqs(session, [seq], provider, model);
+    count += 1;
+  }
+  return count;
+}
+function openToolCallIds(session) {
+  const open = /* @__PURE__ */ new Set();
+  for (const seq of session.surface.nodes) {
+    const event = session.events[seq];
+    if (event === void 0) continue;
+    if (event.type === "assistant/message") {
+      for (const id of toolCallIdsOfEvent(event)) open.add(id);
+    } else if (event.type === "tool/result") {
+      const id = toolCallIdOfResultEvent(event);
+      if (id !== null) open.delete(id);
+    }
+  }
+  return open;
+}
+function deferCompressPairHide(session, callId, resultSeq, onError) {
+  queueMicrotask(() => {
+    try {
+      hideCompressToolPair(session, callId, resultSeq);
+    } catch (error) {
+      onError?.(error);
+    }
+  });
+}
 function buildCompressibleSeqRanges(session, opts = {}) {
+  stripOrphanedSurfaceToolMessages(session);
   const nodes = session.surface.nodes;
   const preserve = opts.preserveRecent ?? 5;
   const protectedSeqs = /* @__PURE__ */ new Set();
@@ -397,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) {
@@ -449,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;
@@ -564,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";
@@ -683,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
 
@@ -711,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.
 
@@ -884,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 {
@@ -986,9 +1181,24 @@ 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;
+  stripOrphanedSurfaceToolMessages(session, openToolCallIds(session));
   const state = env.store.stateFor(session);
   const coreMessages = allLogMessages(session);
   const surfaceMessages = eventsToCoreMessages(surfaceEventsOf(session));
@@ -1059,10 +1269,13 @@ async function handleCompress(env, args, exec) {
     // non-block-covered messages as the visible feed, so default behavior is
     // preserved. Any 'Excluded N protected message(s)' warning is surfaced.
   });
-  if (applied.result.errors.length > 0) {
+  if (applied.result.errors.length > 0 && applied.result.blocksCreated === 0) {
     return { text: `compress failed: ${applied.result.errors.join("; ")}` };
   }
   env.store.set(session, applied.state);
+  if (applied.result.blocksCreated > 0) {
+    env.compressCallIdsToHide?.add(exec.callId);
+  }
   const previousIds = new Set(turn.state.blocks.map((block) => block.blockId));
   const newBlocks = applied.state.blocks.filter((block) => !previousIds.has(block.blockId));
   const blockByRangeKey = new Map(newBlocks.map((block) => [`${block.startRef}::${block.endRef}`, block]));
@@ -1125,18 +1338,31 @@ async function handleCompress(env, args, exec) {
   }
   const summaryLine = `Compressed ${applied.result.blocksCreated} block(s), ~${applied.result.tokensCompressed} tokens reclaimed.`;
   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)` : "";
+  const failedLines = applied.result.errors.map((error) => `  ${error}`);
+  const warningLines = [...freeWarnings.map((warning) => `  ${warning}`), ...failedLines, ...alreadyCompressedNotes, ...lines];
+  const footer = totalSkipped > 0 ? `  (${totalSkipped} range(s) skipped or failed \u2014 see above)` : "";
   return { text: `${summaryLine}
 ${[...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)` };
   }
@@ -1157,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);
@@ -1178,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") };
 }
@@ -1245,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);
@@ -1301,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}
@@ -1360,6 +1649,8 @@ var AcpCompactionEngine = class extends CompactionEngine {
   /** Resolved prompt templates (validated at construction — fail-fast on template typos). */
   prompts;
   lastNudgeTurn = /* @__PURE__ */ new Map();
+  /** Successful compress call ids awaiting their tool/result so the pair can be hidden. */
+  compressCallIdsToHide = /* @__PURE__ */ new Set();
   /** Per provider/model route the resolved window (probe failures cached too). */
   windowCache = /* @__PURE__ */ new Map();
   constructor(ctx, config = {}) {
@@ -1379,7 +1670,8 @@ var AcpCompactionEngine = class extends CompactionEngine {
       nudgeEmergencyThresholdPct: this.config.nudgeEmergencyThresholdPct,
       coreOverrides: this.config.coreOverrides,
       windowFor: (agent) => this.windowFor(agent),
-      prompts: this.prompts
+      prompts: this.prompts,
+      compressCallIdsToHide: this.compressCallIdsToHide
     };
     const tools = ctx.get("tools");
     if (tools !== void 0) {
@@ -1413,16 +1705,27 @@ var AcpCompactionEngine = class extends CompactionEngine {
         if (name === "commands") registerCommand();
       });
     }
-    if (this.config.autoNudge) {
-      ctx.on("agent/pre-step", async (payload, next) => {
-        const decision = await next();
-        if (decision.kind === "reject") return decision;
-        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] };
+    ctx.on("session/event", (session, event) => {
+      if (event.type !== "tool/result") return;
+      const message = event.data.message;
+      const block = message.content[0];
+      const callId = block?.toolCallId ?? message.source.callId;
+      if (typeof callId !== "string" || !this.compressCallIdsToHide.has(callId)) return;
+      this.compressCallIdsToHide.delete(callId);
+      deferCompressPairHide(session, callId, event.seq, (error) => {
+        ctx.logger.warn(`billion-context-dsh: hide compress call/result pair failed: ${String(error)}`);
       });
-    }
+    });
+    ctx.on("agent/pre-step", async (payload, next) => {
+      stripOrphanedSurfaceToolMessages(payload.agent.session);
+      if (!this.config.autoNudge) return next();
+      const decision = await next();
+      if (decision.kind === "reject") return decision;
+      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] };
+    });
     const systemPrompt = ctx.get("systemPrompt");
     if (systemPrompt !== void 0) {
       systemPrompt.section({
@@ -1519,6 +1822,7 @@ export {
   expandShadowedSeqs,
   extractEventText,
   findOpenTurn,
+  hideCompressToolPair,
   kernelConfigFor,
   makeTools,
   projectEvent,
@@ -1531,6 +1835,7 @@ export {
   resolveTokenCount,
   runCompactionTransaction,
   shadowedSeqsOf,
+  stripOrphanedSurfaceToolMessages,
   summarySeqOfKernelBlock,
   surfaceEventsOf,
   windowSourceLabel