billion-context-dsh 0.2.0 → 0.2.2

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
@@ -347,7 +347,198 @@ 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 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;
+    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();
@@ -582,17 +773,24 @@ function kernelConfigFor(input) {
 
 // src/nudge.ts
 import {
-  defaultCountTokens as defaultCountTokens2
+  COMPRESS_PHILOSOPHY as COMPRESS_PHILOSOPHY2,
+  TIER2_DISTILL_RULES as TIER2_DISTILL_RULES2,
+  TIER3_CONDENSE_RULES as TIER3_CONDENSE_RULES2,
+  defaultCountTokens as defaultCountTokens2,
+  renderNudgeText
 } from "acp-kernel";
 import { createUserMessage as createUserMessage2 } from "@deepseek-ai/dsh-llm";
 
 // src/prompts.ts
-import { COMPRESS_PHILOSOPHY } from "acp-kernel";
+import { COMPRESS_PHILOSOPHY, HOW_TO_COMPRESS_RULES, TIER2_DISTILL_RULES, TIER3_CONDENSE_RULES } from "acp-kernel";
 var NUDGE_ALLOWED = {
-  normal: /* @__PURE__ */ new Set(["pct"]),
-  emergency: /* @__PURE__ */ new Set(["pct"]),
+  normal: /* @__PURE__ */ new Set(["pct", "philosophy"]),
+  emergency: /* @__PURE__ */ new Set(["pct", "philosophy"]),
   guidance: /* @__PURE__ */ new Set(),
-  tier: /* @__PURE__ */ new Set(["tier", "count", "prevTier", "tokens", "seqs"])
+  tier: /* @__PURE__ */ new Set(["tier", "count", "prevTier", "tokens", "seqs"]),
+  breakdown: /* @__PURE__ */ new Set(["system", "tool", "summaries", "code", "text"]),
+  growth: /* @__PURE__ */ new Set(["growth"]),
+  tip: /* @__PURE__ */ new Set()
 };
 var RANGE_TABLE_ALLOWED = {
   header: /* @__PURE__ */ new Set(["surface"]),
@@ -606,7 +804,7 @@ var TOOLS_ALLOWED = {
   searchContext: /* @__PURE__ */ new Set(),
   acpStatus: /* @__PURE__ */ new Set()
 };
-var SYSTEM_ALLOWED = /* @__PURE__ */ new Set(["philosophy"]);
+var SYSTEM_ALLOWED = /* @__PURE__ */ new Set(["philosophy", "howToCompressRules", "tier2DistillRules", "tier3CondenseRules"]);
 function validateTemplate(template, allowed, path) {
   const re = /\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
   let match;
@@ -650,14 +848,24 @@ function resolvePrompts(input) {
   };
 }
 function renderSystemPrompt(prompts) {
-  return renderTemplate(prompts.systemPromptTemplate, { philosophy: COMPRESS_PHILOSOPHY });
+  return renderTemplate(prompts.systemPromptTemplate, {
+    philosophy: COMPRESS_PHILOSOPHY,
+    howToCompressRules: HOW_TO_COMPRESS_RULES,
+    tier2DistillRules: TIER2_DISTILL_RULES,
+    tier3CondenseRules: TIER3_CONDENSE_RULES
+  });
 }
 var DEFAULT_PROMPTS = {
   nudge: {
-    normal: "Context usage is at {pct}%. This is a suggestion, not a requirement \u2014 you decide whether and when to compress.",
-    emergency: "\u26A0\uFE0F Context usage is at {pct}% of the window \u2014 nearly full. Consider compressing consumed ranges soon so working context stays available; the choice and timing are yours.",
-    guidance: "Compress by need, not by percentage: replace only ranges you have genuinely consumed, with dense self-contained summaries.",
-    tier: "Tier {tier}: {count} tier-{prevTier} block(s) distillable ({tokens} tokens) \u2014 compress their summary node(s) [seqs {seqs}] to reclaim the original messages."
+    // 与 kernel nudge-text.ts EFFICIENCY_NOTE 逐字对齐——不含 "Context usage is at X%"
+    // 陈述(usage 只通过 breakdown 传达);{pct} 仍可用作自定义占位符。
+    normal: "This is an efficiency nudge to compress early and keep context lean \u2014 not an overflow warning. A separate, stronger alert will appear if the context is actually full.\n\n{philosophy}",
+    emergency: "\u26A0\uFE0F Context limit reached \u2014 compress now. Prioritize consumed tool outputs.\n\n{philosophy}",
+    guidance: HOW_TO_COMPRESS_RULES,
+    tier: "Tier {tier}: {count} tier-{prevTier} block(s) distillable ({tokens} tokens) \u2014 compress their summary node(s) [seqs {seqs}] to reclaim the original messages.",
+    breakdown: "Context breakdown: {system}K system | {tool}K tool | {summaries}K summaries | {code}K code | {text}K text",
+    growth: "+{growth}K since last nudge",
+    tip: "\u{1F4A1} Compress all ranges in one call (pass multiple content entries: `content: [{...}, {...}]`)."
   },
   rangeTable: {
     header: "Surface: {surface}",
@@ -673,10 +881,26 @@ var DEFAULT_PROMPTS = {
   },
   systemPromptTemplate: `Active Context Pruning \u2014 model-driven context management
 
-YOU decide whether and when to compress context. Nothing forces you: the injected "nudge" is a suggestion, not an order, and you may ignore it when compression would not help. Compress only ranges you have genuinely consumed (read tool outputs, finished explorations, superseded steps) that the current work no longer needs verbatim.
+YOU decide whether and when to compress context. The nudge is an efficiency notification: when you see one, consider which ranges you have genuinely consumed and could summarise to keep working context lean.
 
 {philosophy}
 
+WHEN TO COMPRESS:
+- A sub-agent or delegated task has returned a large result that you have already extracted the key facts from.
+- Verbose command output (build/test logs, git diff, directory listings) where you have already used the information you need.
+- Exploration that led nowhere.
+- Repeated reads of the same file or repeated status checks once the decision is recorded.
+- Resolved discussion threads where a decision has been captured in summary or in code.
+- Intermediate steps of a completed multi-step task, once the final result is recorded.
+- A task phase has ended \u2014 bug hunt complete, root cause found, exploration done, research sprint wrapped.
+
+WHEN NOT TO COMPRESS:
+- Content the current step is actively reading or reasoning about.
+- Important user messages \u2014 preserve their exact intent, constraints, and acceptance criteria.
+- Protected tool outputs \u2014 hard-excluded from compression ranges, survive intact in visible context.
+
+{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 }).
@@ -685,6 +909,10 @@ Compression tools (refs are SURFACE SEQS, not ids):
 
 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.
 
+{tier2DistillRules}
+
+{tier3CondenseRules}
+
 When you write a summary, it becomes the ONLY record of that range: keep file paths, signatures, exact values, decisions, and error strings verbatim so a later reader (or you, after decompress) can continue without the original. Never reuse historical seqs \u2014 the surface moves as messages land and compress; verify with acp_status.`
 };
 var DEFAULT_RESOLVED = DEFAULT_PROMPTS;
@@ -746,12 +974,84 @@ function buildNudge(agent, env, lastNudgeTurn) {
   return { message, emergency };
 }
 function buildNudgeText(nudge, emergency, session, prompts = DEFAULT_RESOLVED) {
+  if (prompts.nudge !== DEFAULT_RESOLVED.nudge) {
+    return renderNudgeFromTemplates(nudge, emergency, session, prompts);
+  }
+  const rendered = renderNudgeText(nudge);
+  return adaptKernelNudgeToSeq(rendered.text, nudge, session, prompts);
+}
+function adaptKernelNudgeToSeq(text, nudge, session, prompts) {
+  let out = text;
+  if ((nudge.tier === 2 || nudge.tier === 3) && (nudge.tierTargetBlocks?.length ?? 0) > 0) {
+    out = replaceTierTrigger(out, nudge, session, prompts);
+  } else if (out.includes('"startId"')) {
+    out = replaceEmergencyExample(out);
+  }
+  const seqTable = rangeTable(session, prompts);
+  if (seqTable !== "") out = replaceRangesStr(out, seqTable);
+  return out;
+}
+function replaceRangesStr(text, seqTable) {
+  const match = text.match(/\n\n(?:Compressible ranges \(|\[No specific ranges detected)/);
+  if (!match) return text;
+  const start = match.index;
+  const rest = text.slice(start + 2);
+  const next = rest.match(/\n\n/);
+  const end = next !== null ? start + 2 + next.index : text.length;
+  const before = text.slice(0, start);
+  const after = text.slice(end);
+  return before + "\n" + seqTable + after;
+}
+function replaceTierTrigger(text, nudge, session, prompts) {
+  const start = text.search(/\n\n(?:\[TIER \d|\[EMERGENCY — TIER \d)/);
+  if (start === -1) return text;
+  const rest = text.slice(start + 2);
+  const next = rest.match(/\n\nHOW TO COMPRESS/);
+  const end = next !== null ? start + 2 + next.index : text.length;
+  const targets = nudge.tierTargetBlocks;
+  const summarySeqs = targets.map((block) => summarySeqOfKernelBlock(session, block.blockId)).filter((seq) => seq !== null);
+  const pending = nudge.tier === 2 ? nudge.breakdown?.pendingT2 : nudge.breakdown?.pendingT3;
+  const tokens = typeof pending === "number" ? pending : 0;
+  const tierValue = nudge.tier === null ? 2 : nudge.tier;
+  const tierLine = renderTemplate(prompts.nudge.tier, {
+    tier: tierValue,
+    count: targets.length,
+    prevTier: tierValue - 1,
+    tokens,
+    seqs: summarySeqs.join(", ")
+  });
+  return text.slice(0, start) + "\n\n" + tierLine + text.slice(end);
+}
+function replaceEmergencyExample(text) {
+  const start = text.search(/\n\n\{ "topic":/);
+  if (start === -1) return text;
+  const rest = text.slice(start + 2);
+  const next = rest.match(/\n\nCompressible ranges |\n\n\[No specific/);
+  const end = next !== null ? start + 2 + next.index : text.length;
+  return text.slice(0, start) + "\n\ncompress({ content: [{ startSeq, endSeq, summary }] }) \u2014 use the seqs from the range table above." + text.slice(end);
+}
+function renderNudgeFromTemplates(nudge, emergency, session, prompts) {
   const pct = Math.round(Math.min(nudge.contextUsage, 1) * 100);
   const frame = renderTemplate(
     emergency ? prompts.nudge.emergency : prompts.nudge.normal,
-    { pct }
+    { pct, philosophy: COMPRESS_PHILOSOPHY2 }
   );
   const parts = [frame];
+  if (nudge.contextBreakdown) {
+    const bd = nudge.contextBreakdown;
+    const breakdown = renderTemplate(prompts.nudge.breakdown, {
+      system: Math.round(bd.system / 1e3),
+      tool: Math.round(bd.tool / 1e3),
+      summaries: Math.round(bd.summaries / 1e3),
+      code: Math.round(bd.code / 1e3),
+      text: Math.round(bd.text / 1e3)
+    });
+    if (breakdown !== "") parts.push("", breakdown);
+    if (bd.growth > 0) {
+      const growth = renderTemplate(prompts.nudge.growth, { growth: Math.round(bd.growth / 1e3) });
+      if (growth !== "") parts.push(growth);
+    }
+  }
   if (prompts.nudge.guidance !== "") parts.push("", prompts.nudge.guidance);
   if ((nudge.tier === 2 || nudge.tier === 3) && (nudge.tierTargetBlocks?.length ?? 0) > 0) {
     const targets = nudge.tierTargetBlocks;
@@ -766,8 +1066,12 @@ function buildNudgeText(nudge, emergency, session, prompts = DEFAULT_RESOLVED) {
       seqs: summarySeqs.join(", ")
     });
     if (tierLine !== "") parts.push(tierLine);
+    const tierRules = nudge.tier === 2 ? TIER2_DISTILL_RULES2 : TIER3_CONDENSE_RULES2;
+    parts.push("", tierRules);
+  } else {
+    parts.push(rangeTable(session, prompts));
   }
-  parts.push(rangeTable(session, prompts));
+  if (prompts.nudge.tip !== "") parts.push("", prompts.nudge.tip);
   return parts.join("\n");
 }
 
@@ -811,11 +1115,22 @@ function requireAgent(exec) {
   return exec.agent;
 }
 var compressParameters = {
+  // Tolerated wrapped-arguments form: some models emit
+  // `{ "arguments": "{\"content\": [...]}" }` (double-nested) or
+  // `{ "arguments": { "content": [...] } }` instead of the unwrapped
+  // `{ "content": [...] }`. The old DSH validator surfaced this as
+  // `invalid arguments: "arguments" must be an object` and the model retried
+  // forever. `arguments` is accepted as an optional JSON node so the wrapped
+  // shape passes schema validation; `handleCompress` unwraps it and falls back
+  // to a clear runtime error when neither form carries content. `content` is
+  // intentionally NOT `required: true` — a required property would reject the
+  // wrapped shape before `handleCompress` can see it. The tool description
+  // still tells the model content is mandatory.
+  arguments: { type: "json", description: "Tolerated wrapped-arguments form (model-generated); unwrapped in handleCompress. Prefer passing content directly." },
   topic: { type: "string", description: "Fallback topic for entries without their own." },
   content: {
     type: "array",
-    required: true,
-    description: "One or more ranges to compress, each with startSeq/endSeq boundaries (surface seqs) and a dense summary.",
+    description: "One or more ranges to compress, each with startSeq/endSeq boundaries (surface seqs) and a dense summary. Required \u2014 pass it directly, not wrapped in an arguments key.",
     items: {
       type: "object",
       properties: {
@@ -846,9 +1161,26 @@ function parseSeq(value) {
   }
   return seq;
 }
+function unwrapCompressArgs(args) {
+  if (args.content !== void 0) return args;
+  if (args.arguments === void 0) return null;
+  let inner = args.arguments;
+  if (typeof inner === "string") {
+    try {
+      inner = JSON.parse(inner);
+    } catch {
+      return null;
+    }
+  }
+  if (typeof inner !== "object" || inner === null || Array.isArray(inner)) return null;
+  const content = inner.content;
+  if (content === void 0) return null;
+  return { ...args, content };
+}
 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));
@@ -857,6 +1189,13 @@ 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 unwrapped = unwrapCompressArgs(args);
+  if (unwrapped === null) {
+    return {
+      text: "compress: missing content \u2014 pass the content array directly: compress({ content: [{ startSeq, endSeq, summary }] })"
+    };
+  }
+  args = unwrapped;
   const ranges = [];
   const alreadyCompressedNotes = [];
   for (const range of args.content) {
@@ -912,10 +1251,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]));
@@ -978,8 +1320,9 @@ 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")}` };
 }
@@ -1213,6 +1556,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 = {}) {
@@ -1232,7 +1577,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) {
@@ -1266,16 +1612,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({
@@ -1372,6 +1729,7 @@ export {
   expandShadowedSeqs,
   extractEventText,
   findOpenTurn,
+  hideCompressToolPair,
   kernelConfigFor,
   makeTools,
   projectEvent,
@@ -1384,6 +1742,7 @@ export {
   resolveTokenCount,
   runCompactionTransaction,
   shadowedSeqsOf,
+  stripOrphanedSurfaceToolMessages,
   summarySeqOfKernelBlock,
   surfaceEventsOf,
   windowSourceLabel