billion-context-dsh 0.1.4 → 0.1.6

package/dist/index.js

@@ -7,42 +7,6 @@ import { createCore } from "acp-kernel";
 
 // src/state.ts
 import { createInitialState } from "acp-kernel";
-var AcpStateStore = class {
-  states = /* @__PURE__ */ new Map();
-  /** Kernel state for one session, initialised on first access. */
-  stateFor(session) {
-    const id = session.id;
-    const existing = this.states.get(id);
-    if (existing !== void 0) return existing;
-    const state = createInitialState();
-    this.states.set(id, state);
-    return state;
-  }
-  set(session, state) {
-    this.states.set(session.id, state);
-  }
-  delete(session) {
-    this.states.delete(session.id);
-  }
-};
-
-// src/tools.ts
-import { defineTool } from "@deepseek-ai/dsh-tools";
-import { defaultCountTokens as defaultCountTokens2 } from "acp-kernel";
-
-// src/config.ts
-import { defaultConfig } from "acp-kernel";
-function kernelConfigFor(input) {
-  const nudgePatch = {};
-  if (input.nudgeMinContextLimitPct !== void 0) nudgePatch.minContextLimitPct = input.nudgeMinContextLimitPct;
-  if (input.nudgeMaxContextLimitPct !== void 0) nudgePatch.maxContextLimitPct = input.nudgeMaxContextLimitPct;
-  if (input.nudgeEmergencyThresholdPct !== void 0) nudgePatch.emergencyThresholdPct = input.nudgeEmergencyThresholdPct;
-  const overrides = { ...input.coreOverrides };
-  if (Object.keys(nudgePatch).length > 0) {
-    overrides.nudge = { ...defaultConfig(input.modelContextLimit).nudge, ...nudgePatch };
-  }
-  return defaultConfig(input.modelContextLimit, overrides);
-}
 
 // src/region.ts
 import { randomUUID } from "crypto";
@@ -145,6 +109,9 @@ function eventsToCoreMessages(events) {
 function surfaceEventsOf(session) {
   return session.surface.nodes.map((seq) => session.events[seq]).filter((event) => event !== void 0);
 }
+function allLogMessages(session) {
+  return eventsToCoreMessages(session.events);
+}
 function extractEventText(event) {
   switch (event.type) {
     case "user/message":
@@ -245,6 +212,9 @@ function shadowedSeqsOf(session, start, end) {
   const endIdx = nodes.indexOf(end);
   return nodes.slice(startIdx, endIdx + 1);
 }
+function readCompactionSummary(event) {
+  return event.data;
+}
 function runCompactionTransaction(session, input) {
   assertNoActiveCompaction(session.events);
   const turn = findOpenTurn(session.events);
@@ -258,7 +228,12 @@ function runCompactionTransaction(session, input) {
     shadowedSeqs: [...input.shadowedSeqs],
     shadowedTokenCount: input.shadowedTokenCount,
     provider: input.provider,
-    model: input.model
+    model: input.model,
+    tier: input.tier ?? 1,
+    ...input.kernelBlockId === void 0 ? {} : { kernelBlockId: input.kernelBlockId },
+    ...input.parentBlockIds === void 0 || input.parentBlockIds.length === 0 ? {} : { parentBlockIds: [...input.parentBlockIds] },
+    ...input.directMessageIds === void 0 ? {} : { directMessageIds: [...input.directMessageIds] },
+    ...input.effectiveMessageIds === void 0 ? {} : { effectiveMessageIds: [...input.effectiveMessageIds] }
   }).seq);
   const message = createUserMessage({
     content: input.summary,
@@ -271,11 +246,19 @@ function runCompactionTransaction(session, input) {
   seqs.push(session.append("compaction/end", { compactionId, turn }).seq);
   return { compactionId, seqs };
 }
+function summarySeqOfCompaction(events, compactionId) {
+  for (const event of events) {
+    if (event.type !== "user/message") continue;
+    const source = event.data.source;
+    if (source?.plugin === "compact" && source.compactionId === compactionId) return event.seq;
+  }
+  return null;
+}
 function rebuildBlockLedger(events) {
   const ledger = [];
   for (const event of events) {
     if (event.type !== "compaction/summary") continue;
-    const data = event.data;
+    const data = readCompactionSummary(event);
     let shadowedTokenCount = data.shadowedTokenCount;
     if (shadowedTokenCount === 0) {
       shadowedTokenCount = 0;
@@ -284,13 +267,25 @@ function rebuildBlockLedger(events) {
         if (original !== void 0) shadowedTokenCount += defaultCountTokens(extractEventText(original));
       }
     }
+    const tier = data.tier === 2 || data.tier === 3 ? data.tier : 1;
+    const parentBlockIds = Array.isArray(data.parentBlockIds) ? [...data.parentBlockIds] : [];
+    const directMessageIds = Array.isArray(data.directMessageIds) ? [...data.directMessageIds] : void 0;
+    const effectiveMessageIds = Array.isArray(data.effectiveMessageIds) ? [...data.effectiveMessageIds] : void 0;
+    const summarySeq = summarySeqOfCompaction(events, data.compactionId);
     ledger.push({
       blockId: data.compactionId,
       summary: extractText(data.summary),
       shadowedSeqs: [...data.shadowedSeqs],
       shadowedTokenCount,
       start: data.shadowedRange.start,
-      end: data.shadowedRange.end
+      end: data.shadowedRange.end,
+      tier,
+      parentBlockIds,
+      ...typeof data.kernelBlockId === "string" ? { kernelBlockId: data.kernelBlockId } : {},
+      ...summarySeq === null ? {} : { summarySeq },
+      ...directMessageIds === void 0 ? {} : { directMessageIds },
+      ...effectiveMessageIds === void 0 ? {} : { effectiveMessageIds },
+      createdAt: event.time
     });
   }
   return ledger;
@@ -354,6 +349,206 @@ function surfaceSummary(session) {
   const last = nodes[nodes.length - 1];
   return `${nodes.length} nodes, seqs ${first}..${last}`;
 }
+function blockRegistry(session) {
+  const ledger = rebuildBlockLedger(session.events);
+  const kernelIdOf = /* @__PURE__ */ new Map();
+  const raw = [];
+  let next = 1;
+  for (const entry of ledger) {
+    let kernelBlockId;
+    if (entry.kernelBlockId !== void 0 && /^b\d+$/.test(entry.kernelBlockId)) {
+      kernelBlockId = entry.kernelBlockId;
+      const num = Number(kernelBlockId.slice(1));
+      if (Number.isInteger(num)) next = Math.max(next, num + 1);
+    } else {
+      kernelBlockId = `b${next}`;
+      next += 1;
+    }
+    kernelIdOf.set(entry.blockId, kernelBlockId);
+    raw.push({
+      blockId: entry.blockId,
+      kernelBlockId,
+      tier: entry.tier,
+      summarySeq: entry.summarySeq ?? null,
+      active: true,
+      parentBlockIds: [...entry.parentBlockIds]
+    });
+  }
+  const consumed = /* @__PURE__ */ new Set();
+  for (const entry of raw) {
+    for (const parent of entry.parentBlockIds) consumed.add(parent);
+  }
+  return raw.map((entry) => ({
+    ...entry,
+    active: !consumed.has(entry.blockId)
+  }));
+}
+function blockRefForSummarySeq(session, seq) {
+  const event = session.events[seq];
+  if (event?.type !== "user/message") return null;
+  const source = event.data.source;
+  if (source?.plugin !== "compact" || source.compactionId === void 0) return null;
+  const entry = blockRegistry(session).find((r) => r.blockId === source.compactionId);
+  if (entry === void 0) return null;
+  return entry.kernelBlockId;
+}
+function compactionIdsOfKernelBlocks(session, kernelBlockIds) {
+  if (kernelBlockIds.length === 0) return [];
+  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 summarySeqOfKernelBlock(session, kernelBlockId) {
+  const entry = blockRegistry(session).find((r) => r.kernelBlockId === kernelBlockId);
+  return entry?.active ? entry.summarySeq : null;
+}
+function checkpointBlockIdOf(events, seq) {
+  const event = events[seq];
+  if (event?.type !== "user/message") return null;
+  const source = event.data.source;
+  if (source?.plugin !== "compact" || source.compactionId === void 0) return null;
+  return source.compactionId;
+}
+function expandShadowedSeqs(session, blockId) {
+  const ledger = rebuildBlockLedger(session.events);
+  const byId = new Map(ledger.map((entry) => [entry.blockId, entry]));
+  const root = byId.get(blockId);
+  if (root === void 0) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (entry) => {
+    if (seen.has(entry.blockId)) return;
+    seen.add(entry.blockId);
+    for (const seq of entry.shadowedSeqs) {
+      const childId = checkpointBlockIdOf(session.events, seq);
+      const child = childId === null ? void 0 : byId.get(childId);
+      if (child !== void 0) visit(child);
+      else out.push(seq);
+    }
+  };
+  visit(root);
+  return out;
+}
+
+// src/state.ts
+function rebuildKernelBlocks(events) {
+  const ledger = rebuildBlockLedger(events);
+  if (ledger.length === 0) return [];
+  const kernelIdOf = /* @__PURE__ */ new Map();
+  const parentKernelIds = /* @__PURE__ */ new Map();
+  let next = 1;
+  for (const entry of ledger) {
+    let kernelBlockId;
+    if (entry.kernelBlockId !== void 0 && /^b\d+$/.test(entry.kernelBlockId)) {
+      kernelBlockId = entry.kernelBlockId;
+      const num = Number(kernelBlockId.slice(1));
+      if (Number.isInteger(num)) next = Math.max(next, num + 1);
+    } else {
+      kernelBlockId = `b${next}`;
+      next += 1;
+    }
+    kernelIdOf.set(entry.blockId, kernelBlockId);
+    parentKernelIds.set(
+      entry.blockId,
+      entry.parentBlockIds.map((parent) => kernelIdOf.get(parent)).filter((id) => id !== void 0)
+    );
+  }
+  const consumed = /* @__PURE__ */ new Set();
+  for (const entry of ledger) {
+    for (const parent of entry.parentBlockIds) consumed.add(parent);
+  }
+  const blocks = [];
+  for (const entry of ledger) {
+    const blockId = kernelIdOf.get(entry.blockId);
+    const direct = entry.directMessageIds ?? [...entry.shadowedSeqs.map(String)];
+    const effective = entry.effectiveMessageIds ?? (entry.tier > 1 ? entry.summarySeq === void 0 ? [...entry.shadowedSeqs.map(String)] : [String(entry.summarySeq)] : [...entry.shadowedSeqs.map(String)]);
+    blocks.push({
+      blockId,
+      runId: `r${blocks.length + 1}`,
+      tier: entry.tier,
+      summary: entry.summary,
+      directMessageIds: [...direct],
+      effectiveMessageIds: [...effective],
+      directBlockIds: parentKernelIds.get(entry.blockId) ?? [],
+      compressedTokens: entry.shadowedTokenCount,
+      createdAt: entry.createdAt,
+      survivedCount: 0,
+      generation: "young",
+      active: !consumed.has(entry.blockId)
+    });
+  }
+  return blocks;
+}
+function nextBlockIdAfter(events) {
+  const blocks = rebuildKernelBlocks(events);
+  let max = 0;
+  for (const block of blocks) {
+    const num = Number(block.blockId.slice(1));
+    if (Number.isInteger(num)) max = Math.max(max, num);
+  }
+  return max + 1;
+}
+var AcpStateStore = class {
+  states = /* @__PURE__ */ new Map();
+  /** Kernel state for one session, initialised on first access. */
+  stateFor(session) {
+    const id = session.id;
+    const existing = this.states.get(id);
+    if (existing !== void 0) return existing;
+    const state = createInitialState();
+    if (session.events.some((event) => event.type === "compaction/summary")) {
+      state.blocks = rebuildKernelBlocks(session.events);
+      state.nextBlockId = nextBlockIdAfter(session.events);
+    }
+    this.states.set(id, state);
+    return state;
+  }
+  set(session, state) {
+    this.states.set(session.id, state);
+  }
+  delete(session) {
+    this.states.delete(session.id);
+  }
+};
+
+// src/tools.ts
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { defaultCountTokens as defaultCountTokens2 } from "acp-kernel";
+
+// src/config.ts
+import { defaultConfig } from "acp-kernel";
+function kernelConfigFor(input) {
+  const nudgePatch = {};
+  if (input.nudgeMinContextLimitPct !== void 0) nudgePatch.minContextLimitPct = input.nudgeMinContextLimitPct;
+  if (input.nudgeMaxContextLimitPct !== void 0) nudgePatch.maxContextLimitPct = input.nudgeMaxContextLimitPct;
+  if (input.nudgeEmergencyThresholdPct !== void 0) nudgePatch.emergencyThresholdPct = input.nudgeEmergencyThresholdPct;
+  const overrides = { ...input.coreOverrides };
+  if (Object.keys(nudgePatch).length > 0) {
+    overrides.nudge = { ...defaultConfig(input.modelContextLimit).nudge, ...nudgePatch };
+  }
+  return defaultConfig(input.modelContextLimit, overrides);
+}
+
+// src/window.ts
+var DEFAULT_CONTEXT_WINDOW = 128e3;
+function windowSourceLabel(window) {
+  if (window.source === "explicit") return "configured";
+  if (window.source === "auto") {
+    return `auto-detected from ${window.provider ?? "?"}/${window.model ?? "?"}`;
+  }
+  return "default (auto-detection unavailable)";
+}
+async function detectContextWindow(agent, provider, model) {
+  const llm = agent.ctx?.get?.("llm");
+  if (llm?.resolveModelInfo === void 0) return null;
+  try {
+    const info = await llm.resolveModelInfo(provider, model);
+    const window = info?.context?.contextWindow;
+    if (typeof window === "number" && Number.isInteger(window) && window > 0) return window;
+    return null;
+  } catch {
+    return null;
+  }
+}
 
 // src/tools.ts
 function textOutput() {
@@ -412,8 +607,9 @@ async function handleCompress(env, args, exec) {
   const agent = requireAgent(exec);
   const session = agent.session;
   const state = env.store.stateFor(session);
-  const coreMessages = eventsToCoreMessages(surfaceEventsOf(session));
-  const tokenCount = coreMessages.reduce((sum, message) => sum + defaultCountTokens2(message.text ?? ""), 0);
+  const coreMessages = allLogMessages(session);
+  const surfaceMessages = eventsToCoreMessages(surfaceEventsOf(session));
+  const tokenCount = surfaceMessages.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);
@@ -422,8 +618,10 @@ async function handleCompress(env, args, exec) {
     const startSeq = parseSeq(range.startSeq);
     const endSeq = parseSeq(range.endSeq);
     const { start, end } = resolveSurfaceRange(session, startSeq, endSeq);
-    const startRef = byRaw[String(start)];
-    const endRef = byRaw[String(end)];
+    const startBlockRef = blockRefForSummarySeq(session, start);
+    const endBlockRef = blockRefForSummarySeq(session, end);
+    const startRef = startBlockRef ?? byRaw[String(start)];
+    const endRef = endBlockRef ?? byRaw[String(end)];
     if (startRef === void 0 || endRef === void 0) {
       throw new Error(
         `billion-context-dsh: seq ${start}..${end} has no assigned ref \u2014 the range must be on the current surface (run acp_status for the live seq list)`
@@ -445,15 +643,44 @@ async function handleCompress(env, args, exec) {
     messages: coreMessages,
     state: turn.state,
     config
+    // Deliberately NOT overriding protectedMessageIds: with the full log the
+    // kernel's recent/last-user protection is computed over the same
+    // 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) {
     return { text: `compress failed: ${applied.result.errors.join("; ")}` };
   }
   env.store.set(session, applied.state);
+  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]));
+  const warningByRangeKey = /* @__PURE__ */ new Map();
+  const freeWarnings = [];
+  for (const warning of applied.result.warnings) {
+    const match = /^Skipped range \((.+?)\.\.(.+?)\)/.exec(warning);
+    if (match !== null) {
+      const key = `${match[1]}::${match[2]}`;
+      const list = warningByRangeKey.get(key) ?? [];
+      list.push(warning);
+      warningByRangeKey.set(key, list);
+    } else {
+      freeWarnings.push(warning);
+    }
+  }
   const lines = [];
+  let skippedRanges = 0;
   for (let index = 0; index < ranges.length; index += 1) {
     const range = ranges[index];
     const original = args.content[index];
+    const key = `${range.startRef}::${range.endRef}`;
+    const block = blockByRangeKey.get(key);
+    if (block === void 0) {
+      skippedRanges += 1;
+      const warnings = warningByRangeKey.get(key) ?? [];
+      for (const warning of warnings) lines.push(`  ${warning}`);
+      continue;
+    }
     const { start, end } = range;
     const shadowed = shadowedSeqsOf(session, start, end);
     let shadowedTokens = 0;
@@ -461,6 +688,8 @@ async function handleCompress(env, args, exec) {
       const event = session.events[seq];
       if (event !== void 0) shadowedTokens += defaultCountTokens2(extractEventText(event));
     }
+    const tier = block.tier === 2 || block.tier === 3 ? block.tier : 1;
+    const parentBlockIds = compactionIdsOfKernelBlocks(session, block.directBlockIds);
     const { compactionId } = runCompactionTransaction(session, {
       start,
       end,
@@ -468,17 +697,27 @@ async function handleCompress(env, args, exec) {
       summary: [{ type: "text", text: original.summary }],
       shadowedTokenCount: shadowedTokens,
       provider: agent.options.provider ?? "",
-      model: agent.options.model ?? ""
+      model: agent.options.model ?? "",
+      tier,
+      kernelBlockId: block.blockId,
+      ...parentBlockIds.length === 0 ? {} : { parentBlockIds },
+      // Record the kernel block's raw coverage so a restarted engine
+      // rehydrates the SAME effective messages (a tier-2 block's coverage is
+      // its parents' originals, not the checkpoint node).
+      directMessageIds: block.directMessageIds,
+      effectiveMessageIds: block.effectiveMessageIds
     });
     const adjusted = start !== range.startSeq || end !== range.endSeq;
+    const tierLabel = tier === 1 ? "" : `, tier ${tier}`;
     lines.push(
-      `  block ${compactionId.slice(0, 8)}: seqs ${start}..${end}, ${shadowed.length} messages shadowed` + (adjusted ? ` (adjusted from ${range.startSeq}..${range.endSeq} to balanced edges)` : "")
+      `  block ${compactionId.slice(0, 8)}: seqs ${start}..${end}, ${shadowed.length} messages shadowed${tierLabel}` + (adjusted ? ` (adjusted from ${range.startSeq}..${range.endSeq} to balanced edges)` : "")
     );
   }
-  return {
-    text: `Compressed ${applied.result.blocksCreated} block(s), ~${applied.result.tokensCompressed} tokens reclaimed.
-${lines.join("\n")}`
-  };
+  const summaryLine = `Compressed ${applied.result.blocksCreated} block(s), ~${applied.result.tokensCompressed} tokens reclaimed.`;
+  const warningLines = [...freeWarnings.map((warning) => `  ${warning}`), ...lines];
+  const footer = skippedRanges > 0 ? `  (${skippedRanges} range(s) skipped \u2014 see warnings above)` : "";
+  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)." }
@@ -491,13 +730,14 @@ function handleDecompress(_env, args, exec) {
     return { text: `decompress: block "${args.blockId}" not found (see acp_status for the block list)` };
   }
   const parts = [];
-  for (const seq of block.shadowedSeqs) {
+  for (const seq of expandShadowedSeqs(session, block.blockId)) {
     const event = session.events[seq];
     const text = event === void 0 ? "" : extractEventText(event);
     if (text.length > 0) parts.push(`[seq ${seq}] ${text}`);
   }
+  const tierNote = block.tier > 1 ? ` (tier ${block.tier}, distills ${block.parentBlockIds.length} block(s))` : "";
   return {
-    text: `Block ${block.blockId} \u2014 ${block.summary}
+    text: `Block ${block.blockId} \u2014 ${block.summary}${tierNote}
 
 ${parts.join("\n\n") || "(no recoverable content)"}`
   };
@@ -528,18 +768,21 @@ ${original}`.toLowerCase();
   };
 }
 var statusParameters = {};
-function handleStatus(env, _args, exec) {
-  const session = requireAgent(exec).session;
+async function handleStatus(env, _args, exec) {
+  const agent = requireAgent(exec);
+  const session = agent.session;
   const ledger = rebuildBlockLedger(session.events);
   const totalTokens = ledger.reduce((sum, block) => sum + block.shadowedTokenCount, 0);
   const coreMessages = eventsToCoreMessages(surfaceEventsOf(session));
   const estimated = coreMessages.reduce((sum, message) => sum + defaultCountTokens2(message.text ?? ""), 0);
-  const limit = env.modelContextLimit;
+  const window = env.windowFor === void 0 ? { limit: env.modelContextLimit, source: "explicit" } : await env.windowFor(agent);
+  const limit = window.limit;
   const lines = [
     `ACP status \u2014 session ${session.id}`,
     `  blocks: ${ledger.length}`,
     `  tokens compressed: ${totalTokens}`,
     `  estimated context: ${estimated} / ${limit} (${Math.round(estimated / limit * 100)}%)`,
+    `  context window: ${limit} (${windowSourceLabel(window)})`,
     `  surface: ${surfaceSummary(session)}`
   ];
   for (const block of ledger.slice(0, 10)) {
@@ -582,7 +825,7 @@ function makeTools(env) {
       parameters: statusParameters,
       output: textOutput(),
       execute(args, exec) {
-        return Promise.resolve(handleStatus(env, args, exec));
+        return handleStatus(env, args, exec);
       }
     })
   ];
@@ -590,21 +833,24 @@ function makeTools(env) {
 
 // src/commands.ts
 import { defaultCountTokens as defaultCountTokens3 } from "acp-kernel";
-function statusText(env, agent) {
+async function statusText(env, agent) {
   const session = agent.session;
   const ledger = rebuildBlockLedger(session.events);
   const totalTokens = ledger.reduce((sum, block) => sum + block.shadowedTokenCount, 0);
   const coreMessages = eventsToCoreMessages(surfaceEventsOf(session));
   const estimated = coreMessages.reduce((sum, message) => sum + defaultCountTokens3(message.text ?? ""), 0);
-  const limit = env.modelContextLimit;
+  const window = env.windowFor === void 0 ? { limit: env.modelContextLimit, source: "explicit" } : await env.windowFor(agent);
+  const limit = window.limit;
   const lines = [
     `ACP status \u2014 session ${session.id}`,
     `  blocks: ${ledger.length}`,
     `  tokens compressed: ${totalTokens}`,
-    `  estimated context: ${estimated} / ${limit} (${Math.round(estimated / limit * 100)}%)`
+    `  estimated context: ${estimated} / ${limit} (${Math.round(estimated / limit * 100)}%)`,
+    `  context window: ${limit} (${windowSourceLabel(window)})`
   ];
   for (const block of ledger.slice(0, 10)) {
-    lines.push(`  - ${block.blockId.slice(0, 8)}: seqs ${block.start}..${block.end} \u2014 ${block.summary.slice(0, 80)}`);
+    const tier = block.tier > 1 ? ` [T${block.tier}]` : "";
+    lines.push(`  - ${block.blockId.slice(0, 8)}${tier}: seqs ${block.start}..${block.end} \u2014 ${block.summary.slice(0, 80)}`);
   }
   return lines.join("\n");
 }
@@ -620,6 +866,9 @@ function compressText(env, agent, args) {
   }
   const session = agent.session;
   const { start, end } = resolveSurfaceRange(session, startSeq, endSeq);
+  if (blockRefForSummarySeq(session, start) !== null || blockRefForSummarySeq(session, end) !== null) {
+    return "/acp compress: the range touches a compressed block summary node \u2014 distill it with the compress tool (seq-based batch), not /acp compress";
+  }
   const shadowed = shadowedSeqsOf(session, startSeq, endSeq);
   let shadowedTokens = 0;
   for (const seq of shadowed) {
@@ -643,7 +892,7 @@ function decompressText(_env, agent, args) {
   const ledger = rebuildBlockLedger(session.events);
   const block = ledger.find((entry) => entry.blockId.startsWith(args[0]));
   if (block === void 0) return `block "${args[0]}" not found (see /acp status)`;
-  const parts = block.shadowedSeqs.map((seq) => extractEventText(session.events[seq])).filter((text) => text.length > 0);
+  const parts = expandShadowedSeqs(session, block.blockId).map((seq) => extractEventText(session.events[seq])).filter((text) => text.length > 0);
   return `Block ${block.blockId} \u2014 ${block.summary}
 
 ${parts.join("\n\n") || "(no recoverable content)"}`;
@@ -655,7 +904,7 @@ function acpCommand(env) {
     handler: async (invocation) => {
       const raw = invocation.rawInput.trim();
       if (raw === "" || raw === "status") {
-        return { kind: "success", text: statusText(env, invocation.agent) };
+        return { kind: "success", text: await statusText(env, invocation.agent) };
       }
       if (raw.startsWith("compress")) {
         return { kind: "success", text: compressText(env, invocation.agent, raw.slice("compress".length).trim().split(/\s+/)) };
@@ -694,8 +943,9 @@ function measuredTokenCount(agent, coreMessages) {
 function buildNudge(agent, env, lastNudgeTurn) {
   const session = agent.session;
   const state = env.store.stateFor(session);
-  const coreMessages = eventsToCoreMessages(surfaceEventsOf(session));
-  const tokenCount = measuredTokenCount(agent, coreMessages);
+  const coreMessages = allLogMessages(session);
+  const surfaceMessages = eventsToCoreMessages(surfaceEventsOf(session));
+  const tokenCount = measuredTokenCount(agent, surfaceMessages);
   const config = kernelConfigFor(env);
   const turn = env.kernel.processTurn({ messages: coreMessages, state, config, tokenCount });
   env.store.set(session, turn.state);
@@ -717,7 +967,18 @@ 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(session)].join("\n");
+  const parts = [frame, "", guidance];
+  if ((nudge.tier === 2 || nudge.tier === 3) && (nudge.tierTargetBlocks?.length ?? 0) > 0) {
+    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;
+    parts.push(
+      `Tier ${nudge.tier}: ${targets.length} tier-${nudge.tier - 1} block(s) distillable (${tokens} tokens) \u2014 compress their summary node(s) [seqs ${summarySeqs.join(", ")}] to reclaim the original messages.`
+    );
+  }
+  parts.push(rangeTable(session));
+  return parts.join("\n");
 }
 
 // src/system-prompt.ts
@@ -734,15 +995,24 @@ Compression tools (refs are SURFACE SEQS, not ids):
 - search_context: find information inside compressed blocks BEFORE decompressing. search_context({ query }).
 - acp_status: current context usage and the live compressible-range list. Run it before compressing when in doubt.
 
+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.
+
 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 ACP_SYSTEM_PROMPT_ORDER = 150;
 
 // src/index.ts
 var DEFAULT_CONFIG = {
-  modelContextLimit: 128e3,
+  autoModelContextLimit: true,
   autoTools: true,
   autoCommand: true,
-  autoNudge: true
+  autoNudge: true,
+  // Nudge thresholds: engine defaults 0.70/0.85 — deliberately below the
+  // kernel/billion-context-pi 0.75/0.95. 0.95 leaves no room to act before
+  // the API rejects, and the host's compaction-basic line (thresholdRatio
+  // 0.80) shadows it in standard/code/cordis modes; 0.70 keeps the forced
+  // over-limit nudge ahead of that 80% line. Explicit values always win.
+  nudgeMaxContextLimitPct: 0.7,
+  nudgeEmergencyThresholdPct: 0.85
 };
 function resolveAcpConfig(config = {}) {
   return { ...DEFAULT_CONFIG, ...config };
@@ -755,6 +1025,8 @@ var AcpCompactionEngine = class extends CompactionEngine {
   /** Resolved engine configuration. */
   config;
   lastNudgeTurn = /* @__PURE__ */ new Map();
+  /** Per provider/model route the resolved window (probe failures cached too). */
+  windowCache = /* @__PURE__ */ new Map();
   constructor(ctx, config = {}) {
     super(ctx);
     this.config = resolveAcpConfig(config);
@@ -763,11 +1035,13 @@ var AcpCompactionEngine = class extends CompactionEngine {
     const env = {
       kernel: this.kernel,
       store: this.store,
-      modelContextLimit: this.config.modelContextLimit,
+      // Initial value before any probe; windowFor() replaces it per pre-step.
+      modelContextLimit: this.config.modelContextLimit ?? DEFAULT_CONTEXT_WINDOW,
       nudgeMinContextLimitPct: this.config.nudgeMinContextLimitPct,
       nudgeMaxContextLimitPct: this.config.nudgeMaxContextLimitPct,
       nudgeEmergencyThresholdPct: this.config.nudgeEmergencyThresholdPct,
-      coreOverrides: this.config.coreOverrides
+      coreOverrides: this.config.coreOverrides,
+      windowFor: (agent) => this.windowFor(agent)
     };
     const tools = ctx.get("tools");
     if (tools !== void 0) {
@@ -805,7 +1079,8 @@ var AcpCompactionEngine = class extends CompactionEngine {
       ctx.on("agent/pre-step", async (payload, next) => {
         const decision = await next();
         if (decision.kind === "reject") return decision;
-        const outcome = buildNudge(payload.agent, env, this.lastNudgeTurn);
+        const window = await this.windowFor(payload.agent);
+        const outcome = buildNudge(payload.agent, { ...env, modelContextLimit: window.limit }, this.lastNudgeTurn);
         if (outcome === null) return decision;
         return { kind: "enter", messages: [...decision.messages, outcome.message] };
       });
@@ -819,6 +1094,32 @@ var AcpCompactionEngine = class extends CompactionEngine {
       });
     }
   }
+  /**
+   * Resolve the effective context window for an agent. An explicitly
+   * configured `modelContextLimit` always wins (no probe). Otherwise probe the
+   * model's real window via `agent.ctx.llm.resolveModelInfo` (cached per
+   * provider/model route, probe failures cached too) and fall back to
+   * DEFAULT_CONTEXT_WINDOW when auto-detection is disabled or unavailable.
+   */
+  async windowFor(agent) {
+    if (this.config.modelContextLimit !== void 0) {
+      return { limit: this.config.modelContextLimit, source: "explicit" };
+    }
+    const provider = agent.options.provider ?? "";
+    const model = agent.options.model ?? "";
+    const key = `${provider}\0${model}`;
+    const cached = this.windowCache.get(key);
+    if (cached !== void 0) return cached;
+    let window;
+    if (!this.config.autoModelContextLimit) {
+      window = { limit: DEFAULT_CONTEXT_WINDOW, source: "default", provider, model };
+    } else {
+      const detected = await detectContextWindow(agent, provider, model);
+      window = detected === null ? { limit: DEFAULT_CONTEXT_WINDOW, source: "default", provider, model } : { limit: detected, source: "auto", provider, model };
+    }
+    this.windowCache.set(key, window);
+    return window;
+  }
   /** ACP is model-driven: automatic pressure policy never summarizes by itself. */
   async compactIfNeeded(_agent, _trigger, signal) {
     signal.throwIfAborted();
@@ -848,11 +1149,17 @@ export {
   ACP_SYSTEM_PROMPT_ORDER,
   AcpCompactionEngine,
   AcpStateStore,
+  DEFAULT_CONTEXT_WINDOW,
   acpCommand,
   assertNoActiveCompaction,
+  blockRefForSummarySeq,
+  blockRegistry,
   buildNudge,
+  compactionIdsOfKernelBlocks,
   index_default as default,
+  detectContextWindow,
   eventsToCoreMessages,
+  expandShadowedSeqs,
   extractEventText,
   findOpenTurn,
   kernelConfigFor,
@@ -863,6 +1170,8 @@ export {
   resolveSurfaceRange,
   runCompactionTransaction,
   shadowedSeqsOf,
-  surfaceEventsOf
+  summarySeqOfKernelBlock,
+  surfaceEventsOf,
+  windowSourceLabel
 };
 //# sourceMappingURL=index.js.map