billion-context-dsh 0.1.0 → 0.1.2

package/dist/index.js

@@ -28,7 +28,7 @@ var AcpStateStore = class {
 
 // src/tools.ts
 import { defineTool } from "@deepseek-ai/dsh-tools";
-import { estimateTokensFast } from "acp-kernel";
+import { defaultCountTokens as defaultCountTokens2 } from "acp-kernel";
 
 // src/config.ts
 import { defaultConfig } from "acp-kernel";
@@ -53,6 +53,7 @@ import {
   toolPairingBalancedBefore
 } from "@deepseek-ai/dsh-compaction";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { defaultCountTokens } from "acp-kernel";
 
 // src/messages.ts
 function extractText(content) {
@@ -176,28 +177,62 @@ function assertNoActiveCompaction(events) {
     throw new Error("billion-context-dsh: another compaction is already active for this session");
   }
 }
+function hasPlainRef(session, seq) {
+  const event = session.events[seq];
+  if (event === void 0) return false;
+  switch (event.type) {
+    case "user/message":
+    case "tool/result":
+      return extractEventText(event).trim().length > 0;
+    case "assistant/message": {
+      const content = event.data.message?.content;
+      const calls = Array.isArray(content) ? content.filter(
+        (block) => block !== null && typeof block === "object" && block.type === "tool-call"
+      ) : [];
+      if (calls.length > 1) return false;
+      return calls.length === 1 || extractEventText(event).trim().length > 0;
+    }
+    default:
+      return false;
+  }
+}
 function resolveSurfaceRange(session, start, end) {
   const nodes = session.surface.nodes;
-  let startIdx = nodes.indexOf(start);
-  let endIdx = nodes.indexOf(end);
-  if (startIdx < 0 || endIdx < 0) {
+  const requestedStartIdx = nodes.indexOf(start);
+  const requestedEndIdx = nodes.indexOf(end);
+  if (requestedStartIdx < 0 || requestedEndIdx < 0) {
     throw new Error(`billion-context-dsh: seq ${start}..${end} not in the current surface`);
   }
-  if (startIdx > endIdx) {
+  if (requestedStartIdx > requestedEndIdx) {
     throw new Error(`billion-context-dsh: reversed range ${start}..${end}`);
   }
-  while (startIdx <= endIdx && !toolPairingBalancedBefore(session, nodes[startIdx])) {
+  const cleanBefore = (index) => toolPairingBalancedBefore(session, nodes[index]) && hasPlainRef(session, nodes[index]);
+  const cleanAfter = (index) => toolPairingBalancedAfter(session, nodes[index]) && hasPlainRef(session, nodes[index]);
+  let startIdx = requestedStartIdx;
+  let endIdx = requestedEndIdx;
+  while (startIdx <= endIdx && !cleanBefore(startIdx)) {
     startIdx += 1;
   }
-  while (endIdx >= startIdx && !toolPairingBalancedAfter(session, nodes[endIdx])) {
+  while (endIdx >= startIdx && !cleanAfter(endIdx)) {
     endIdx -= 1;
   }
-  if (startIdx > endIdx) {
-    throw new Error(
-      `billion-context-dsh: no tool-pairing-balanced range inside seq ${start}..${end} \u2014 narrow the range or consult acp_status for the current surface`
-    );
+  if (startIdx <= endIdx) {
+    return { start: nodes[startIdx], end: nodes[endIdx] };
+  }
+  startIdx = requestedStartIdx;
+  endIdx = requestedEndIdx;
+  while (startIdx > 0 && !cleanBefore(startIdx)) {
+    startIdx -= 1;
+  }
+  while (endIdx < nodes.length - 1 && !cleanAfter(endIdx)) {
+    endIdx += 1;
   }
-  return { start: nodes[startIdx], end: nodes[endIdx] };
+  if (cleanBefore(startIdx) && cleanAfter(endIdx)) {
+    return { start: nodes[startIdx], end: nodes[endIdx] };
+  }
+  throw new Error(
+    `billion-context-dsh: no tool-pairing-balanced range around seq ${start}..${end} \u2014 narrow the range or consult acp_status for the current surface`
+  );
 }
 function shadowedSeqsOf(session, start, end) {
   const nodes = session.surface.nodes;
@@ -236,17 +271,73 @@ function rebuildBlockLedger(events) {
   for (const event of events) {
     if (event.type !== "compaction/summary") continue;
     const data = event.data;
+    let shadowedTokenCount = data.shadowedTokenCount;
+    if (shadowedTokenCount === 0) {
+      shadowedTokenCount = 0;
+      for (const seq of data.shadowedSeqs) {
+        const original = events[seq];
+        if (original !== void 0) shadowedTokenCount += defaultCountTokens(extractEventText(original));
+      }
+    }
     ledger.push({
       blockId: data.compactionId,
       summary: extractText(data.summary),
       shadowedSeqs: [...data.shadowedSeqs],
-      shadowedTokenCount: data.shadowedTokenCount,
+      shadowedTokenCount,
       start: data.shadowedRange.start,
       end: data.shadowedRange.end
     });
   }
   return ledger;
 }
+function isCheckpointNode(event) {
+  if (event.type !== "user/message") return false;
+  const source = event.data.source;
+  return source?.plugin === "compact";
+}
+function buildCompressibleSeqRanges(session, opts = {}) {
+  const nodes = session.surface.nodes;
+  const preserve = opts.preserveRecent ?? 5;
+  const protectedSeqs = /* @__PURE__ */ new Set();
+  for (const seq of nodes.slice(-preserve)) protectedSeqs.add(seq);
+  for (let index = nodes.length - 1; index >= 0; index -= 1) {
+    const event = session.events[nodes[index]];
+    if (event?.type === "user/message" && !isCheckpointNode(event)) {
+      protectedSeqs.add(nodes[index]);
+      break;
+    }
+  }
+  const raw = [];
+  let cur = null;
+  const flush = () => {
+    if (cur !== null) raw.push(cur);
+    cur = null;
+  };
+  for (const seq of nodes) {
+    const event = session.events[seq];
+    if (event === void 0 || protectedSeqs.has(seq) || isCheckpointNode(event)) {
+      flush();
+      continue;
+    }
+    const tokens = defaultCountTokens(extractEventText(event));
+    if (cur === null) {
+      cur = { start: seq, end: seq, count: 1, tokens };
+    } else {
+      cur = { start: cur.start, end: seq, count: cur.count + 1, tokens: cur.tokens + tokens };
+    }
+  }
+  flush();
+  const out = [];
+  for (const range of raw) {
+    try {
+      const { start, end } = resolveSurfaceRange(session, range.start, range.end);
+      const count = range.count;
+      out.push({ start, end, count, tokens: range.tokens });
+    } catch {
+    }
+  }
+  return out.sort((a, b) => b.tokens - a.tokens);
+}
 
 // src/tools.ts
 function textOutput() {
@@ -306,7 +397,7 @@ async function handleCompress(env, args, exec) {
   const session = agent.session;
   const state = env.store.stateFor(session);
   const coreMessages = eventsToCoreMessages(surfaceEventsOf(session));
-  const tokenCount = coreMessages.reduce((sum, message) => sum + estimateTokensFast(message.text ?? ""), 0);
+  const tokenCount = coreMessages.reduce((sum, message) => sum + defaultCountTokens2(message.text ?? ""), 0);
   const config = kernelConfigFor(env);
   const turn = env.kernel.processTurn({ messages: coreMessages, state, config, tokenCount });
   env.store.set(session, turn.state);
@@ -314,16 +405,19 @@ async function handleCompress(env, args, exec) {
   const ranges = args.content.map((range) => {
     const startSeq = parseSeq(range.startSeq);
     const endSeq = parseSeq(range.endSeq);
-    const startRef = byRaw[String(startSeq)];
-    const endRef = byRaw[String(endSeq)];
+    const { start, end } = resolveSurfaceRange(session, startSeq, endSeq);
+    const startRef = byRaw[String(start)];
+    const endRef = byRaw[String(end)];
     if (startRef === void 0 || endRef === void 0) {
       throw new Error(
-        `billion-context-dsh: seq ${startSeq}..${endSeq} 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 ${start}..${end} has no assigned ref \u2014 the range must be on the current surface (run acp_status for the live seq list)`
       );
     }
     return {
       startSeq,
       endSeq,
+      start,
+      end,
       startRef,
       endRef,
       summary: range.summary,
@@ -344,14 +438,19 @@ async function handleCompress(env, args, exec) {
   for (let index = 0; index < ranges.length; index += 1) {
     const range = ranges[index];
     const original = args.content[index];
-    const { start, end } = resolveSurfaceRange(session, range.startSeq, range.endSeq);
+    const { start, end } = range;
     const shadowed = shadowedSeqsOf(session, start, end);
+    let shadowedTokens = 0;
+    for (const seq of shadowed) {
+      const event = session.events[seq];
+      if (event !== void 0) shadowedTokens += defaultCountTokens2(extractEventText(event));
+    }
     const { compactionId } = runCompactionTransaction(session, {
       start,
       end,
       shadowedSeqs: shadowed,
       summary: [{ type: "text", text: original.summary }],
-      shadowedTokenCount: 0,
+      shadowedTokenCount: shadowedTokens,
       provider: agent.options.provider ?? "",
       model: agent.options.model ?? ""
     });
@@ -418,7 +517,7 @@ function handleStatus(env, _args, exec) {
   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 + estimateTokensFast(message.text ?? ""), 0);
+  const estimated = coreMessages.reduce((sum, message) => sum + defaultCountTokens2(message.text ?? ""), 0);
   const limit = env.modelContextLimit;
   const lines = [
     `ACP status \u2014 session ${session.id}`,
@@ -473,13 +572,13 @@ function makeTools(env) {
 }
 
 // src/commands.ts
-import { estimateTokensFast as estimateTokensFast2 } from "acp-kernel";
+import { defaultCountTokens as defaultCountTokens3 } from "acp-kernel";
 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 + estimateTokensFast2(message.text ?? ""), 0);
+  const estimated = coreMessages.reduce((sum, message) => sum + defaultCountTokens3(message.text ?? ""), 0);
   const limit = env.modelContextLimit;
   const lines = [
     `ACP status \u2014 session ${session.id}`,
@@ -505,12 +604,17 @@ function compressText(env, agent, args) {
   const session = agent.session;
   const { start, end } = resolveSurfaceRange(session, startSeq, endSeq);
   const shadowed = shadowedSeqsOf(session, startSeq, endSeq);
+  let shadowedTokens = 0;
+  for (const seq of shadowed) {
+    const event = session.events[seq];
+    if (event !== void 0) shadowedTokens += defaultCountTokens3(extractEventText(event));
+  }
   const { compactionId } = runCompactionTransaction(session, {
     start,
     end,
     shadowedSeqs: shadowed,
     summary: [{ type: "text", text: summary }],
-    shadowedTokenCount: 0,
+    shadowedTokenCount: shadowedTokens,
     provider: agent.options.provider ?? "",
     model: agent.options.model ?? ""
   });
@@ -549,31 +653,31 @@ function acpCommand(env) {
 
 // src/nudge.ts
 import {
-  estimateTokensFast as estimateTokensFast3
+  defaultCountTokens as defaultCountTokens4
 } from "acp-kernel";
 import { createUserMessage as createUserMessage2 } from "@deepseek-ai/dsh-llm";
-function rangeTable(nudge, state) {
-  const byRef = state.messageRefs.byRef;
-  const lines = nudge.compressibleRanges.slice(0, 6).map((range) => {
-    const startRaw = byRef[range.startRef];
-    const endRaw = byRef[range.endRef];
-    if (startRaw === void 0 || endRaw === void 0) return null;
-    return `  - seq ${startRaw}..${endRaw} \u2014 ${range.count} messages, ~${range.tokens} tokens`;
-  });
-  const visible = lines.filter((line) => line !== null);
-  if (visible.length === 0) return "";
+function rangeTable(session) {
+  const ranges = buildCompressibleSeqRanges(session).slice(0, 6);
+  if (ranges.length === 0) return "";
+  const lines = ranges.map((range) => `  - seq ${range.start}..${range.end} \u2014 ${range.count} messages, ~${range.tokens} tokens`);
   return [
     "",
     "Compressible ranges (refs are surface seqs):",
-    ...visible,
+    ...lines,
     "Compress with: compress({ content: [{ startSeq, endSeq, summary }] })"
   ].join("\n");
 }
+function measuredTokenCount(agent, coreMessages) {
+  const meter = agent.ctx?.get?.("tokenMeter");
+  const surface = meter?.measure?.(agent.session)?.surfaceTokens;
+  if (typeof surface === "number" && surface > 0) return surface;
+  return coreMessages.reduce((sum, message) => sum + defaultCountTokens4(message.text ?? ""), 0);
+}
 function buildNudge(agent, env, lastNudgeTurn) {
   const session = agent.session;
   const state = env.store.stateFor(session);
   const coreMessages = eventsToCoreMessages(surfaceEventsOf(session));
-  const tokenCount = coreMessages.reduce((sum, message2) => sum + estimateTokensFast3(message2.text ?? ""), 0);
+  const tokenCount = measuredTokenCount(agent, coreMessages);
   const config = kernelConfigFor(env);
   const turn = env.kernel.processTurn({ messages: coreMessages, state, config, tokenCount });
   env.store.set(session, turn.state);
@@ -584,18 +688,18 @@ function buildNudge(agent, env, lastNudgeTurn) {
   const alreadyShown = !emergency && lastNudgeTurn.get(session.id) === turnNumber;
   if (alreadyShown) return null;
   lastNudgeTurn.set(session.id, turnNumber);
-  const text = buildNudgeText(nudge, emergency, turn.state);
+  const text = buildNudgeText(nudge, emergency, session);
   const message = createUserMessage2({
     content: [{ type: "text", text }],
     source: { kind: "plugin", plugin: "acp-nudge" }
   });
   return { message, emergency };
 }
-function buildNudgeText(nudge, emergency, state) {
-  const pct = Math.round(nudge.contextUsage * 100);
+function buildNudgeText(nudge, emergency, session) {
+  const pct = Math.round(Math.min(nudge.contextUsage, 1) * 100);
   const frame = 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.` : `Context usage is at ${pct}%. This is a suggestion, not a requirement \u2014 you decide whether and when to compress.`;
   const guidance = "Compress by need, not by percentage: replace only ranges you have genuinely consumed, with dense self-contained summaries.";
-  return [frame, "", guidance, rangeTable(nudge, state)].join("\n");
+  return [frame, "", guidance, rangeTable(session)].join("\n");
 }
 
 // src/system-prompt.ts