@lexwdex-org/opencode-dcp 3.5.0 → 4.0.0

package/dist/index.js

@@ -1,118 +1,3 @@
-// lib/auto-prune.ts
-function tokenize(text) {
-  const tokens = /* @__PURE__ */ new Set();
-  for (const match of text.toLowerCase().matchAll(/[\p{L}\p{N}]+/gu)) {
-    const word = match[0];
-    if (/[\u4e00-\u9fff]/.test(word)) {
-      if (word.length === 1) {
-        tokens.add(word);
-        continue;
-      }
-      for (let index = 0; index < word.length - 1; index++) {
-        tokens.add(word.slice(index, index + 2));
-      }
-    } else {
-      tokens.add(word);
-    }
-  }
-  return tokens;
-}
-function jaccard(a, b) {
-  if (a.size === 0 && b.size === 0) return 1;
-  let intersection = 0;
-  for (const token of a) {
-    if (b.has(token)) intersection++;
-  }
-  return intersection / (a.size + b.size - intersection);
-}
-var WINDOW_SIZE = 4;
-var DRIFT_BASELINE = 3;
-var MIN_DRIFT_TOKENS = 6;
-function extractText(parts) {
-  const texts = [];
-  for (const part of parts) {
-    if (part && typeof part === "object" && part.type === "text" && typeof part.text === "string") {
-      texts.push(part.text);
-    }
-  }
-  return texts.join(" ").trim();
-}
-var AutoPruner = class {
-  constructor(config, now) {
-    this.config = config;
-    this.now = now ?? Date.now;
-  }
-  sessions = /* @__PURE__ */ new Map();
-  now;
-  observeUserMessage(sessionID, parts, at = this.now()) {
-    const state = this.state(sessionID);
-    const text = extractText(parts);
-    const signals = this.evaluate(state, text, at);
-    if (text) {
-      state.window.push(text);
-      if (state.window.length > WINDOW_SIZE) state.window.shift();
-    }
-    state.count += 1;
-    state.lastAt = at;
-    for (const signal of signals) {
-      if (!state.pendingSignals.includes(signal)) state.pendingSignals.push(signal);
-    }
-    return { signals };
-  }
-  consumePending(sessionID, at = this.now()) {
-    const state = this.sessions.get(sessionID);
-    if (!state || state.pendingSignals.length === 0) return null;
-    const signals = [...state.pendingSignals];
-    state.pendingSignals = [];
-    if (at - state.lastTriggerAt < this.config.cooldownMs) return null;
-    state.lastTriggerAt = at;
-    return signals;
-  }
-  markPruned(sessionID, at = this.now()) {
-    const state = this.sessions.get(sessionID);
-    if (!state) return;
-    state.count = 0;
-    state.window = [];
-    state.pendingSignals = [];
-    state.lastTriggerAt = at;
-  }
-  dropSession(sessionID) {
-    this.sessions.delete(sessionID);
-  }
-  evaluate(state, text, at) {
-    if (state.count + 1 < this.config.minMessages) return [];
-    const signals = [];
-    const enabled = this.config.signals;
-    if (enabled.idleGap && state.count > 0 && at - state.lastAt >= this.config.idleGapMs) {
-      signals.push("idle-gap");
-    }
-    if (enabled.topicDrift && state.count >= DRIFT_BASELINE && text) {
-      const current = tokenize(text);
-      if (current.size >= MIN_DRIFT_TOKENS) {
-        let max = 0;
-        for (let index = Math.max(0, state.window.length - DRIFT_BASELINE); index < state.window.length; index++) {
-          max = Math.max(max, jaccard(current, tokenize(state.window[index])));
-        }
-        if (max < this.config.driftThreshold) signals.push("topic-drift");
-      }
-    }
-    if (enabled.volume && state.count + 1 >= this.config.volumeThreshold) signals.push("volume");
-    return signals;
-  }
-  state(sessionID) {
-    let state = this.sessions.get(sessionID);
-    if (!state) {
-      state = { window: [], count: 0, lastAt: 0, pendingSignals: [], lastTriggerAt: 0 };
-      this.sessions.set(sessionID, state);
-      if (this.sessions.size > 200) {
-        const oldest = this.sessions.keys().next().value;
-        if (oldest !== void 0 && oldest !== sessionID) this.sessions.delete(oldest);
-      }
-    }
-    return state;
-  }
-};
-
 // lib/config.ts
 import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from "fs";
 import { join, dirname } from "path";
@@ -977,16 +862,403 @@ var ParseErrorCode;
   ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
 })(ParseErrorCode || (ParseErrorCode = {}));
 
+// lib/text.ts
+function tokenize(text) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const match of text.toLowerCase().matchAll(/[\p{L}\p{N}]+/gu)) {
+    const word = match[0];
+    if (/[\u4e00-\u9fff]/.test(word)) {
+      if (word.length === 1) {
+        tokens.add(word);
+        continue;
+      }
+      for (let index = 0; index < word.length - 1; index++) {
+        tokens.add(word.slice(index, index + 2));
+      }
+    } else {
+      tokens.add(word);
+    }
+  }
+  return tokens;
+}
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 1;
+  let intersection = 0;
+  for (const token of a) {
+    if (b.has(token)) intersection++;
+  }
+  return intersection / (a.size + b.size - intersection);
+}
+function estimateTokens(text) {
+  let cjk = 0;
+  let other = 0;
+  for (let index = 0; index < text.length; index++) {
+    const code = text.charCodeAt(index);
+    if (code >= 19968 && code <= 40959) cjk++;
+    else other++;
+  }
+  return Math.ceil(cjk * 0.7 + other / 4);
+}
+function hashString(text) {
+  let hash = 5381;
+  for (let index = 0; index < text.length; index++) {
+    hash = (hash << 5) + hash + text.charCodeAt(index) | 0;
+  }
+  return (hash >>> 0).toString(36);
+}
+function firstLine(text, maxChars) {
+  const line = text.split("\n", 1)[0]?.trim() ?? "";
+  return line.length > maxChars ? `${line.slice(0, maxChars)}\u2026` : line;
+}
+function truncateMiddle(text, keepChars, note) {
+  if (text.length <= keepChars) return text;
+  const head = Math.ceil(keepChars / 2);
+  const tail = Math.floor(keepChars / 2);
+  return `${text.slice(0, head)}
+${note}
+${text.slice(text.length - tail)}`;
+}
+
+// lib/dtc/digest.ts
+var INTENT_MAX = 120;
+var RESULT_MAX = 160;
+var MAX_TOOLS = 8;
+var MAX_FILES = 6;
+var DIGEST_MAX_CHARS = 600;
+var PATH_KEYS = ["filePath", "path", "file", "filename", "pattern", "directory"];
+function toolSummary(parts) {
+  const counts = /* @__PURE__ */ new Map();
+  const files = [];
+  let errors = 0;
+  for (const part of parts) {
+    if (!part || typeof part !== "object" || part.type !== "tool") continue;
+    const name = part.tool ?? "tool";
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+    if (part.state?.status === "error") errors++;
+    const input = part.state?.input;
+    if (input && typeof input === "object") {
+      for (const key of PATH_KEYS) {
+        const value = input[key];
+        if (typeof value === "string" && value && !files.includes(value)) {
+          files.push(value);
+        }
+      }
+      const command = input.command;
+      if (typeof command === "string" && command && !files.includes(firstLine(command, 60))) {
+        files.push(firstLine(command, 60));
+      }
+    }
+  }
+  const actions = [...counts.entries()].map(([name, count]) => count > 1 ? `${name}\xD7${count}` : name).slice(0, MAX_TOOLS).join(", ");
+  return { actions, files: files.slice(0, MAX_FILES).join(" "), errors };
+}
+function digestTurn(messages, turn, index) {
+  const slice = messages.slice(turn.start, turn.end);
+  const user = slice[0];
+  const intent = firstLine(userText(user), INTENT_MAX) || "(\u65E0\u6587\u672C)";
+  const { actions, files, errors } = toolSummary(
+    slice.flatMap((m) => m && typeof m === "object" ? m.parts ?? [] : [])
+  );
+  let result = "";
+  for (let i = slice.length - 1; i >= 0; i--) {
+    if (slice[i]?.info?.role !== "assistant") continue;
+    const text = assistantText(slice[i]);
+    if (text) {
+      result = firstLine(text, RESULT_MAX);
+      break;
+    }
+  }
+  const parts = [`[DCP\xB7\u8F6E${index}]`, `\u610F\u56FE: ${intent}`];
+  if (actions) parts.push(`\u52A8\u4F5C: ${actions}`);
+  if (files) parts.push(`\u6D89\u53CA: ${files}`);
+  if (result) parts.push(`\u7ED3\u679C: ${result}`);
+  if (errors > 0) parts.push(`\u9519\u8BEF\xD7${errors}`);
+  const digest = parts.join(" | ");
+  return digest.length > DIGEST_MAX_CHARS ? `${digest.slice(0, DIGEST_MAX_CHARS)}\u2026` : digest;
+}
+function userText(message) {
+  const parts = message?.parts ?? [];
+  const texts = parts.filter((p) => p?.type === "text" && typeof p.text === "string").map((p) => p.text);
+  return texts.join(" ").trim();
+}
+function assistantText(message) {
+  return userText(message);
+}
+function digestKey(messages, turn) {
+  const first = messages[turn.start];
+  const id = first?.info?.id ?? "noid";
+  let shape = "";
+  for (let i = turn.start; i < turn.end && i < messages.length; i++) {
+    const message = messages[i];
+    shape += `${message?.info?.role ?? "?"}:${(message?.parts ?? []).length};`;
+    for (const part of message?.parts ?? []) {
+      if (!part || typeof part !== "object") continue;
+      if (part.type === "text" && typeof part.text === "string") {
+        shape += part.text.slice(0, 64);
+      } else if (part.type === "tool") {
+        shape += `${part.tool ?? "tool"}:${part.state?.status ?? "?"}:${(part.state?.output ?? "").length}`;
+      }
+    }
+  }
+  return `${id}:${hashString(shape)}`;
+}
+function findTopicBoundaries(messages, turns, driftThreshold) {
+  const boundaries = [];
+  let previous;
+  for (let t = 0; t < turns.length; t++) {
+    const text = userText(messages[turns[t].start]);
+    const tokens = tokenize(text);
+    if (tokens.size < 6) continue;
+    if (previous && jaccard(tokens, previous) < driftThreshold) boundaries.push(t);
+    previous = tokens;
+  }
+  return boundaries;
+}
+function estimateSlice(messages, start, end) {
+  let tokens = 0;
+  for (let i = start; i < end && i < messages.length; i++) {
+    for (const part of messages[i]?.parts ?? []) {
+      if (!part || typeof part !== "object") continue;
+      if (typeof part.text === "string") tokens += estimateTokens(part.text);
+      const state = part.state;
+      if (!state) continue;
+      if (state.time?.compacted) {
+        tokens += 8;
+        continue;
+      }
+      if (typeof state.output === "string") tokens += estimateTokens(state.output);
+      if (state.input) tokens += estimateTokens(JSON.stringify(state.input));
+    }
+  }
+  return tokens;
+}
+
+// lib/dtc/engine.ts
+var DTC_DEFAULTS = {
+  tailTurns: 4,
+  lowWatermarkRatio: 0.5,
+  targetRatio: 0.7,
+  driftThreshold: 0.18,
+  toolOutputKeepChars: 4e3
+};
+var C_ZONE_MAX_TURNS = 8;
+var M_ZONE_MAX_TURNS = 12;
+var M_TEXT_KEEP_CHARS = 200;
+var FOLDED_TEXT = " ";
+var NO_STATS = {
+  messages: 0,
+  userTurns: 0,
+  level: 0,
+  estimatedBefore: 0,
+  estimatedAfter: 0,
+  contextTokens: 0,
+  foldedTools: 0,
+  foldedTexts: 0,
+  digestedTurns: 0,
+  skipped: void 0
+};
+function segmentTurns(messages) {
+  const turns = [];
+  for (let i = 0; i < messages.length; i++) {
+    const info = messages[i]?.info;
+    if (info?.role !== "user") continue;
+    if ((messages[i]?.parts ?? []).some((p) => p?.type === "compaction")) continue;
+    turns.push({ start: i, end: messages.length });
+  }
+  for (let i = 0; i < turns.length - 1; i++) {
+    turns[i].end = turns[i + 1].start;
+  }
+  return turns;
+}
+function transformMessages(messages, deps) {
+  const stats = { ...NO_STATS };
+  if (!Array.isArray(messages) || messages.length === 0) return stats;
+  stats.messages = messages.length;
+  const sessionID = findSessionID(messages);
+  if (sessionID && deps.state.consumeCompactionSkip(sessionID)) {
+    stats.skipped = "compaction";
+    return stats;
+  }
+  const turns = segmentTurns(messages);
+  stats.userTurns = turns.length;
+  const { config, state } = deps;
+  if (turns.length <= config.tailTurns) {
+    stats.skipped = "short";
+    return stats;
+  }
+  const contextTokens = sessionID ? state.contextTokens(sessionID) : void 0;
+  if (!contextTokens) {
+    stats.skipped = "unknown-context";
+    return stats;
+  }
+  stats.contextTokens = contextTokens;
+  const headTurns = turns.slice(0, turns.length - config.tailTurns);
+  const estimatedBefore = estimateSlice(messages, 0, messages.length);
+  stats.estimatedBefore = estimatedBefore;
+  const lowWatermark = Math.floor(contextTokens * config.lowWatermarkRatio);
+  const target = Math.floor(contextTokens * config.targetRatio);
+  const minLevel = sessionID ? state.minLevel(sessionID) : 0;
+  if (estimatedBefore <= lowWatermark && minLevel === 0) {
+    stats.estimatedAfter = estimatedBefore;
+    return stats;
+  }
+  const zones = computeZones(messages, headTurns, sessionID, state, config);
+  const now = (deps.now ?? Date.now)();
+  let level = Math.max(1, minLevel);
+  applyLevel(messages, headTurns, zones, level, deps, stats, now);
+  let estimatedAfter = estimateSlice(messages, 0, messages.length);
+  while (estimatedAfter > target && level < 3) {
+    level = level + 1;
+    applyLevel(messages, headTurns, zones, level, deps, stats, now);
+    estimatedAfter = estimateSlice(messages, 0, messages.length);
+  }
+  stats.level = level;
+  stats.estimatedAfter = estimatedAfter;
+  deps.logger?.debug("DTC transform", {
+    sessionId: sessionID,
+    messages: stats.messages,
+    userTurns: stats.userTurns,
+    level,
+    estimatedBefore,
+    estimatedAfter,
+    contextTokens,
+    foldedTools: stats.foldedTools,
+    digestedTurns: stats.digestedTurns
+  });
+  return stats;
+}
+function computeZones(messages, headTurns, sessionID, state, config) {
+  const boundaries = findTopicBoundaries(messages, headTurns, config.driftThreshold);
+  const lastBoundary = boundaries.length > 0 ? boundaries[boundaries.length - 1] : 0;
+  const secondLast = boundaries.length > 1 ? boundaries[boundaries.length - 2] : 0;
+  let markStart = 0;
+  const markAt = sessionID ? state.boundaryMark(sessionID) : void 0;
+  if (markAt !== void 0) {
+    for (let t = 0; t < headTurns.length; t++) {
+      const created = messages[headTurns[t].start]?.info?.time?.created;
+      if (typeof created === "number" && created <= markAt) markStart = t + 1;
+    }
+  }
+  const cStart = Math.min(
+    headTurns.length,
+    Math.max(lastBoundary, markStart, headTurns.length - C_ZONE_MAX_TURNS)
+  );
+  const mStart = Math.min(cStart, Math.max(secondLast, cStart - M_ZONE_MAX_TURNS));
+  return { mStart, cStart };
+}
+function applyLevel(messages, headTurns, zones, level, deps, stats, now) {
+  const prev = level === 1 ? -1 : level - 1;
+  if (level >= 1 && prev < 1) {
+    for (let t = 0; t < zones.mStart; t++) {
+      foldDistant(messages, headTurns[t], t + 1, deps, stats, now);
+    }
+  }
+  if (level >= 2 && prev < 2) {
+    for (let t = zones.mStart; t < zones.cStart; t++) {
+      foldMiddle(messages, headTurns[t], stats, now);
+    }
+  }
+  if (level >= 3 && prev < 3) {
+    for (let t = zones.cStart; t < headTurns.length; t++) {
+      foldCurrent(messages, headTurns[t], deps.config.toolOutputKeepChars, stats);
+    }
+  }
+}
+function foldDistant(messages, turn, ordinal, deps, stats, now) {
+  const key = digestKey(messages, turn);
+  let digest = deps.state.cachedDigest(key);
+  if (digest === void 0) {
+    digest = digestTurn(messages, turn, ordinal);
+    deps.state.storeDigest(key, digest);
+  }
+  stats.digestedTurns++;
+  let digestPlaced = false;
+  for (let i = turn.start; i < turn.end; i++) {
+    const message = messages[i];
+    for (const part of message?.parts ?? []) {
+      if (!part || typeof part !== "object") continue;
+      if (foldToolPart(part, now, true)) {
+        stats.foldedTools++;
+        continue;
+      }
+      if (part.type === "reasoning" && typeof part.text === "string" && part.text.length > 0) {
+        part.text = FOLDED_TEXT;
+        continue;
+      }
+      if (part.type === "text" && typeof part.text === "string") {
+        if (!digestPlaced && message?.info?.role === "user") {
+          part.text = digest;
+          digestPlaced = true;
+        } else {
+          part.text = FOLDED_TEXT;
+        }
+        stats.foldedTexts++;
+      }
+    }
+  }
+}
+function foldMiddle(messages, turn, stats, now) {
+  for (let i = turn.start; i < turn.end; i++) {
+    for (const part of messages[i]?.parts ?? []) {
+      if (!part || typeof part !== "object") continue;
+      if (foldToolPart(part, now, false)) {
+        stats.foldedTools++;
+        continue;
+      }
+      if (part.type === "reasoning" && typeof part.text === "string" && part.text.length > 0) {
+        part.text = FOLDED_TEXT;
+        continue;
+      }
+      if (part.type === "text" && typeof part.text === "string" && part.text.length > M_TEXT_KEEP_CHARS) {
+        part.text = firstLine(part.text, M_TEXT_KEEP_CHARS) || FOLDED_TEXT;
+        stats.foldedTexts++;
+      }
+    }
+  }
+}
+function foldCurrent(messages, turn, keepChars, stats) {
+  for (let i = turn.start; i < turn.end; i++) {
+    for (const part of messages[i]?.parts ?? []) {
+      if (!part || typeof part !== "object" || part.type !== "tool") continue;
+      const state = part.state;
+      if (!state || state.status !== "completed") continue;
+      const output = state.output;
+      if (typeof output !== "string" || output.length <= keepChars) continue;
+      state.output = truncateMiddle(
+        output,
+        keepChars,
+        `[DCP \u5DF2\u6298\u53E0 ${output.length - keepChars} \u5B57\u7B26]`
+      );
+      stats.foldedTools++;
+    }
+  }
+}
+function foldToolPart(part, now, clearInput) {
+  if (part.type !== "tool") return false;
+  const state = part.state;
+  if (!state || state.status !== "completed") return false;
+  if (state.time && typeof state.time === "object") {
+    state.time.compacted = now;
+  } else {
+    state.time = { compacted: now };
+  }
+  if (clearInput && state.input && typeof state.input === "object") {
+    state.input = {};
+  }
+  return true;
+}
+function findSessionID(messages) {
+  for (const message of messages) {
+    const id = message?.info?.sessionID;
+    if (typeof id === "string" && id) return id;
+  }
+  return void 0;
+}
+
 // lib/config.ts
-var DEFAULT_FAILURE_COOLDOWN_MS = 3e4;
-var DEFAULT_AUTO_PRUNE = {
+var DEFAULT_DTC = {
   enabled: true,
-  signals: { topicDrift: true, volume: false, idleGap: false },
-  minMessages: 8,
-  volumeThreshold: 30,
-  driftThreshold: 0.18,
-  idleGapMs: 30 * 6e4,
-  cooldownMs: 5 * 6e4
+  ...DTC_DEFAULTS
 };
 var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "$schema",
@@ -998,19 +1270,13 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "commands.enabled",
   "experimental",
   "experimental.customPrompts",
-  "summarize",
-  "summarize.failureCooldownMs",
-  "autoPrune",
-  "autoPrune.enabled",
-  "autoPrune.signals",
-  "autoPrune.signals.topicDrift",
-  "autoPrune.signals.volume",
-  "autoPrune.signals.idleGap",
-  "autoPrune.minMessages",
-  "autoPrune.volumeThreshold",
-  "autoPrune.driftThreshold",
-  "autoPrune.idleGapMs",
-  "autoPrune.cooldownMs",
+  "dtc",
+  "dtc.enabled",
+  "dtc.tailTurns",
+  "dtc.lowWatermarkRatio",
+  "dtc.targetRatio",
+  "dtc.driftThreshold",
+  "dtc.toolOutputKeepChars",
   "tool",
   "tool.enabled"
 ]);
@@ -1055,7 +1321,21 @@ var DEPRECATED_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "pruneNotificationType",
   "protectedFilePatterns",
   "commands.protectedTools",
-  "experimental.allowSubAgents"
+  "experimental.allowSubAgents",
+  "summarize",
+  "summarize.failureCooldownMs",
+  "autoPrune",
+  "autoPrune.enabled",
+  "autoPrune.signals",
+  "autoPrune.signals.topicDrift",
+  "autoPrune.signals.volume",
+  "autoPrune.signals.idleGap",
+  "autoPrune.autoContinue",
+  "autoPrune.minMessages",
+  "autoPrune.volumeThreshold",
+  "autoPrune.driftThreshold",
+  "autoPrune.idleGapMs",
+  "autoPrune.cooldownMs"
 ]);
 function getConfigKeyPaths(obj, prefix = "") {
   const keys = [];
@@ -1097,11 +1377,7 @@ function validateConfigTypes(config) {
   const commands = config.commands;
   if (commands !== void 0) {
     if (typeof commands !== "object" || commands === null || Array.isArray(commands)) {
-      errors.push({
-        key: "commands",
-        expected: "object",
-        actual: typeof commands
-      });
+      errors.push({ key: "commands", expected: "object", actual: typeof commands });
     } else if (commands.enabled !== void 0 && typeof commands.enabled !== "boolean") {
       errors.push({
         key: "commands.enabled",
@@ -1113,11 +1389,7 @@ function validateConfigTypes(config) {
   const experimental = config.experimental;
   if (experimental !== void 0) {
     if (typeof experimental !== "object" || experimental === null || Array.isArray(experimental)) {
-      errors.push({
-        key: "experimental",
-        expected: "object",
-        actual: typeof experimental
-      });
+      errors.push({ key: "experimental", expected: "object", actual: typeof experimental });
     } else if (experimental.customPrompts !== void 0 && typeof experimental.customPrompts !== "boolean") {
       errors.push({
         key: "experimental.customPrompts",
@@ -1126,125 +1398,65 @@ function validateConfigTypes(config) {
       });
     }
   }
-  const summarize = config.summarize;
-  if (summarize !== void 0) {
-    if (typeof summarize !== "object" || summarize === null || Array.isArray(summarize)) {
-      errors.push({
-        key: "summarize",
-        expected: "object",
-        actual: typeof summarize
-      });
+  const dtc = config.dtc;
+  if (dtc !== void 0) {
+    if (typeof dtc !== "object" || dtc === null || Array.isArray(dtc)) {
+      errors.push({ key: "dtc", expected: "object", actual: typeof dtc });
     } else {
-      if (summarize.failureCooldownMs !== void 0 && (typeof summarize.failureCooldownMs !== "number" || !Number.isFinite(summarize.failureCooldownMs) || summarize.failureCooldownMs < 0)) {
-        errors.push({
-          key: "summarize.failureCooldownMs",
-          expected: "non-negative finite number",
-          actual: JSON.stringify(summarize.failureCooldownMs)
-        });
+      if (dtc.enabled !== void 0 && typeof dtc.enabled !== "boolean") {
+        errors.push({ key: "dtc.enabled", expected: "boolean", actual: typeof dtc.enabled });
       }
-    }
-  }
-  const autoPrune = config.autoPrune;
-  if (autoPrune !== void 0) {
-    if (typeof autoPrune !== "object" || autoPrune === null || Array.isArray(autoPrune)) {
-      errors.push({
-        key: "autoPrune",
-        expected: "object",
-        actual: typeof autoPrune
-      });
-    } else {
       const numericKeys = [
-        ["minMessages", 1, Number.POSITIVE_INFINITY],
-        ["volumeThreshold", 2, Number.POSITIVE_INFINITY],
+        ["tailTurns", 0, Number.POSITIVE_INFINITY],
+        ["lowWatermarkRatio", 0, 1],
+        ["targetRatio", 0, 1],
         ["driftThreshold", 0, 1],
-        ["idleGapMs", 0, Number.POSITIVE_INFINITY],
-        ["cooldownMs", 0, Number.POSITIVE_INFINITY]
+        ["toolOutputKeepChars", 200, Number.POSITIVE_INFINITY]
       ];
       for (const [key, min, max] of numericKeys) {
-        const value = autoPrune[key];
+        const value = dtc[key];
         if (value !== void 0 && (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max)) {
           errors.push({
-            key: `autoPrune.${key}`,
+            key: `dtc.${key}`,
             expected: `number in [${min}, ${max === Number.POSITIVE_INFINITY ? "\u221E" : max}]`,
             actual: JSON.stringify(value)
           });
         }
       }
-      for (const key of ["enabled"]) {
-        const value = autoPrune[key];
-        if (value !== void 0 && typeof value !== "boolean") {
-          errors.push({
-            key: `autoPrune.${key}`,
-            expected: "boolean",
-            actual: typeof value
-          });
-        }
-      }
-      const signals = autoPrune.signals;
-      if (signals !== void 0) {
-        if (typeof signals !== "object" || signals === null || Array.isArray(signals)) {
-          errors.push({
-            key: "autoPrune.signals",
-            expected: "object",
-            actual: typeof signals
-          });
-        } else {
-          for (const key of ["topicDrift", "volume", "idleGap"]) {
-            const value = signals[key];
-            if (value !== void 0 && typeof value !== "boolean") {
-              errors.push({
-                key: `autoPrune.signals.${key}`,
-                expected: "boolean",
-                actual: typeof value
-              });
-            }
-          }
-        }
-      }
     }
   }
   const tool2 = config.tool;
   if (tool2 !== void 0) {
     if (typeof tool2 !== "object" || tool2 === null || Array.isArray(tool2)) {
-      errors.push({
-        key: "tool",
-        expected: "object",
-        actual: typeof tool2
-      });
+      errors.push({ key: "tool", expected: "object", actual: typeof tool2 });
     } else if (tool2.enabled !== void 0 && typeof tool2.enabled !== "boolean") {
-      errors.push({
-        key: "tool.enabled",
-        expected: "boolean",
-        actual: typeof tool2.enabled
-      });
+      errors.push({ key: "tool.enabled", expected: "boolean", actual: typeof tool2.enabled });
     }
   }
   return errors;
 }
-function needsSignalsMigrationHint(configData) {
+function legacyDriftThreshold(configData) {
   const autoPrune = configData.autoPrune;
-  return autoPrune !== null && typeof autoPrune === "object" && !Array.isArray(autoPrune) && autoPrune.enabled === true && autoPrune.signals === void 0;
+  if (autoPrune === null || typeof autoPrune !== "object" || Array.isArray(autoPrune)) {
+    return void 0;
+  }
+  const value = autoPrune.driftThreshold;
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1 ? value : void 0;
 }
 function showConfigWarnings(ctx, configPath, configData, isProject) {
   const invalidKeys = getInvalidConfigKeys(configData);
   const deprecatedKeys = getDeprecatedConfigKeys(configData);
   const typeErrors = validateConfigTypes(configData);
-  const signalsHint = needsSignalsMigrationHint(configData);
-  if (!signalsHint && invalidKeys.length === 0 && deprecatedKeys.length === 0 && typeErrors.length === 0) {
+  if (invalidKeys.length === 0 && deprecatedKeys.length === 0 && typeErrors.length === 0) {
     return;
   }
   const configType = isProject ? "project config" : "config";
   const messages = [];
-  if (signalsHint) {
-    messages.push(
-      "auto-prune signals `volume` and `idleGap` are now disabled by default; re-enable via autoPrune.signals.*"
-    );
-  }
   if (deprecatedKeys.length > 0) {
     const keyList = deprecatedKeys.slice(0, 3).join(", ");
     const suffix = deprecatedKeys.length > 3 ? ` (+${deprecatedKeys.length - 3} more)` : "";
     messages.push(
-      `Removed legacy compression keys are ignored: ${keyList}${suffix}. Pruning now runs through OpenCode's native compaction.`
+      `Removed legacy keys are ignored: ${keyList}${suffix}. Compression now runs as dynamic request-time folding (dtc.*).`
     );
   }
   if (invalidKeys.length > 0) {
@@ -1286,10 +1498,7 @@ var defaultConfig = {
   experimental: {
     customPrompts: false
   },
-  summarize: {
-    failureCooldownMs: DEFAULT_FAILURE_COOLDOWN_MS
-  },
-  autoPrune: { ...DEFAULT_AUTO_PRUNE },
+  dtc: { ...DEFAULT_DTC },
   tool: {
     enabled: true
   }
@@ -1375,33 +1584,19 @@ function mergeExperimental(base, override) {
     customPrompts: typeof override.customPrompts === "boolean" ? override.customPrompts : base.customPrompts
   };
 }
-function mergeSummarize(base, override) {
-  if (!override) {
-    return base;
-  }
-  return {
-    failureCooldownMs: typeof override.failureCooldownMs === "number" && Number.isFinite(override.failureCooldownMs) && override.failureCooldownMs >= 0 ? override.failureCooldownMs : base.failureCooldownMs
-  };
-}
-function mergeAutoPrune(base, override) {
+function mergeDtc(base, override, legacyDrift) {
+  const driftFallback = legacyDrift ?? base.driftThreshold;
   if (!override || typeof override !== "object" || Array.isArray(override)) {
-    return base;
+    return { ...base, driftThreshold: driftFallback };
   }
-  const number = (key, min, max = Number.POSITIVE_INFINITY) => typeof override[key] === "number" && Number.isFinite(override[key]) && override[key] >= min && override[key] <= max ? override[key] : base[key];
-  const signalsOverride = override.signals;
-  const signals = signalsOverride && typeof signalsOverride === "object" && !Array.isArray(signalsOverride) ? {
-    topicDrift: typeof signalsOverride.topicDrift === "boolean" ? signalsOverride.topicDrift : base.signals.topicDrift,
-    volume: typeof signalsOverride.volume === "boolean" ? signalsOverride.volume : base.signals.volume,
-    idleGap: typeof signalsOverride.idleGap === "boolean" ? signalsOverride.idleGap : base.signals.idleGap
-  } : base.signals;
+  const number = (key, min, max) => typeof override[key] === "number" && Number.isFinite(override[key]) && override[key] >= min && override[key] <= max ? override[key] : base[key];
   return {
     enabled: typeof override.enabled === "boolean" ? override.enabled : base.enabled,
-    signals,
-    minMessages: number("minMessages", 1),
-    volumeThreshold: number("volumeThreshold", 2),
-    driftThreshold: number("driftThreshold", 0, 1),
-    idleGapMs: number("idleGapMs", 0),
-    cooldownMs: number("cooldownMs", 0)
+    tailTurns: number("tailTurns", 0, Number.POSITIVE_INFINITY),
+    lowWatermarkRatio: number("lowWatermarkRatio", 0, 1),
+    targetRatio: number("targetRatio", 0, 1),
+    driftThreshold: typeof override.driftThreshold === "number" && Number.isFinite(override.driftThreshold) && override.driftThreshold >= 0 && override.driftThreshold <= 1 ? override.driftThreshold : driftFallback,
+    toolOutputKeepChars: number("toolOutputKeepChars", 200, Number.POSITIVE_INFINITY)
   };
 }
 function mergeTool(base, override) {
@@ -1417,8 +1612,7 @@ function deepCloneConfig(config) {
     ...config,
     commands: { ...config.commands },
     experimental: { ...config.experimental },
-    summarize: { ...config.summarize },
-    autoPrune: { ...config.autoPrune, signals: { ...config.autoPrune.signals } },
+    dtc: { ...config.dtc },
     tool: { ...config.tool }
   };
 }
@@ -1430,8 +1624,7 @@ function mergeLayer(config, data) {
     language: data.language === "zh" || data.language === "en" ? data.language : config.language,
     commands: mergeCommands(config.commands, data.commands),
     experimental: mergeExperimental(config.experimental, data.experimental),
-    summarize: mergeSummarize(config.summarize, data.summarize),
-    autoPrune: mergeAutoPrune(config.autoPrune, data.autoPrune),
+    dtc: mergeDtc(config.dtc, data.dtc, legacyDriftThreshold(data)),
     tool: mergeTool(config.tool, data.tool)
   };
 }
@@ -1485,225 +1678,76 @@ Using previous/default values`
   return config;
 }
 
-// lib/session-boundary.ts
-var BOUNDARY_QUIET_MS = 2e3;
-var PROBE_TIMEOUT_MS = 2e3;
-var BUSY_EVIDENCE_TTL_MS = 10 * 6e4;
-var MAX_TRACKED_SESSIONS = 500;
-var SessionBoundaryTracker = class {
+// lib/dtc/state.ts
+var SESSION_LIMIT = 500;
+var DIGEST_LIMIT = 2e3;
+function lruSet(map, key, value, limit) {
+  if (map.has(key)) map.delete(key);
+  map.set(key, value);
+  while (map.size > limit) {
+    const oldest = map.keys().next().value;
+    if (oldest === void 0) break;
+    map.delete(oldest);
+  }
+}
+var DtcState = class {
   sessions = /* @__PURE__ */ new Map();
-  listeners = [];
-  probeBusy;
-  logger;
-  now;
-  setTimer;
-  clearTimer;
-  constructor(deps) {
-    this.probeBusy = deps.probeBusy;
-    this.logger = deps.logger;
-    this.now = deps.now ?? Date.now;
-    this.setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
-    this.clearTimer = deps.clearTimer ?? ((t) => clearTimeout(t));
-  }
-  /** Register an at-rest listener; listeners fire in registration order
-   * (1. deferred drain, 2. heuristic auto prune) and are individually
-   * error-isolated: a throw or rejection is warn-logged and never blocks
-   * later listeners nor escapes into the timer callback. */
-  onAtRest(listener) {
-    this.listeners.push(listener);
-  }
-  /** Primary input: `session.status` event payload status type. */
-  observeStatus(sessionID, statusType) {
-    if (!sessionID) return;
-    const entry = this.entry(sessionID);
-    entry.sawStatus = true;
-    if (statusType === "busy" || statusType === "retry") {
-      this.transition(
-        sessionID,
-        entry,
-        "busy",
-        statusType === "retry" ? "retry-observed" : "busy-observed"
-      );
+  digests = /* @__PURE__ */ new Map();
+  observeContextLimit(sessionID, contextTokens) {
+    if (!sessionID || !contextTokens || !Number.isFinite(contextTokens) || contextTokens <= 0) {
       return;
     }
-    if (statusType === "idle") {
-      this.observeIdle(sessionID, entry, "status");
-    }
+    const state = this.session(sessionID);
+    state.contextTokens = contextTokens;
+    lruSet(this.sessions, sessionID, state, SESSION_LIMIT);
   }
-  /** First-class input: legacy `session.idle`. Absorbed by dedup on hosts
-   * that dual-publish; the only boundary signal on status-less hosts (T3). */
-  observeLegacyIdle(sessionID) {
-    if (!sessionID) return;
-    this.observeIdle(sessionID, this.entry(sessionID), "legacy-idle");
+  contextTokens(sessionID) {
+    return this.sessions.get(sessionID)?.contextTokens;
   }
-  /** Lifecycle: cancel any pending window and forget the session. */
-  observeDeleted(sessionID) {
-    if (!sessionID) return;
-    const entry = this.sessions.get(sessionID);
-    if (!entry) return;
-    this.cancelWindow(entry);
-    this.sessions.delete(sessionID);
-    this.logger.debug("Boundary session dropped", { sessionId: sessionID, reason: "deleted" });
-  }
-  /** Lifecycle: compaction ended; reset to unknown so the next idle opens a
-   * fresh window. */
-  observeCompacted(sessionID) {
-    if (!sessionID) return;
-    const entry = this.sessions.get(sessionID);
-    if (!entry) return;
-    const from = entry.phase;
-    this.cancelWindow(entry);
-    entry.phase = "unknown";
-    delete entry.busyAt;
-    this.logger.debug("Boundary transition", {
-      sessionId: sessionID,
-      from,
-      to: "unknown",
-      reason: "compacted"
-    });
+  /** Called by the compacting hook; consumed by the very next transform. */
+  armCompactionSkip(sessionID) {
+    const state = this.session(sessionID);
+    state.skipNextTransform = true;
+    lruSet(this.sessions, sessionID, state, SESSION_LIMIT);
   }
-  /** Absorbed busy-evidence cache: `busy` decays to `unknown` after the TTL;
-   * the table is LRU-bounded (pending-rest/at-rest entries have no TTL exit
-   * and rely on the cap). */
-  state(sessionID) {
-    const entry = this.sessions.get(sessionID);
-    if (!entry) return "unknown";
-    if (entry.phase === "busy" && entry.busyAt !== void 0 && this.now() - entry.busyAt > BUSY_EVIDENCE_TTL_MS) {
-      return "unknown";
-    }
-    return entry.phase;
+  consumeCompactionSkip(sessionID) {
+    const state = this.sessions.get(sessionID);
+    if (!state?.skipNextTransform) return false;
+    state.skipNextTransform = false;
+    return true;
   }
-  dispose(sessionID) {
-    this.observeDeleted(sessionID);
+  /** `dcp_prune` / `/dcp fold`: mark a boundary now and deepen folding. */
+  markBoundary(sessionID, at, minLevel = 2) {
+    const state = this.session(sessionID);
+    state.boundaryMarkAt = at;
+    state.minLevel = Math.max(state.minLevel ?? 0, minLevel);
+    lruSet(this.sessions, sessionID, state, SESSION_LIMIT);
   }
-  observeIdle(sessionID, entry, source) {
-    if (entry.phase === "pending-rest") {
-      this.logger.debug("Boundary duplicate idle ignored", { sessionId: sessionID, source });
-      return;
-    }
-    if (entry.phase === "at-rest") {
-      if (source === "legacy-idle" && !entry.sawStatus) {
-        this.armWindow(sessionID, entry, "degrade-rearm");
-      } else {
-        this.logger.debug("Boundary duplicate idle ignored", {
-          sessionId: sessionID,
-          source
-        });
-      }
-      return;
-    }
-    this.armWindow(sessionID, entry, "idle-observed");
-  }
-  armWindow(sessionID, entry, reason) {
-    this.cancelWindow(entry);
-    entry.phase = "pending-rest";
-    entry.timer = this.setTimer(() => {
-      entry.timer = void 0;
-      void this.onWindowExpiry(sessionID, entry);
-    }, BOUNDARY_QUIET_MS);
-    this.refresh(sessionID, entry);
-    this.logger.debug("Boundary quiet window armed", {
-      sessionId: sessionID,
-      reason,
-      generation: entry.generation
-    });
+  boundaryMark(sessionID) {
+    return this.sessions.get(sessionID)?.boundaryMarkAt;
   }
-  async onWindowExpiry(sessionID, entry) {
-    if (entry.phase !== "pending-rest") return;
-    const generation = entry.generation;
-    let busy;
-    try {
-      busy = await this.probeBusy(sessionID);
-    } catch {
-      busy = null;
-    }
-    if (entry.phase !== "pending-rest" || entry.generation !== generation || this.sessions.get(sessionID) !== entry) {
-      this.logger.debug("Boundary probe result discarded", {
-        sessionId: sessionID,
-        generation
-      });
-      return;
-    }
-    if (busy === true) {
-      this.transition(sessionID, entry, "busy", "probe-busy");
-      return;
-    }
-    const reason = busy === false ? "window-expired" : "probe-failopen";
-    const from = entry.phase;
-    entry.phase = "at-rest";
-    this.refresh(sessionID, entry);
-    this.logger.debug("Boundary transition", {
-      sessionId: sessionID,
-      from,
-      to: "at-rest",
-      reason
-    });
-    this.fireAtRest(sessionID, reason);
-  }
-  transition(sessionID, entry, phase, reason) {
-    const from = entry.phase;
-    this.cancelWindow(entry);
-    entry.phase = phase;
-    if (phase === "busy") entry.busyAt = this.now();
-    else delete entry.busyAt;
-    this.refresh(sessionID, entry);
-    this.logger.debug("Boundary transition", { sessionId: sessionID, from, to: phase, reason });
-  }
-  cancelWindow(entry) {
-    if (entry.timer !== void 0) {
-      this.clearTimer(entry.timer);
-      entry.timer = void 0;
-    }
-    entry.generation += 1;
-  }
-  fireAtRest(sessionID, reason) {
-    for (const listener of this.listeners) {
-      try {
-        const result = listener(sessionID, reason);
-        if (result instanceof Promise) {
-          result.catch((error) => {
-            this.logger.warn("At-rest listener rejected", {
-              sessionId: sessionID,
-              error: error instanceof Error ? error.message : String(error)
-            });
-          });
-        }
-      } catch (error) {
-        this.logger.warn("At-rest listener failed", {
-          sessionId: sessionID,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
+  minLevel(sessionID) {
+    return this.sessions.get(sessionID)?.minLevel ?? 0;
   }
-  entry(sessionID) {
-    let entry = this.sessions.get(sessionID);
-    if (!entry) {
-      entry = { phase: "unknown", generation: 0, sawStatus: false };
-      this.sessions.set(sessionID, entry);
-      this.evictIfNeeded(sessionID);
-      return entry;
-    }
-    this.refresh(sessionID, entry);
-    return entry;
+  cachedDigest(key) {
+    return this.digests.get(key);
   }
-  refresh(sessionID, entry) {
+  storeDigest(key, digest) {
+    lruSet(this.digests, key, digest, DIGEST_LIMIT);
+  }
+  dropSession(sessionID) {
     this.sessions.delete(sessionID);
-    this.sessions.set(sessionID, entry);
-    this.evictIfNeeded(sessionID);
   }
-  evictIfNeeded(kept) {
-    if (this.sessions.size <= MAX_TRACKED_SESSIONS) return;
-    const oldest = this.sessions.keys().next().value;
-    if (oldest === void 0 || oldest === kept) return;
-    const victim = this.sessions.get(oldest);
-    if (victim?.timer !== void 0) this.clearTimer(victim.timer);
-    this.sessions.delete(oldest);
+  /** Test/inspection surface. */
+  stats() {
+    return { sessions: this.sessions.size, digests: this.digests.size };
+  }
+  session(sessionID) {
+    return this.sessions.get(sessionID) ?? {};
   }
 };
-function retrySeconds(retryAfterMs) {
-  return Math.ceil(retryAfterMs / 1e3);
-}
+
+// lib/session-events.ts
 function eventSessionID(properties) {
   const direct = properties?.sessionID;
   if (typeof direct === "string" && direct) return direct;
@@ -1713,162 +1757,176 @@ function eventSessionID(properties) {
 }
 
 // lib/hooks.ts
-function createSessionCompactingHandler(prompts, logger) {
+var DEFAULT_TAIL_TURNS = 4;
+var DEFAULT_PRESERVE_RECENT_TOKENS = 32e3;
+function extractPreviousCheckpoint(messages) {
+  if (!Array.isArray(messages)) return void 0;
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index];
+    const info = message?.info;
+    if (info?.role !== "assistant" || info.summary !== true) continue;
+    const parts = Array.isArray(message?.parts) ? message.parts : [];
+    const text = parts.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text.trim()).filter(Boolean).join("\n\n").trim();
+    if (text) return text;
+  }
+  return void 0;
+}
+async function fetchPreviousCheckpoint(client, sessionID) {
+  if (!sessionID) return void 0;
+  try {
+    const response = await client.session.messages({ path: { id: sessionID } });
+    return extractPreviousCheckpoint(response.data ?? response);
+  } catch {
+    return void 0;
+  }
+}
+function createSessionCompactingHandler(deps) {
   return async (input, output) => {
     try {
-      prompts.reload();
-      const prompt = prompts.getRuntimePrompts().compaction;
+      deps.state.armCompactionSkip(input.sessionID);
+      deps.prompts.reload();
+      const prompt = deps.prompts.getRuntimePrompts().compaction;
+      const previous = await fetchPreviousCheckpoint(deps.client, input.sessionID);
+      const withCheckpoint = previous ? `${prompt}
+
+<previous-checkpoint>
+${previous}
+</previous-checkpoint>` : prompt;
       if (!output.prompt) {
-        output.prompt = prompt;
+        output.prompt = withCheckpoint;
       } else if (!output.context.includes(prompt)) {
-        output.context.push(prompt);
+        output.context.push(withCheckpoint);
       }
-      logger.debug("Applied semantic pruning prompt", { sessionId: input.sessionID });
-    } catch (error) {
-      logger.warn("Failed to apply semantic pruning prompt; native compaction continues", {
+      deps.logger.debug("Applied semantic pruning prompt", {
         sessionId: input.sessionID,
-        error: error instanceof Error ? error.message : String(error)
+        carriedCheckpoint: Boolean(previous)
       });
+    } catch (error) {
+      deps.logger.warn(
+        "Failed to apply semantic pruning prompt; native compaction continues",
+        {
+          sessionId: input.sessionID,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
     }
   };
 }
-async function showToast(client, title, message, variant = "info") {
-  await client.tui.showToast({
-    body: { title, message, variant, duration: 5e3 }
-  }).catch(() => void 0);
-}
-function createChatMessageHandler(autoPruner) {
+function createChatParamsHandler(deps) {
   return async (input, _output) => {
-    const parts = _output?.parts ?? [];
-    autoPruner.observeUserMessage(input.sessionID, parts);
+    try {
+      const context = input.model?.limit?.context;
+      if (typeof context === "number" && Number.isFinite(context) && context > 0) {
+        deps.state.observeContextLimit(input.sessionID, context);
+      }
+    } catch (error) {
+      deps.logger.debug("chat.params observation failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
+}
+function createTransformHandler(deps) {
+  return async (_input, output) => {
+    try {
+      if (!Array.isArray(output?.messages) || output.messages.length === 0) return;
+      transformMessages(output.messages, {
+        state: deps.state,
+        config: deps.config,
+        logger: deps.logger
+      });
+    } catch (error) {
+      deps.logger.warn("DTC transform failed; the request proceeds unfolded", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
   };
 }
-var SIGNAL_LABELS = {
-  "topic-drift": "\u8BDD\u9898\u53D8\u66F4",
-  volume: "\u6D88\u606F\u91CF\u8FBE\u5230\u9608\u503C",
-  "idle-gap": "\u957F\u65F6\u95F4\u4E2D\u65AD\u540E\u6062\u590D"
-};
 function createEventHandler(deps) {
   return async (input) => {
-    const event = input.event;
     try {
-      deps.prune.observeEvent(event.type, event.properties);
-      const sessionID = eventSessionID(event.properties);
-      if (!sessionID) return;
-      if (event.type === "session.compacted") {
-        deps.autoPruner.markPruned(sessionID);
-        return;
-      }
-      if (event.type === "session.deleted") {
-        deps.autoPruner.dropSession(sessionID);
-      }
+      if (input.event.type !== "session.deleted") return;
+      const sessionID = eventSessionID(input.event.properties);
+      if (sessionID) deps.state.dropSession(sessionID);
     } catch (error) {
       deps.logger.warn("Event handler failed", {
-        type: event.type,
+        type: input.event.type,
         error: error instanceof Error ? error.message : String(error)
       });
     }
   };
 }
-async function triggerAutoPrune(deps, sessionID, signals) {
-  const reason = signals.map((signal) => SIGNAL_LABELS[signal]).join("\u3001");
-  const result = await deps.prune.request({ sessionID, onBusy: "proceed" });
-  const attempted = result.status === "succeeded" || result.status === "failed" || result.status === "cooldown";
-  if (!attempted) {
-    if (result.status === "busy") {
+async function showToast(client, title, message, variant = "info") {
+  await client.tui.showToast({
+    body: { title, message, variant, duration: 5e3 }
+  }).catch(() => void 0);
+}
+function createCommandExecuteHandler(deps) {
+  return async (input, _output) => {
+    if (input.command !== "dcp") return;
+    const subcommand = (input.arguments ?? "").trim().split(/\s+/, 1)[0]?.toLowerCase();
+    if (subcommand === "fold") {
+      deps.state.markBoundary(input.sessionID, Date.now(), 3);
       await showToast(
         deps.client,
-        "DCP \u81EA\u52A8\u538B\u7F29",
-        `\u68C0\u6D4B\u5230${reason}\uFF0C\u4F46\u4F1A\u8BDD\u6B63\u5FD9\uFF0C\u672C\u6B21\u5DF2\u8DF3\u8FC7\uFF1B\u539F\u59CB\u4E0A\u4E0B\u6587\u4FDD\u6301\u4E0D\u53D8\u3002`,
-        "warning"
+        "DCP fold",
+        "\u5DF2\u6807\u8BB0\u8BDD\u9898\u8FB9\u754C\u5E76\u52A0\u6DF1\u6298\u53E0\uFF1B\u4E0B\u4E00\u6B21\u6A21\u578B\u8BF7\u6C42\u8D77\u751F\u6548\uFF0C\u4F1A\u8BDD\u4E0D\u4E2D\u65AD\u3002"
       );
+      deps.logger.debug("Handled DCP fold command", { sessionId: input.sessionID });
+      throw new Error("__DCP_FOLD_HANDLED__");
+    }
+    if (subcommand === "status") {
+      const message = await buildStatusMessage(deps, input.sessionID);
+      await showToast(deps.client, "DCP status", message);
+      throw new Error("__DCP_STATUS_HANDLED__");
     }
-    deps.logger.debug("Auto prune skipped", {
-      sessionId: sessionID,
-      status: result.status
-    });
-    return;
-  }
-  deps.autoPruner.markPruned(sessionID);
-  if (result.status === "succeeded") {
-    await showToast(deps.client, "DCP \u81EA\u52A8\u538B\u7F29", `\u68C0\u6D4B\u5230${reason}\uFF0C\u5DF2\u751F\u6210\u65B0\u7684\u8BED\u4E49\u68C0\u67E5\u70B9\u3002`);
-  } else if (result.status === "cooldown") {
-    await showToast(
-      deps.client,
-      "DCP \u81EA\u52A8\u538B\u7F29",
-      `\u68C0\u6D4B\u5230${reason}\uFF0C\u4F46\u4E0A\u4E00\u6B21\u538B\u7F29\u5931\u8D25\uFF1B${retrySeconds(result.retryAfterMs)} \u79D2\u540E\u53EF\u91CD\u8BD5\u3002`,
-      "warning"
-    );
-  } else {
     await showToast(
       deps.client,
-      "DCP \u81EA\u52A8\u538B\u7F29",
-      `\u68C0\u6D4B\u5230${reason}\uFF0C\u4F46\u538B\u7F29\u5931\u8D25\uFF1B\u539F\u59CB\u4E0A\u4E0B\u6587\u4FDD\u6301\u4E0D\u53D8\u3002`,
-      "warning"
+      "DCP",
+      "\u7528\u6CD5\uFF1A/dcp fold\uFF08\u7ACB\u5373\u6DF1\u6298\u53E0\uFF09\u6216 /dcp status\uFF08\u67E5\u770B\u5206\u533A\u72B6\u6001\uFF09\u3002\u538B\u7F29\u7531\u52A8\u6001\u5206\u7EA7\u5F15\u64CE\u5728\u6BCF\u6B21\u8BF7\u6C42\u65F6\u81EA\u52A8\u5B8C\u6210\u3002"
     );
-  }
-  deps.logger.debug("Auto prune finished", { sessionId: sessionID, status: result.status });
-}
-function createAtRestAutoPruneListener(deps) {
-  return async (sessionID, _reason) => {
-    if (!deps.config.enabled) return;
-    const signals = deps.autoPruner.consumePending(sessionID);
-    if (signals) await triggerAutoPrune(deps, sessionID, signals);
+    throw new Error("__DCP_HELP_HANDLED__");
   };
 }
-function createCommandExecuteHandler(client, prune, logger) {
-  return async (input, _output) => {
-    if (input.command !== "dcp") return;
-    const subcommand = (input.arguments ?? "").trim().split(/\s+/, 1)[0]?.toLowerCase();
-    if (subcommand !== "summarize") {
-      await showToast(
-        client,
-        "DCP",
-        "Use /dcp summarize for semantic pruning, or OpenCode's native /compact command."
-      );
-      throw new Error("__DCP_HELP_HANDLED__");
-    }
-    const result = await prune.request({ sessionID: input.sessionID, onBusy: "proceed" });
-    if (result.status === "busy") {
-      await showToast(
-        client,
-        "DCP summarize",
-        "Session is busy; the prune will not interrupt the current turn. Try again once it finishes.",
-        "warning"
-      );
-      throw new Error("__DCP_SUMMARIZE_HANDLED__");
-    }
-    if (result.status === "no-model") {
-      await showToast(
-        client,
-        "DCP summarize",
-        "No session model is available yet.",
-        "warning"
-      );
-      throw new Error("__DCP_SUMMARIZE_NO_MODEL__");
-    }
-    if (result.status === "succeeded") {
-      await showToast(client, "DCP summarize", "Semantic pruning checkpoint created.");
-    } else if (result.status === "cooldown") {
-      await showToast(
-        client,
-        "DCP summarize",
-        `Previous attempt failed; retry in ${retrySeconds(result.retryAfterMs)}s.`,
-        "warning"
-      );
-    } else {
-      await showToast(
-        client,
-        "DCP summarize",
-        "Native compaction failed; the original context was kept.",
-        "error"
-      );
+async function buildStatusMessage(deps, sessionID) {
+  try {
+    const response = await deps.client.session.messages({ path: { id: sessionID } });
+    const data = response.data ?? response;
+    const messages = Array.isArray(data) ? data : [];
+    const turns = segmentTurns(messages);
+    const estimated = estimateSlice(messages, 0, messages.length);
+    const context = deps.state.contextTokens(sessionID);
+    const tail = Math.min(deps.config.tailTurns, turns.length);
+    const lines = [
+      `\u6D88\u606F ${messages.length} \u6761 / \u5BF9\u8BDD\u8F6E ${turns.length}\uFF08\u5C3E\u90E8\u4FDD\u62A4 ${tail} \u8F6E\uFF09`,
+      `\u4F30\u7B97 ${estimated.toLocaleString()} tokens` + (context ? ` / \u4E0A\u4E0B\u6587\u7A97\u53E3 ${context.toLocaleString()}` : "\uFF08\u7A97\u53E3\u672A\u77E5\uFF0C\u6682\u672A\u6298\u53E0\uFF09"),
+      `\u624B\u52A8\u964D\u7EA7\u6863\u4F4D\uFF1A${deps.state.minLevel(sessionID)}`
+    ];
+    return lines.join("\n");
+  } catch {
+    return "\u65E0\u6CD5\u8BFB\u53D6\u4F1A\u8BDD\u72B6\u6001\u3002";
+  }
+}
+function createConfigHandler(config, logger) {
+  return async (opencodeConfig) => {
+    const compaction = opencodeConfig.compaction ??= {};
+    if (compaction.tail_turns === void 0) {
+      compaction.tail_turns = DEFAULT_TAIL_TURNS;
+    }
+    if (compaction.preserve_recent_tokens === void 0) {
+      compaction.preserve_recent_tokens = DEFAULT_PRESERVE_RECENT_TOKENS;
+    }
+    if (config.commands.enabled) {
+      opencodeConfig.command ??= {};
+      opencodeConfig.command.dcp = {
+        template: "",
+        description: "Dynamic context pruning: /dcp fold | /dcp status"
+      };
     }
-    logger.debug("Handled DCP summarize command", {
-      sessionId: input.sessionID,
-      status: result.status
+    logger.debug("Applied host config defaults", {
+      tailTurns: compaction.tail_turns,
+      preserveRecentTokens: compaction.preserve_recent_tokens
     });
-    throw new Error("__DCP_SUMMARIZE_HANDLED__");
   };
 }
 
@@ -2072,15 +2130,16 @@ import { homedir as homedir3 } from "os";
 import { dirname as dirname2, join as join3 } from "path";
 
 // lib/prompts/compaction.ts
-var COMPACTION = `\u4F60\u6B63\u5728\u751F\u6210\u5F53\u524D\u4F1A\u8BDD\u552F\u4E00\u7684\u6EDA\u52A8\u68C0\u67E5\u70B9\u3002\u8F93\u51FA\u5C06\u66FF\u4EE3\u65E7\u5BF9\u8BDD\u524D\u7F00\uFF0C\u6210\u4E3A\u540E\u7EED\u6A21\u578B\u770B\u5230\u7684\u7B2C\u4E00\u6BB5\u4E0A\u4E0B\u6587\uFF1BOpenCode \u4F1A\u5728\u5B83\u540E\u9762\u4FDD\u7559\u5C1A\u672A\u538B\u7F29\u7684\u8FD1\u671F\u5C3E\u90E8\u3002\u7CFB\u7EDF\u7EA7\u5185\u5BB9\uFF08AGENTS.md\u3001\u9879\u76EE\u89C4\u5219\u7B49\uFF09\u7531 OpenCode \u5728\u6BCF\u6B21\u8BF7\u6C42\u65F6\u72EC\u7ACB\u6CE8\u5165\uFF0C\u4E0D\u5C5E\u4E8E\u538B\u7F29\u8303\u56F4\uFF0C\u4E0D\u8981\u590D\u8FF0\u5B83\u4EEC\u3002
+var COMPACTION = `\u4F60\u6B63\u5728\u751F\u6210\u5F53\u524D\u4F1A\u8BDD\u552F\u4E00\u7684\u6EDA\u52A8\u68C0\u67E5\u70B9\u3002\u8F93\u51FA\u5C06\u66FF\u4EE3\u65E7\u5BF9\u8BDD\u524D\u7F00\uFF0C\u6210\u4E3A\u540E\u7EED\u6A21\u578B\u770B\u5230\u7684\u7B2C\u4E00\u6BB5\u4E0A\u4E0B\u6587\uFF1BOpenCode \u4F1A\u5728\u68C0\u67E5\u70B9\u4E4B\u540E\u76F4\u63A5\u4FDD\u7559\u6700\u8FD1\u82E5\u5E72\u8F6E\u5B8C\u6574\u5BF9\u8BDD\uFF08\u4E0D\u7ECF\u538B\u7F29\uFF0C\u8303\u56F4\u7531\u5BBF\u4E3B\u914D\u7F6E\u51B3\u5B9A\uFF09\uFF0C\u8FD9\u90E8\u5206\u5C3E\u90E8\u4E0D\u5C5E\u4E8E\u538B\u7F29\u5BF9\u8C61\uFF0C\u4E0D\u8981\u590D\u8FF0\u3001\u603B\u7ED3\u6216\u6539\u5199\u5B83\u4EEC\u3002\u7CFB\u7EDF\u7EA7\u5185\u5BB9\uFF08AGENTS.md\u3001\u9879\u76EE\u89C4\u5219\u7B49\uFF09\u7531 OpenCode \u5728\u6BCF\u6B21\u8BF7\u6C42\u65F6\u72EC\u7ACB\u6CE8\u5165\uFF0C\u4E0D\u5C5E\u4E8E\u538B\u7F29\u8303\u56F4\uFF0C\u4E0D\u8981\u590D\u8FF0\u5B83\u4EEC\u3002
 
-\u8FD9\u4E0D\u662F\u804A\u5929\u8BB0\u5F55\u6458\u8981\uFF0C\u800C\u662F\u53EF\u76F4\u63A5\u7EE7\u7EED\u5DE5\u4F5C\u7684\u8BED\u4E49\u526A\u679D\u7ED3\u679C\u3002\u6309\u4EE5\u4E0B\u89C4\u5219\u538B\u7F29\uFF1A
+\u8FD9\u4E0D\u662F\u804A\u5929\u8BB0\u5F55\u6458\u8981\uFF0C\u800C\u662F\u53EF\u76F4\u63A5\u7EE7\u7EED\u5DE5\u4F5C\u7684\u8BED\u4E49\u526A\u679D\u7ED3\u679C\u3002\u6309\u4EE5\u4E0B\u5206\u5C42\u89C4\u5219\u538B\u7F29\uFF1A
 
-1. \u5982\u679C\u8F93\u5165\u542B\u6709\u4E0A\u4E00\u4EFD\u68C0\u67E5\u70B9\uFF0C\u628A\u4ECD\u6709\u6548\u7684\u4FE1\u606F\u5408\u5E76\u8FDB\u65B0\u68C0\u67E5\u70B9\uFF1B\u4E0D\u8981\u5D4C\u5957\u3001\u5F15\u7528\u6216\u91CD\u590D\u65E7\u68C0\u67E5\u70B9\u3002
-2. \u5220\u9664\u65E0\u5173\u95F2\u804A\u3001\u5176\u4ED6\u9879\u76EE\u6216\u5176\u4ED6\u4ED3\u5E93\u7684\u5BF9\u8BDD\u3001\u91CD\u590D\u89E3\u91CA\u3001\u5DF2\u7ECF\u63A8\u7FFB\u4E14\u4E0D\u518D\u6709\u8BCA\u65AD\u4EF7\u503C\u7684\u65B9\u6848\u3002
-3. \u591A\u6B21\u5DE5\u5177\u8C03\u7528\u8BD5\u9519\u6216\u5931\u8D25\u540E\u6210\u529F\u65F6\uFF0C\u53EA\u4FDD\u7559\u6700\u7EC8\u6210\u529F\u7ED3\u679C\uFF1B\u4EC5\u5F53\u6839\u56E0\u4F1A\u5F71\u54CD\u540E\u7EED\u5DE5\u4F5C\u65F6\u4FDD\u7559\u4E00\u6B21\u7B80\u77ED\u5931\u8D25\u539F\u56E0\u3002
-4. \u540C\u4E00\u5185\u5BB9\u6216\u6587\u4EF6\u88AB\u91CD\u590D\u7F16\u8F91\u65F6\uFF0C\u53EA\u4FDD\u7559\u6700\u7EC8\u72B6\u6001\u3001\u4ECD\u6709\u6548\u7684\u5173\u952E\u51B3\u7B56\u548C\u5FC5\u8981\u7406\u7531\uFF0C\u4E0D\u590D\u8FF0\u6BCF\u8F6E\u4FEE\u6539\u3002
-5. \u6309\u65F6\u95F4\u5206\u5C42\u51B3\u5B9A\u538B\u7F29\u6DF1\u5EA6\uFF1A\u65E9\u671F\u5386\u53F2\u548C\u4E2D\u90E8\u5386\u53F2\u9AD8\u5EA6\u538B\u7F29\u2014\u2014\u6BCF\u4E2A\u4E3B\u9898\u53EA\u7559\u4E00\u53E5\u8BDD\u7ED3\u8BBA\uFF0C\u4E0D\u7559\u8FC7\u7A0B\uFF1B\u6700\u8FD1\u5386\u53F2\u8F7B\u5EA6\u538B\u7F29\u2014\u2014\u5C24\u5176\u662F\u4E0E\u5F53\u524D\u4EFB\u52A1\u76F8\u5173\u7684\u5185\u5BB9\uFF0C\u4FDD\u7559\u7EE7\u7EED\u5DE5\u4F5C\u6240\u9700\u7684\u5173\u952E\u7EC6\u8282\uFF08\u6587\u4EF6\u8DEF\u5F84\u3001\u63A5\u53E3\u3001\u547D\u4EE4\u3001\u6D4B\u8BD5\u7ED3\u679C\u3001\u9519\u8BEF\u4E8B\u5B9E\u3001\u4ECD\u6709\u6548\u7684\u51B3\u7B56\u53CA\u7406\u7531\uFF09\uFF0C\u53EA\u6298\u53E0\u91CD\u590D\u4E0E\u5DF2\u5931\u6548\u7684\u5185\u5BB9\u3002\u6700\u8FD1\u5386\u53F2\u6307\u81EA\u4E0A\u4E00\u4EFD\u68C0\u67E5\u70B9\u4EE5\u6765\u7684\u65B0\u5185\u5BB9\u3002
+1. \u6EDA\u52A8\u5408\u5E76\uFF1A\u5982\u679C\u8F93\u5165\u672B\u5C3E\u542B\u6709 <previous-checkpoint> \u6807\u7B7E\u5305\u88F9\u7684\u4E0A\u4E00\u4EFD\u68C0\u67E5\u70B9\uFF0C\u628A\u4ECD\u6709\u6548\u7684\u4FE1\u606F\u5408\u5E76\u8FDB\u65B0\u68C0\u67E5\u70B9\uFF1B\u4E0D\u8981\u5D4C\u5957\u3001\u5F15\u7528\u6216\u9010\u5B57\u91CD\u590D\u65E7\u68C0\u67E5\u70B9\uFF0C\u5931\u6548\u5185\u5BB9\u76F4\u63A5\u4E22\u5F03\u3002\u6CA1\u6709\u8BE5\u6807\u7B7E\u65F6\u5FFD\u7565\u672C\u6761\u3002
+2. \u8FDC\u8DDD\u79BB\u5185\u5BB9\uFF08\u65E9\u671F\u4E0E\u4E2D\u90E8\u5386\u53F2\uFF09\u91CD\u5EA6\u538B\u7F29\uFF1A\u6BCF\u4E2A\u4E3B\u9898\u53EA\u7559\u4E00\u53E5\u8BDD\u7ED3\u8BBA\uFF0C\u4E0D\u7559\u8FC7\u7A0B\u3001\u4E0D\u590D\u8FF0\u5BF9\u8BDD\u5F80\u6765\u3002
+3. \u5220\u9664\u65E0\u5173\u95F2\u804A\u3001\u5176\u4ED6\u9879\u76EE\u6216\u5176\u4ED6\u4ED3\u5E93\u7684\u5BF9\u8BDD\u3001\u91CD\u590D\u89E3\u91CA\u3001\u5DF2\u7ECF\u63A8\u7FFB\u4E14\u4E0D\u518D\u6709\u8BCA\u65AD\u4EF7\u503C\u7684\u65B9\u6848\u3002
+4. \u591A\u6B21\u5DE5\u5177\u8C03\u7528\u8BD5\u9519\u6216\u5931\u8D25\u540E\u6210\u529F\u65F6\uFF0C\u53EA\u4FDD\u7559\u6700\u7EC8\u6210\u529F\u7ED3\u679C\uFF1B\u4EC5\u5F53\u6839\u56E0\u4F1A\u5F71\u54CD\u540E\u7EED\u5DE5\u4F5C\u65F6\u4FDD\u7559\u4E00\u6B21\u7B80\u77ED\u5931\u8D25\u539F\u56E0\u3002
+5. \u540C\u4E00\u5185\u5BB9\u6216\u6587\u4EF6\u88AB\u91CD\u590D\u7F16\u8F91\u65F6\uFF0C\u53EA\u4FDD\u7559\u6700\u7EC8\u72B6\u6001\u3001\u4ECD\u6709\u6548\u7684\u5173\u952E\u51B3\u7B56\u548C\u5FC5\u8981\u7406\u7531\uFF0C\u4E0D\u590D\u8FF0\u6BCF\u8F6E\u4FEE\u6539\u3002
+6. \u8FD1\u8DDD\u79BB\u5185\u5BB9\uFF08\u81EA\u4E0A\u4E00\u4EFD\u68C0\u67E5\u70B9\u4EE5\u6765\u7684\u65B0\u5185\u5BB9\uFF0C\u4E14\u4E0D\u5C5E\u4E8E\u5BBF\u4E3B\u4FDD\u7559\u7684\u5C3E\u90E8\uFF09\u8F7B\u5EA6\u538B\u7F29\uFF1A\u5F53\u524D\u4EFB\u52A1\u3001\u76EE\u6807\u3001\u72B6\u6001\u4E0E\u8FDB\u884C\u4E2D\u7684\u60C5\u51B5\u505A\u6C47\u603B\u4F46\u4E0D\u4E22\u7EC6\u8282\u2014\u2014\u4FDD\u7559\u7EE7\u7EED\u5DE5\u4F5C\u6240\u9700\u7684\u6587\u4EF6\u8DEF\u5F84\u3001\u63A5\u53E3\u3001\u547D\u4EE4\u3001\u6D4B\u8BD5\u7ED3\u679C\u3001\u9519\u8BEF\u4E8B\u5B9E\u3001\u4ECD\u6709\u6548\u7684\u51B3\u7B56\u53CA\u7406\u7531\uFF0C\u53EA\u6298\u53E0\u91CD\u590D\u4E0E\u5DF2\u5931\u6548\u7684\u5185\u5BB9\u3002
 
 \u4F7F\u7528\u4EE5\u4E0B\u56FA\u5B9A\u7ED3\u6784\uFF0C\u7701\u7565\u786E\u5B9E\u4E3A\u7A7A\u7684\u6761\u76EE\uFF1A
 
@@ -2097,15 +2156,16 @@ var COMPACTION = `\u4F60\u6B63\u5728\u751F\u6210\u5F53\u524D\u4F1A\u8BDD\u552F\u
 \u8DE8\u4EFB\u52A1\u7684\u9057\u7559\u98CE\u9669\u548C\u5F85\u786E\u8BA4\u4E8B\u9879\u3002\u53EA\u5199\u672A\u5728\u300C\u8FDB\u884C\u4E2D\u4EFB\u52A1\u8BE6\u60C5\u300D\u4E2D\u51FA\u73B0\u7684\u5185\u5BB9\uFF0C\u907F\u514D\u4E0E\u8BE5\u8282\u91CD\u590D\u3002
 
 \u4FDD\u6301\u5177\u4F53\u3001\u53EF\u9A8C\u8BC1\u548C\u9879\u76EE\u5185\u805A\u3002\u8FDB\u884C\u4E2D\u7684\u4EFB\u52A1\u5FC5\u987B\u80FD\u51ED\u68C0\u67E5\u70B9\u76F4\u63A5\u7EE7\u7EED\uFF0C\u4E0D\u8981\u4F9D\u8D56\u5DF2\u88AB\u538B\u7F29\u6389\u7684\u4E2D\u95F4\u8FC7\u7A0B\u3002\u4FDD\u7559\u6587\u4EF6\u8DEF\u5F84\u3001\u63A5\u53E3\u3001\u547D\u4EE4\u3001\u6D4B\u8BD5\u7ED3\u679C\u548C\u9519\u8BEF\u4E8B\u5B9E\u7B49\u786C\u4E8B\u5B9E\uFF0C\u4F46\u4E0D\u8981\u4FDD\u7559\u6D88\u606F ID\u3001\u5757 ID\u3001\u951A\u70B9\u3001\u5360\u4F4D\u7B26\u3001\u63A7\u5236\u6807\u7B7E\u6216\u8FC7\u7A0B\u6027\u804A\u5929\u3002`;
-var COMPACTION_EN = `You are generating the single rolling checkpoint for this session. Your output will replace the old conversation prefix as the first context the model sees afterwards; OpenCode keeps an uncompacted recent tail right after it. System-level content (AGENTS.md, project rules, etc.) is injected independently by OpenCode on every request and is not part of compaction; do not restate it.
+var COMPACTION_EN = `You are generating the single rolling checkpoint for this session. Your output will replace the old conversation prefix as the first context the model sees afterwards; OpenCode keeps the most recent conversation turns directly after the checkpoint, uncompacted (their range is a host setting). That tail is outside the compaction scope: do not restate, summarize, or rewrite it. System-level content (AGENTS.md, project rules, etc.) is injected independently by OpenCode on every request and is not part of compaction; do not restate it.
 
-This is not a chat-log summary but a semantic pruning result one can resume working from directly. Compress by these rules:
+This is not a chat-log summary but a semantic pruning result one can resume working from directly. Compress by these tiered rules:
 
-1. If the input contains a previous checkpoint, merge the still-valid information into the new checkpoint; do not nest, quote, or duplicate the old one.
-2. Remove irrelevant chitchat, conversations about other projects or repositories, repeated explanations, and approaches that were overturned and no longer carry diagnostic value.
-3. When repeated tool trial-and-error ends in success, keep only the final successful outcome; retain one brief failure reason only if the root cause affects future work.
-4. When the same content or file was edited repeatedly, keep only the final state, the still-valid key decisions, and the necessary rationale; do not restate each round of edits.
-5. Choose compression depth by recency tiers: early and middle history are compressed heavily\u2014one concluding sentence per topic, no process detail; recent history is compressed lightly\u2014especially content related to the current task, keeping the key details needed to continue (file paths, interfaces, commands, test results, error facts, still-valid decisions and their rationale), folding only duplicates and invalidated content. Recent history means everything generated since the previous checkpoint.
+1. Rolling merge: if the input ends with a <previous-checkpoint> block containing the previous checkpoint, merge its still-valid information into the new checkpoint; do not nest, quote, or repeat it verbatim, and drop stale content outright. Ignore this rule when the tag is absent.
+2. Distant content (early and middle history) is compressed heavily: one concluding sentence per topic, no process detail, no dialogue restatement.
+3. Remove irrelevant chitchat, conversations about other projects or repositories, repeated explanations, and approaches that were overturned and no longer carry diagnostic value.
+4. When repeated tool trial-and-error ends in success, keep only the final successful outcome; retain one brief failure reason only if the root cause affects future work.
+5. When the same content or file was edited repeatedly, keep only the final state, the still-valid key decisions, and the necessary rationale; do not restate each round of edits.
+6. Recent content (everything generated since the previous checkpoint, excluding the host-retained tail) is compressed lightly: summarize the current task, goals, status, and in-progress work without losing detail\u2014keep the file paths, interfaces, commands, test results, error facts, and still-valid decisions with rationale needed to continue, folding only duplicates and invalidated content.
 
 Use the following fixed structure, omitting sections that are truly empty:
 
@@ -2213,301 +2273,30 @@ var PromptStore = class {
 
 // lib/prune-tool.ts
 import { tool } from "@opencode-ai/plugin";
-
-// lib/session-model.ts
-function latestUserModel(messages) {
-  if (!Array.isArray(messages)) return null;
-  for (let index = messages.length - 1; index >= 0; index--) {
-    const info = messages[index]?.info;
-    if (info?.role !== "user") continue;
-    const providerID = info.model?.providerID;
-    const modelID = info.model?.modelID;
-    if (typeof providerID === "string" && typeof modelID === "string") {
-      return { providerID, modelID };
-    }
-  }
-  return null;
-}
-async function resolveSessionModel(client, sessionID) {
-  try {
-    const response = await client.session.messages({ path: { id: sessionID } });
-    return latestUserModel(response.data ?? response);
-  } catch {
-    return null;
-  }
-}
-
-// lib/prune-service.ts
-var PruneService = class {
-  deferred = /* @__PURE__ */ new Set();
-  client;
-  summarize;
-  logger;
-  probeTimeoutMs;
-  /** THE single busy/idle event state machine (absorbed the former
-   * SessionActivityTracker — no second busy cache may exist). */
-  boundary;
-  constructor(deps) {
-    this.client = deps.client;
-    this.summarize = deps.summarize;
-    this.logger = deps.logger;
-    this.probeTimeoutMs = deps.probeTimeoutMs ?? PROBE_TIMEOUT_MS;
-    this.boundary = new SessionBoundaryTracker({
-      probeBusy: (sessionID) => this.probeBusy(sessionID),
-      logger: deps.logger,
-      now: deps.now,
-      setTimer: deps.setTimer,
-      clearTimer: deps.clearTimer
-    });
-    this.boundary.onAtRest((sessionID) => {
-      if (!this.deferred.delete(sessionID)) return;
-      void this.drainQueued(sessionID);
-    });
-  }
-  /**
-   * Feed every host event through here. `session.status` and legacy
-   * `session.idle` feed the boundary tracker (quiet window + expiry probe);
-   * the deferral queue drains at the confirmed at-rest classification, and
-   * queued prunes are forgotten once a compaction (or the session itself)
-   * is gone.
-   */
-  observeEvent(type, properties) {
-    const sessionID = eventSessionID(properties);
-    if (type === "session.status") {
-      this.boundary.observeStatus(sessionID, properties?.status?.type);
-      return;
-    }
-    if (type === "session.idle") {
-      this.boundary.observeLegacyIdle(sessionID);
-      return;
-    }
-    if (!sessionID) return;
-    if (type === "session.compacted") {
-      this.deferred.delete(sessionID);
-      this.boundary.observeCompacted(sessionID);
-      return;
-    }
-    if (type === "session.deleted") {
-      this.deferred.delete(sessionID);
-      this.boundary.observeDeleted(sessionID);
-    }
-  }
-  async request(request) {
-    const beforeModel = await this.gate(request);
-    if (beforeModel) return beforeModel;
-    const model = await resolveSessionModel(this.client, request.sessionID);
-    if (!model) return { status: "no-model" };
-    const afterModel = await this.gate(request);
-    if (afterModel) return afterModel;
-    const serverBusy = await this.probeBusy(request.sessionID);
-    if (serverBusy === true) {
-      const fallback = await this.outcomeFor(request, { action: "stand-down" });
-      if (fallback) return fallback;
-    }
-    const result = await this.summarize.summarize({ sessionID: request.sessionID, model });
-    if (result.status === "rejected") {
-      return { status: "busy" };
-    }
-    return result;
-  }
-  /** One admission check; `null` means the request may proceed. */
-  gate(request) {
-    return this.outcomeFor(request, this.admit(request));
-  }
-  /**
-   * Executes a queued prune at the confirmed at-rest boundary. The tool
-   * already promised its caller this prune would run; losing the busy race
-   * must not silently break that promise, so a busy outcome re-queues for
-   * the next at-rest boundary. Every other outcome is terminal: it is
-   * logged and never retried — new prune demand arrives through new
-   * triggers only. Execution is re-guarded on every attempt, so re-queueing
-   * never violates the never-interrupt invariant.
-   */
-  async drainQueued(sessionID) {
-    let outcome;
-    try {
-      outcome = await this.request({ sessionID, onBusy: "proceed" });
-    } catch (error) {
-      this.logger.warn("Queued prune drain failed; the prune was not retried", {
-        sessionId: sessionID,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return;
-    }
-    if (outcome.status === "busy") {
-      this.deferred.add(sessionID);
-      return;
-    }
-    this.logger.debug("Queued prune drain finished", {
-      sessionId: sessionID,
-      status: outcome.status
-    });
-  }
-  /**
-   * Turns an admission decision into a terminal outcome, or `null` when the
-   * request may proceed. Deferral additionally enqueues the session.
-   */
-  async outcomeFor(request, admission) {
-    if (admission.action === "go") return null;
-    if (admission.action === "stand-down") return { status: "busy" };
-    this.deferred.add(request.sessionID);
-    this.logger.debug("Prune deferred to the next session at-rest boundary", {
-      sessionId: request.sessionID
-    });
-    return { status: "deferred" };
-  }
-  admit(request) {
-    if (request.onBusy === "defer") return { action: "defer" };
-    if (this.boundary.state(request.sessionID) === "busy") return { action: "stand-down" };
-    return { action: "go" };
-  }
-  /**
-   * THE single live busy probe, reused verbatim by the boundary tracker's
-   * expiry check. Bounded by a finite deadline: a never-returning probe
-   * resolves `null` within the timeout (fail-open). Returns `null` when the
-   * answer is unknown (endpoint or SDK method missing, request failed,
-   * timeout) — callers must fail open in that case.
-   */
-  async probeBusy(sessionID) {
-    const statusFn = this.client.session.status;
-    if (typeof statusFn !== "function") return null;
-    const query = (async () => {
-      try {
-        return await statusFn.call(
-          this.client.session
-        );
-      } catch {
-        return null;
-      }
-    })();
-    const response = await Promise.race([
-      query,
-      new Promise((resolve) => setTimeout(() => resolve(null), this.probeTimeoutMs))
-    ]);
-    const map = response?.data ?? response;
-    const info = map?.[sessionID];
-    return info?.type === "busy" || info?.type === "retry";
-  }
-};
-
-// lib/prune-tool.ts
 var PRUNE_TOOL_NAME = "dcp_prune";
-var PRUNE_TOOL_DESCRIPTION = `\u628A\u5F53\u524D\u4F1A\u8BDD\u7684\u65E7\u5BF9\u8BDD\u524D\u7F00\u6298\u53E0\u4E3A\u4E00\u4E2A\u6EDA\u52A8\u68C0\u67E5\u70B9\uFF08\u4FDD\u7559\u7CFB\u7EDF\u7EA7\u89C4\u5219\u3001\u538B\u7F29\u4E2D\u90E8\u5386\u53F2\u3001\u8BE6\u8FF0\u8FDB\u884C\u4E2D\u7684\u4EFB\u52A1\uFF09\uFF0C\u8FD1\u671F\u5C3E\u90E8\u4E0D\u53D7\u5F71\u54CD\u3002
+var PRUNE_TOOL_DESCRIPTION = `\u6807\u8BB0\u8BDD\u9898\u8FB9\u754C\u5E76\u52A0\u6DF1\u672C\u4F1A\u8BDD\u7684\u52A8\u6001\u4E0A\u4E0B\u6587\u6298\u53E0\u3002\u538B\u7F29\u672C\u8EAB\u7531 DCP \u5728\u6BCF\u6B21\u6A21\u578B\u8BF7\u6C42\u65F6\u81EA\u52A8\u5206\u7EA7\u5B8C\u6210\uFF08\u8FDC\u8DDD\u79BB\u91CD\u5EA6\u6298\u53E0\u3001\u5F53\u524D\u4EFB\u52A1\u8F7B\u5EA6\u6298\u53E0\u3001\u6700\u8FD1\u6570\u8F6E\u539F\u6837\u4FDD\u7559\uFF09\uFF0C\u672C\u5DE5\u5177\u53EA\u8C03\u6574\u6298\u53E0\u7B56\u7565\uFF0C\u4E0D\u6267\u884C\u4EFB\u4F55\u4F1A\u8BDD\u64CD\u4F5C\u3002
 
 \u4EC5\u5728\u8FD9\u4E9B\u60C5\u51B5\u4E0B\u8C03\u7528\uFF1A
 - \u5BF9\u8BDD\u8BDD\u9898\u53D1\u751F\u660E\u663E\u53D8\u66F4\uFF1A\u5F00\u59CB\u5904\u7406\u65B0\u7684\u95EE\u9898\u57DF\u3001\u5207\u6362\u5230\u53E6\u4E00\u4E2A\u6A21\u5757/\u4ED3\u5E93/\u4EFB\u52A1\uFF1B
 - \u7528\u6237\u660E\u786E\u8981\u6C42\u538B\u7F29\u4E0A\u4E0B\u6587\u3002
 
-\u540C\u4E00\u4EFB\u52A1\u5185\u7684\u591A\u8F6E\u8FFD\u95EE\u3001\u53C2\u6570\u5FAE\u8C03\u3001\u5EF6\u7EED\u5F53\u524D\u5DE5\u4F5C\uFF0C\u90FD\u4E0D\u8981\u8C03\u7528\u3002\u8C03\u7528\u4E0D\u4F1A\u6253\u65AD\u5F53\u524D\u5DE5\u4F5C\uFF1A\u538B\u7F29\u4F1A\u6392\u961F\uFF0C\u5E76\u5728\u4E0B\u4E00\u4E2A\u786E\u8BA4\u7684\u9759\u606F\u8FB9\u754C\uFF08\u77ED\u6682\u9759\u9ED8\u7A97\u53E3\u52A0\u5B9E\u65F6\u72B6\u6001\u68C0\u67E5\uFF09\u5C1D\u8BD5\u6267\u884C\uFF1B\u5E76\u53D1\u8BF7\u6C42\u81EA\u52A8\u5408\u5E76\uFF0C\u5931\u8D25\u4E0D\u4F1A\u7834\u574F\u73B0\u6709\u4E0A\u4E0B\u6587\u3002\u4E0D\u8981\u4E3A\u540C\u4E00\u8BDD\u9898\u53CD\u590D\u8C03\u7528\u3002`;
+\u540C\u4E00\u4EFB\u52A1\u5185\u7684\u591A\u8F6E\u8FFD\u95EE\u3001\u53C2\u6570\u5FAE\u8C03\u3001\u5EF6\u7EED\u5F53\u524D\u5DE5\u4F5C\uFF0C\u90FD\u4E0D\u8981\u8C03\u7528\u3002\u8C03\u7528\u77AC\u65F6\u5B8C\u6210\uFF0C\u7EDD\u4E0D\u6253\u65AD\u5F53\u524D\u5DE5\u4F5C\uFF1A\u65E7\u4EFB\u52A1\u5185\u5BB9\u4ECE\u4E0B\u4E00\u6B21\u6A21\u578B\u8BF7\u6C42\u8D77\u88AB\u6298\u53E0\u4E3A\u7ED3\u6784\u5316\u6458\u8981\uFF0C\u6700\u8FD1\u5BF9\u8BDD\u4E0E\u5F53\u524D\u4EFB\u52A1\u7EC6\u8282\u4E0D\u53D7\u5F71\u54CD\u3002\u4E0D\u8981\u4E3A\u540C\u4E00\u8BDD\u9898\u53CD\u590D\u8C03\u7528\u3002`;
 function createPruneTool(deps) {
   return tool({
     description: PRUNE_TOOL_DESCRIPTION,
     args: {},
     execute: async (_args, context) => {
       const sessionID = context.sessionID;
-      const result = await deps.prune.request({ sessionID, onBusy: "defer" });
-      if (result.status === "succeeded") {
-        deps.logger.debug("Prune tool triggered native compaction", {
-          sessionId: sessionID
-        });
-        return "DCP\uFF1A\u8BED\u4E49\u538B\u7F29\u5B8C\u6210\uFF0C\u65E7\u4E0A\u4E0B\u6587\u5DF2\u6298\u53E0\u4E3A\u65B0\u68C0\u67E5\u70B9\u3002";
-      }
-      if (result.status === "deferred") {
-        return "DCP\uFF1A\u4F1A\u8BDD\u4ECD\u5728\u5DE5\u4F5C\u4E2D\uFF0C\u538B\u7F29\u5DF2\u6392\u961F\uFF0C\u5C06\u5728\u4E0B\u4E00\u4E2A\u786E\u8BA4\u7684\u9759\u606F\u8FB9\u754C\u5C1D\u8BD5\u81EA\u52A8\u6267\u884C\uFF1B\u5F53\u524D\u4E0A\u4E0B\u6587\u4E0D\u53D7\u5F71\u54CD\u3002";
-      }
-      if (result.status === "busy") {
-        return "DCP\uFF1A\u4F1A\u8BDD\u6B63\u5FD9\uFF0C\u4E3A\u907F\u514D\u6253\u65AD\u5F53\u524D\u5DE5\u4F5C\uFF0C\u672C\u6B21\u672A\u6267\u884C\u538B\u7F29\u3002";
-      }
-      if (result.status === "cooldown") {
-        return `DCP\uFF1A\u4E0A\u4E00\u6B21\u538B\u7F29\u5931\u8D25\uFF0C${retrySeconds(result.retryAfterMs)} \u79D2\u540E\u624D\u80FD\u91CD\u8BD5\u3002`;
-      }
-      if (result.status === "no-model") {
-        return "DCP\uFF1A\u4F1A\u8BDD\u4E2D\u8FD8\u6CA1\u6709\u53EF\u7528\u7684\u6A21\u578B\u4FE1\u606F\uFF0C\u65E0\u6CD5\u6267\u884C\u538B\u7F29\u3002";
-      }
-      return `DCP\uFF1A\u538B\u7F29\u5931\u8D25\uFF08${result.error}\uFF09\uFF0C\u539F\u59CB\u4E0A\u4E0B\u6587\u4FDD\u6301\u4E0D\u53D8\u3002`;
+      const now = (deps.now ?? Date.now)();
+      deps.state.markBoundary(sessionID, now, 2);
+      deps.logger.debug("Prune tool marked a topic boundary", {
+        sessionId: sessionID
+      });
+      return "DCP\uFF1A\u5DF2\u6807\u8BB0\u8BDD\u9898\u8FB9\u754C\u5E76\u52A0\u6DF1\u672C\u4F1A\u8BDD\u6298\u53E0\u2014\u2014\u65E7\u4EFB\u52A1\u5185\u5BB9\u5C06\u4ECE\u4E0B\u4E00\u6B21\u6A21\u578B\u8BF7\u6C42\u8D77\u5206\u7EA7\u6298\u53E0\u4E3A\u7ED3\u6784\u5316\u6458\u8981\uFF1B\u6700\u8FD1\u5BF9\u8BDD\u4E0E\u5F53\u524D\u4EFB\u52A1\u7EC6\u8282\u4E0D\u53D7\u5F71\u54CD\uFF0C\u4F1A\u8BDD\u672A\u4E2D\u65AD\u3002";
     }
   });
 }
 
-// lib/summarize.ts
-function errorMessage(error) {
-  if (error instanceof Error) return error.message;
-  if (typeof error === "string") return error;
-  try {
-    return JSON.stringify(error);
-  } catch {
-    return "Unknown native compaction error";
-  }
-}
-function isBusyRejection(error) {
-  if (error instanceof Error && /\bbusy\b/i.test(error.message)) return true;
-  if (typeof error === "string" && /\bbusy\b/i.test(error)) return true;
-  const structured = error;
-  if (!structured || typeof structured !== "object") return false;
-  if (structured.status === 409 || structured.statusCode === 409 || structured.code === 409) {
-    return true;
-  }
-  return typeof structured.name === "string" && /busy/i.test(structured.name);
-}
-var SummarizeCoordinator = class {
-  constructor(client, logger, options) {
-    this.client = client;
-    this.logger = logger;
-    this.options = options;
-    this.now = options.now ?? Date.now;
-  }
-  inFlight = /* @__PURE__ */ new Map();
-  failedAt = /* @__PURE__ */ new Map();
-  now;
-  summarize(request) {
-    const active = this.inFlight.get(request.sessionID);
-    if (active) return active;
-    const failedAt = this.failedAt.get(request.sessionID);
-    if (failedAt !== void 0) {
-      const retryAfterMs = this.options.failureCooldownMs - (this.now() - failedAt);
-      if (retryAfterMs > 0) {
-        return Promise.resolve({ status: "cooldown", retryAfterMs });
-      }
-      this.failedAt.delete(request.sessionID);
-    }
-    const promise = this.invokeNative(request).finally(() => {
-      if (this.inFlight.get(request.sessionID) === promise) {
-        this.inFlight.delete(request.sessionID);
-      }
-    });
-    this.inFlight.set(request.sessionID, promise);
-    return promise;
-  }
-  async invokeNative(request) {
-    try {
-      const response = await this.client.session.summarize({
-        path: { id: request.sessionID },
-        body: request.model
-      });
-      const nativeError = response?.error;
-      if (nativeError && isBusyRejection(nativeError)) {
-        return { status: "rejected", reason: "busy" };
-      }
-      if (nativeError || response?.data !== true) {
-        throw new Error(errorMessage(nativeError ?? "Native summarize returned false"));
-      }
-      this.failedAt.delete(request.sessionID);
-      return { status: "succeeded" };
-    } catch (error) {
-      if (isBusyRejection(error)) {
-        return { status: "rejected", reason: "busy" };
-      }
-      this.failedAt.set(request.sessionID, this.now());
-      const message = errorMessage(error);
-      await this.logger.warn("Native summarize failed; context remains unchanged", {
-        sessionId: request.sessionID,
-        error: message
-      });
-      return { status: "failed", error: message };
-    }
-  }
-};
-
 // lib/update.ts
 import { readFile } from "fs/promises";
 import { basename, dirname as dirname3, join as join4 } from "path";
@@ -2654,57 +2443,48 @@ var server = (async (ctx) => {
     config.experimental.customPrompts,
     config.language
   );
-  const summarize = new SummarizeCoordinator(ctx.client, logger, {
-    failureCooldownMs: config.summarize.failureCooldownMs
-  });
-  const prune = new PruneService({ client: ctx.client, summarize, logger });
-  const autoPruner = new AutoPruner(config.autoPrune);
-  if (config.autoPrune.enabled) {
-    prune.boundary.onAtRest(
-      createAtRestAutoPruneListener({
-        client: ctx.client,
-        prune,
-        autoPruner,
-        config: config.autoPrune,
-        logger
-      })
-    );
-  }
+  const state = new DtcState();
   logger.info("DCP initialized", {
     commands: config.commands.enabled,
-    autoPrune: config.autoPrune.enabled,
+    dtc: config.dtc.enabled,
     tool: config.tool.enabled,
     customPrompts: config.experimental.customPrompts
   });
   startAutoUpdate(ctx, config.autoUpdate);
   return {
-    "experimental.session.compacting": createSessionCompactingHandler(prompts, logger),
-    ...config.autoPrune.enabled && {
-      "chat.message": createChatMessageHandler(autoPruner)
-    },
-    // The event feed drives both the boundary classification (status/idle
-    // observations) and the tool's deferred prunes, so it stays registered
-    // whenever either surface is on.
-    ...(config.autoPrune.enabled || config.tool.enabled) && {
-      event: createEventHandler({
-        prune,
-        autoPruner,
+    "experimental.session.compacting": createSessionCompactingHandler({
+      prompts,
+      logger,
+      client: ctx.client,
+      state
+    }),
+    // THE compression surface: dynamic tiered folding on every model
+    // request, plus the chat.params feed that teaches the engine each
+    // session's context-window size.
+    ...config.dtc.enabled && {
+      "experimental.chat.messages.transform": createTransformHandler({
+        state,
+        config: config.dtc,
         logger
-      })
+      }),
+      "chat.params": createChatParamsHandler({ state, logger })
     },
+    // Lifecycle cleanup for DTC session state (LRU-bounded regardless).
+    event: createEventHandler({ state, logger }),
     ...config.tool.enabled && {
-      tool: { [PRUNE_TOOL_NAME]: createPruneTool({ prune, logger }) }
+      tool: { [PRUNE_TOOL_NAME]: createPruneTool({ state, logger }) }
     },
     ...config.commands.enabled && {
-      "command.execute.before": createCommandExecuteHandler(ctx.client, prune, logger),
-      config: async (opencodeConfig) => {
-        opencodeConfig.command ??= {};
-        opencodeConfig.command.dcp = {
-          template: "",
-          description: "Run semantic context pruning with native compaction"
-        };
-      }
-    }
+      "command.execute.before": createCommandExecuteHandler({
+        client: ctx.client,
+        state,
+        config: config.dtc,
+        logger
+      })
+    },
+    // Always registered: besides the optional /dcp command it raises the
+    // host's compaction tail protection to DCP's tiered defaults.
+    config: createConfigHandler(config, logger)
   };
 });
 var index_default = server;