billion-context-dsh 0.1.9 → 0.2.1

package/dist/index.js

@@ -582,9 +582,151 @@ 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, HOW_TO_COMPRESS_RULES, TIER2_DISTILL_RULES, TIER3_CONDENSE_RULES } from "acp-kernel";
+var NUDGE_ALLOWED = {
+  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"]),
+  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"]),
+  title: /* @__PURE__ */ new Set(["count"]),
+  line: /* @__PURE__ */ new Set(["start", "end", "count", "tokens"]),
+  footer: /* @__PURE__ */ new Set()
+};
+var TOOLS_ALLOWED = {
+  compress: /* @__PURE__ */ new Set(),
+  decompress: /* @__PURE__ */ new Set(),
+  searchContext: /* @__PURE__ */ new Set(),
+  acpStatus: /* @__PURE__ */ new Set()
+};
+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;
+  while ((match = re.exec(template)) !== null) {
+    const name = match[1];
+    if (!allowed.has(name)) {
+      throw new Error(
+        `${path} contains unknown placeholder {${name}} \u2014 allowed: ${[...allowed].join(", ") || "(none)"}`
+      );
+    }
+  }
+  return template;
+}
+function renderTemplate(template, vars) {
+  return template.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => {
+    const value = vars[name];
+    if (value === void 0) {
+      throw new Error(
+        `renderTemplate: missing value for placeholder {${name}} in template "${template.slice(0, 60)}\u2026"`
+      );
+    }
+    return String(value);
+  });
+}
+function mergeGroup(defaults, override, allowed, path) {
+  if (override == null) return defaults;
+  const out = {};
+  for (const key of Object.keys(defaults)) {
+    const value = override[key];
+    out[key] = value === null || value === void 0 ? defaults[key] : validateTemplate(value, allowed[key], `${path}.${String(key)}`);
+  }
+  return out;
+}
+function resolvePrompts(input) {
+  if (input === void 0) return DEFAULT_RESOLVED;
+  return {
+    nudge: mergeGroup(DEFAULT_PROMPTS.nudge, input.nudge, NUDGE_ALLOWED, "prompts.nudge"),
+    rangeTable: mergeGroup(DEFAULT_PROMPTS.rangeTable, input.rangeTable, RANGE_TABLE_ALLOWED, "prompts.rangeTable"),
+    tools: mergeGroup(DEFAULT_PROMPTS.tools, input.tools, TOOLS_ALLOWED, "prompts.tools"),
+    systemPromptTemplate: input.systemPrompt === null || input.systemPrompt === void 0 ? DEFAULT_PROMPTS.systemPromptTemplate : validateTemplate(input.systemPrompt, SYSTEM_ALLOWED, "prompts.systemPrompt")
+  };
+}
+function renderSystemPrompt(prompts) {
+  return renderTemplate(prompts.systemPromptTemplate, {
+    philosophy: COMPRESS_PHILOSOPHY,
+    howToCompressRules: HOW_TO_COMPRESS_RULES,
+    tier2DistillRules: TIER2_DISTILL_RULES,
+    tier3CondenseRules: TIER3_CONDENSE_RULES
+  });
+}
+var DEFAULT_PROMPTS = {
+  nudge: {
+    // 与 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}",
+    title: "Compressible ranges (suggestions only \u2014 compress any consumed span; refs are surface seqs):",
+    line: "  - seq {start}..{end} \u2014 {count} messages, ~{tokens} tokens",
+    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).",
+    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."
+  },
+  systemPromptTemplate: `Active Context Pruning \u2014 model-driven context management
+
+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 }).
+- 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.
+
+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;
+
+// src/nudge.ts
 function resolveTokenCount(agent, coreMessages) {
   const projections = agent.ctx?.get?.("sessionProjections");
   const projected = projections?.snapshot?.(agent.session)?.values?.contextPressure?.projectedTokens;
@@ -594,17 +736,24 @@ function resolveTokenCount(agent, coreMessages) {
   if (typeof surface === "number" && surface > 0) return surface;
   return coreMessages.reduce((sum, message) => sum + defaultCountTokens2(message.text ?? ""), 0);
 }
-function rangeTable(session) {
+function rangeTable(session, prompts = DEFAULT_RESOLVED) {
   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`);
+  const lines = ranges.map(
+    (range) => renderTemplate(prompts.rangeTable.line, {
+      start: range.start,
+      end: range.end,
+      count: range.count,
+      tokens: range.tokens
+    })
+  );
   return [
+    // 前导空串元素产生 nudge 中范围表前的唯一空行(§4:parts 层不再加分隔)。
     "",
-    `Surface: ${surfaceSummary(session)}`,
-    "Compressible ranges (suggestions only \u2014 compress any consumed span; refs are surface seqs):",
+    renderTemplate(prompts.rangeTable.header, { surface: surfaceSummary(session) }),
+    renderTemplate(prompts.rangeTable.title, { count: ranges.length }),
     ...lines,
-    "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.",
-    "Snapshot 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."
+    prompts.rangeTable.footer
   ].join("\n");
 }
 function measuredTokenCount(agent, coreMessages) {
@@ -626,28 +775,112 @@ 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, session);
+  const text = buildNudgeText(nudge, emergency, session, env.prompts);
   const message = createUserMessage2({
     content: [{ type: "text", text }],
     source: { kind: "plugin", plugin: "acp-nudge" }
   });
   return { message, emergency };
 }
-function buildNudgeText(nudge, emergency, session) {
+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 = 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.";
-  const parts = [frame, "", guidance];
+  const frame = renderTemplate(
+    emergency ? prompts.nudge.emergency : prompts.nudge.normal,
+    { 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;
     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.`
-    );
+    const tierLine = renderTemplate(prompts.nudge.tier, {
+      tier: nudge.tier,
+      count: targets.length,
+      prevTier: nudge.tier - 1,
+      tokens,
+      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));
+  if (prompts.nudge.tip !== "") parts.push("", prompts.nudge.tip);
   return parts.join("\n");
 }
 
@@ -691,11 +924,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: {
@@ -726,6 +970,22 @@ 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;
@@ -737,6 +997,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) {
@@ -935,10 +1202,11 @@ async function handleStatus(env, _args, exec) {
   return { text: lines.join("\n") };
 }
 function makeTools(env) {
+  const prompts = env.prompts ?? DEFAULT_RESOLVED;
   return [
     defineTool({
       name: "compress",
-      description: "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.",
+      description: prompts.tools.compress,
       parameters: compressParameters,
       output: textOutput(),
       async execute(args, exec) {
@@ -947,7 +1215,7 @@ function makeTools(env) {
     }),
     defineTool({
       name: "decompress",
-      description: "Recover the original content of a compressed block by its blockId (read-only; does not unshadow the range).",
+      description: prompts.tools.decompress,
       parameters: decompressParameters,
       output: textOutput(),
       execute(args, exec) {
@@ -956,7 +1224,7 @@ function makeTools(env) {
     }),
     defineTool({
       name: "search_context",
-      description: "Search inside compressed blocks (summaries and original content) for information the model no longer sees in context.",
+      description: prompts.tools.searchContext,
       parameters: searchParameters,
       output: textOutput(),
       execute(args, exec) {
@@ -965,7 +1233,7 @@ function makeTools(env) {
     }),
     defineTool({
       name: "acp_status",
-      description: "Report the ACP block ledger: compressed blocks, reclaimed tokens, and current context pressure.",
+      description: prompts.tools.acpStatus,
       parameters: statusParameters,
       output: textOutput(),
       execute(args, exec) {
@@ -1062,22 +1330,7 @@ function acpCommand(env) {
 }
 
 // src/system-prompt.ts
-import { COMPRESS_PHILOSOPHY } from "acp-kernel";
-var ACP_SYSTEM_PROMPT = `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.
-
-${COMPRESS_PHILOSOPHY}
-
-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 }).
-- 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.
-
-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 = renderSystemPrompt(DEFAULT_PROMPTS);
 var ACP_SYSTEM_PROMPT_ORDER = 150;
 
 // src/index.ts
@@ -1104,12 +1357,15 @@ var AcpCompactionEngine = class extends CompactionEngine {
   store;
   /** Resolved engine configuration. */
   config;
+  /** Resolved prompt templates (validated at construction — fail-fast on template typos). */
+  prompts;
   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);
+    this.prompts = resolvePrompts(config.prompts);
     const ports = this.config.countTokens !== void 0 ? { countTokens: this.config.countTokens } : {};
     this.kernel = createCore(ports);
     this.store = new AcpStateStore();
@@ -1122,7 +1378,8 @@ var AcpCompactionEngine = class extends CompactionEngine {
       nudgeMaxContextLimitPct: this.config.nudgeMaxContextLimitPct,
       nudgeEmergencyThresholdPct: this.config.nudgeEmergencyThresholdPct,
       coreOverrides: this.config.coreOverrides,
-      windowFor: (agent) => this.windowFor(agent)
+      windowFor: (agent) => this.windowFor(agent),
+      prompts: this.prompts
     };
     const tools = ctx.get("tools");
     if (tools !== void 0) {
@@ -1171,7 +1428,7 @@ var AcpCompactionEngine = class extends CompactionEngine {
       systemPrompt.section({
         name: "billion-context-dsh",
         order: ACP_SYSTEM_PROMPT_ORDER,
-        text: ACP_SYSTEM_PROMPT
+        text: renderSystemPrompt(this.prompts)
       });
     } else {
       let done = false;
@@ -1183,7 +1440,7 @@ var AcpCompactionEngine = class extends CompactionEngine {
         registry.section({
           name: "billion-context-dsh",
           order: ACP_SYSTEM_PROMPT_ORDER,
-          text: ACP_SYSTEM_PROMPT
+          text: renderSystemPrompt(this.prompts)
         });
       };
       ctx.on("internal/service", (name) => {
@@ -1248,6 +1505,8 @@ export {
   AcpStateStore,
   AlreadyCompressedRangeError,
   DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_PROMPTS,
+  DEFAULT_RESOLVED,
   acpCommand,
   assertNoActiveCompaction,
   blockRefForSummarySeq,
@@ -1264,7 +1523,10 @@ export {
   makeTools,
   projectEvent,
   rebuildBlockLedger,
+  renderSystemPrompt,
+  renderTemplate,
   resolveAcpConfig,
+  resolvePrompts,
   resolveSurfaceRange,
   resolveTokenCount,
   runCompactionTransaction,