@lexwdex-org/opencode-dcp 3.5.0 → 5.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,40 +862,460 @@ 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 M_ERROR_KEEP_CHARS = 200;
+var D_ERROR_KEEP_CHARS = 100;
+var INPUT_TARGET_KEYS = ["filePath", "path", "file", "filename", "pattern", "directory"];
+var COMMAND_KEEP_CHARS = 80;
+var FOLDED_TEXT = " ";
+var NO_STATS = {
+  messages: 0,
+  userTurns: 0,
+  level: 0,
+  estimatedBefore: 0,
+  estimatedAfter: 0,
+  contextTokens: 0,
+  foldedTools: 0,
+  foldedTexts: 0,
+  reducedInputs: 0,
+  foldedErrors: 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,
+    reducedInputs: stats.reducedInputs,
+    foldedErrors: stats.foldedErrors,
+    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 (part.type === "tool" && part.state?.status === "error") {
+        foldErrorPart(part, D_ERROR_KEEP_CHARS, true, stats);
+        continue;
+      }
+      if (foldToolPart(part, now, "distant", stats)) {
+        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 (part.type === "tool" && part.state?.status === "error") {
+        foldErrorPart(part, M_ERROR_KEEP_CHARS, false, stats);
+        continue;
+      }
+      if (foldToolPart(part, now, "middle", stats)) {
+        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 reduceInput(input) {
+  if (!input || typeof input !== "object") return {};
+  const reduced = {};
+  for (const key of INPUT_TARGET_KEYS) {
+    const value = input[key];
+    if (typeof value === "string" && value) reduced[key] = value;
+  }
+  const command = input.command;
+  if (typeof command === "string" && command) {
+    reduced.command = firstLine(command, COMMAND_KEEP_CHARS);
+  }
+  return reduced;
+}
+function foldToolPart(part, now, zone, stats) {
+  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 (state.input && typeof state.input === "object") {
+    state.input = zone === "distant" ? {} : reduceInput(state.input);
+    stats.reducedInputs++;
+  }
+  return true;
+}
+function foldErrorPart(part, keepChars, clearInput, stats) {
+  const state = part.state;
+  if (!state) return;
+  if (typeof state.error === "string" && state.error.length > keepChars) {
+    state.error = firstLine(state.error, keepChars) || FOLDED_TEXT;
+    stats.foldedErrors++;
+  }
+  if (state.input && typeof state.input === "object") {
+    state.input = clearInput ? {} : reduceInput(state.input);
+    stats.reducedInputs++;
+  }
+}
+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",
   "enabled",
   "autoUpdate",
   "debug",
-  "language",
   "commands",
   "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 +1360,24 @@ var DEPRECATED_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "pruneNotificationType",
   "protectedFilePatterns",
   "commands.protectedTools",
-  "experimental.allowSubAgents"
+  "experimental.allowSubAgents",
+  "language",
+  "experimental",
+  "experimental.customPrompts",
+  "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 = [];
@@ -1087,21 +1409,10 @@ function validateConfigTypes(config) {
   if (config.debug !== void 0 && typeof config.debug !== "boolean") {
     errors.push({ key: "debug", expected: "boolean", actual: typeof config.debug });
   }
-  if (config.language !== void 0 && config.language !== "zh" && config.language !== "en") {
-    errors.push({
-      key: "language",
-      expected: '"zh" or "en"',
-      actual: JSON.stringify(config.language)
-    });
-  }
   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",
@@ -1110,141 +1421,65 @@ 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
-      });
-    } else if (experimental.customPrompts !== void 0 && typeof experimental.customPrompts !== "boolean") {
-      errors.push({
-        key: "experimental.customPrompts",
-        expected: "boolean",
-        actual: typeof experimental.customPrompts
-      });
-    }
-  }
-  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) {
@@ -1279,17 +1514,10 @@ var defaultConfig = {
   enabled: true,
   autoUpdate: true,
   debug: false,
-  language: "zh",
   commands: {
     enabled: true
   },
-  experimental: {
-    customPrompts: false
-  },
-  summarize: {
-    failureCooldownMs: DEFAULT_FAILURE_COOLDOWN_MS
-  },
-  autoPrune: { ...DEFAULT_AUTO_PRUNE },
+  dtc: { ...DEFAULT_DTC },
   tool: {
     enabled: true
   }
@@ -1367,41 +1595,19 @@ function mergeCommands(base, override) {
     enabled: typeof override.enabled === "boolean" ? override.enabled : base.enabled
   };
 }
-function mergeExperimental(base, override) {
-  if (!override) {
-    return base;
-  }
-  return {
-    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) {
@@ -1416,9 +1622,7 @@ function deepCloneConfig(config) {
   return {
     ...config,
     commands: { ...config.commands },
-    experimental: { ...config.experimental },
-    summarize: { ...config.summarize },
-    autoPrune: { ...config.autoPrune, signals: { ...config.autoPrune.signals } },
+    dtc: { ...config.dtc },
     tool: { ...config.tool }
   };
 }
@@ -1427,11 +1631,8 @@ function mergeLayer(config, data) {
     enabled: typeof data.enabled === "boolean" ? data.enabled : config.enabled,
     autoUpdate: typeof data.autoUpdate === "boolean" ? data.autoUpdate : config.autoUpdate,
     debug: typeof data.debug === "boolean" ? data.debug : config.debug,
-    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 +1686,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 +1765,138 @@ function eventSessionID(properties) {
 }
 
 // lib/hooks.ts
-function createSessionCompactingHandler(prompts, logger) {
-  return async (input, output) => {
+var DEFAULT_TAIL_TURNS = 4;
+var DEFAULT_PRESERVE_RECENT_TOKENS = 32e3;
+function createSessionCompactingHandler(deps) {
+  return async (input, _output) => {
     try {
-      prompts.reload();
-      const prompt = prompts.getRuntimePrompts().compaction;
-      if (!output.prompt) {
-        output.prompt = prompt;
-      } else if (!output.context.includes(prompt)) {
-        output.context.push(prompt);
-      }
-      logger.debug("Applied semantic pruning prompt", { sessionId: input.sessionID });
+      deps.state.armCompactionSkip(input.sessionID);
+      deps.logger.debug("Armed DTC skip for the native compaction input", {
+        sessionId: input.sessionID
+      });
     } catch (error) {
-      logger.warn("Failed to apply semantic pruning prompt; native compaction continues", {
+      deps.logger.warn("Failed to arm the compaction skip; 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__");
   };
 }
 
@@ -2066,451 +2094,35 @@ var Logger = class {
   }
 };
 
-// lib/prompts/store.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
-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
-
-\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
-
-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
-
-\u4F7F\u7528\u4EE5\u4E0B\u56FA\u5B9A\u7ED3\u6784\uFF0C\u7701\u7565\u786E\u5B9E\u4E3A\u7A7A\u7684\u6761\u76EE\uFF1A
-
-## \u5386\u53F2\u6982\u8981
-\u65E9\u671F\u4E0E\u4E2D\u90E8\u5386\u53F2\u7684\u4E3B\u9898\u548C\u80CC\u666F\uFF0C\u6BCF\u9879\u4E00\u53E5\u8BDD\u7ED3\u8BBA\uFF1B\u8FDC\u671F\u5DF2\u5B8C\u6210\u4EFB\u52A1\u5F52\u5165\u6B64\u5904\uFF0C\u4E0D\u542B\u6267\u884C\u8FC7\u7A0B\u3002
-
-## \u5DF2\u5B8C\u6210\u4EFB\u52A1\u7684\u6982\u62EC
-\u6700\u8FD1\u7684\u5DF2\u5B8C\u6210\u4EFB\u52A1\uFF0C\u6BCF\u4E2A\u4EFB\u52A1\u4E00\u53E5\u8BDD\u6982\u62EC\u5176\u7ED3\u679C\u4E0E\u5173\u952E\u4EA7\u51FA\u3002
-
-## \u8FDB\u884C\u4E2D\u4EFB\u52A1\u8BE6\u60C5
-\u5F53\u524D\u6B63\u5728\u8FDB\u884C\u7684\u4EFB\u52A1\u9010\u9879\u5199\u6E05\uFF1A\u76EE\u6807\u3001\u5DF2\u5B8C\u6210\u6B65\u9AA4\u3001\u6D89\u53CA\u6587\u4EF6\u8DEF\u5F84\u4E0E\u63A5\u53E3\u3001\u5173\u952E\u51B3\u7B56\u3001\u9047\u5230\u7684\u963B\u585E\u3001\u4E0B\u4E00\u6B65\u5177\u4F53\u52A8\u4F5C\u3002\u672C\u8282\u5C5E\u4E8E\u8F7B\u5EA6\u538B\u7F29\u533A\uFF0C\u5B81\u53EF\u591A\u4FDD\u7559\u7EC6\u8282\uFF0C\u4E0D\u505A\u4E8C\u6B21\u63A8\u65AD\u3002
-
-## \u672A\u89E3\u51B3\u95EE\u9898
-\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.
-
-This is not a chat-log summary but a semantic pruning result one can resume working from directly. Compress by these 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.
-
-Use the following fixed structure, omitting sections that are truly empty:
-
-## History Overview
-Topics and background from early and middle history, one concluding sentence each; long-completed tasks belong here, without execution process.
-
-## Completed Task Summaries
-Recently completed tasks, one sentence per task covering its outcome and key outputs.
-
-## In-Progress Task Details
-For the current task, itemize: goal, completed steps, file paths and interfaces involved, key decisions, blockers encountered, concrete next actions. This is the lightly-compressed zone; prefer keeping more detail and avoid second-order inference.
-
-## Unresolved Issues
-Cross-task lingering risks and items awaiting confirmation. Only list items not already covered under In-Progress Task Details, to avoid duplication.
-
-Stay specific, verifiable, and project-cohesive. An in-progress task must be resumable straight from this checkpoint, without relying on intermediate process that was pruned away. Keep hard facts such as file paths, interfaces, commands, test results, and error facts, but never message IDs, block IDs, anchors, placeholders, control tags, or procedural chatter.`;
-function getCompactionPrompt(language) {
-  return language === "en" ? COMPACTION_EN : COMPACTION;
-}
-
-// lib/prompts/store.ts
-function findOpencodeDir2(startDir) {
-  let current = startDir;
-  while (current !== "/") {
-    const candidate = join3(current, ".opencode");
-    if (existsSync3(candidate) && statSync2(candidate).isDirectory()) return candidate;
-    const parent = dirname2(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return null;
-}
-function resolvePaths(workingDirectory) {
-  const configHome = process.env.XDG_CONFIG_HOME || join3(homedir3(), ".config");
-  const globalRoot = join3(configHome, "opencode", "dcp-prompts");
-  const opencodeDir = findOpencodeDir2(workingDirectory);
-  return {
-    defaultsDir: join3(globalRoot, "defaults"),
-    overrides: [
-      opencodeDir ? join3(opencodeDir, "dcp-prompts", "overrides", "compaction.md") : "",
-      process.env.OPENCODE_CONFIG_DIR ? join3(process.env.OPENCODE_CONFIG_DIR, "dcp-prompts", "overrides", "compaction.md") : "",
-      join3(globalRoot, "overrides", "compaction.md")
-    ].filter(Boolean)
-  };
-}
-function normalize(content) {
-  return content.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n").replace(/<!--[\s\S]*?-->/g, "").trim();
-}
-var PromptStore = class {
-  constructor(logger, workingDirectory, customPromptsEnabled = false, language) {
-    this.logger = logger;
-    this.customPromptsEnabled = customPromptsEnabled;
-    this.paths = resolvePaths(workingDirectory);
-    this.defaultPrompt = getCompactionPrompt(language);
-    this.runtime = { compaction: this.defaultPrompt };
-    if (customPromptsEnabled) this.ensureDefaults();
-    this.reload();
-  }
-  paths;
-  defaultPrompt;
-  runtime;
-  lastReloadAt = 0;
-  getRuntimePrompts() {
-    return { ...this.runtime };
-  }
-  reload() {
-    const now = Date.now();
-    if (now - this.lastReloadAt < 1e3) return;
-    this.lastReloadAt = now;
-    this.runtime = { compaction: this.defaultPrompt };
-    if (!this.customPromptsEnabled) return;
-    for (const path of this.paths.overrides) {
-      if (!existsSync3(path)) continue;
-      try {
-        const prompt = normalize(readFileSync2(path, "utf-8"));
-        if (prompt) this.runtime = { compaction: prompt };
-        return;
-      } catch (error) {
-        this.logger.warn("Failed to load compaction prompt override", {
-          path,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-  }
-  ensureDefaults() {
-    try {
-      mkdirSync2(this.paths.defaultsDir, { recursive: true });
-      writeFileSync2(
-        join3(this.paths.defaultsDir, "compaction.md"),
-        `${this.defaultPrompt.trim()}
-`
-      );
-      writeFileSync2(
-        join3(this.paths.defaultsDir, "README.md"),
-        "# DCP compaction prompt\n\nCopy `compaction.md` to an `overrides` directory and restart OpenCode.\n"
-      );
-    } catch (error) {
-      this.logger.warn("Failed to write bundled compaction prompt", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-};
-
 // 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";
+import { basename, dirname as dirname2, join as join3 } from "path";
 import { fileURLToPath } from "url";
 var PACKAGE_NAME = "@lexwdex-org/opencode-dcp";
 function startAutoUpdate(ctx, enabled) {
@@ -2536,7 +2148,7 @@ function startAutoUpdate(ctx, enabled) {
 async function checkAutoUpdate(signal) {
   const packageDir = await findPackageDir(PACKAGE_NAME);
   if (!packageDir) return { available: false };
-  const pkg = await readPackageJson(join4(packageDir, "package.json"));
+  const pkg = await readPackageJson(join3(packageDir, "package.json"));
   if (!pkg?.name || !pkg.version) return { available: false };
   const latest = await fetchLatestVersion(pkg.name, signal);
   if (!latest || !isVersionNewer(latest, pkg.version)) return { available: false };
@@ -2545,21 +2157,21 @@ async function checkAutoUpdate(signal) {
   return { available: true, name: pkg.name, current: pkg.version, latest };
 }
 async function findPackageDir(name) {
-  let dir = dirname3(fileURLToPath(import.meta.url));
+  let dir = dirname2(fileURLToPath(import.meta.url));
   for (; ; ) {
-    const pkg = await readPackageJson(join4(dir, "package.json"));
+    const pkg = await readPackageJson(join3(dir, "package.json"));
     if (pkg?.name === name) return dir;
-    const parent = dirname3(dir);
+    const parent = dirname2(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
 }
 async function findAutoUpdateWrapperDir(packageDir, name) {
-  const packageParent = dirname3(packageDir);
-  const nodeModulesDir = basename(packageParent).startsWith("@") ? dirname3(packageParent) : packageParent;
+  const packageParent = dirname2(packageDir);
+  const nodeModulesDir = basename(packageParent).startsWith("@") ? dirname2(packageParent) : packageParent;
   if (basename(nodeModulesDir) !== "node_modules") return void 0;
-  const wrapperDir = dirname3(nodeModulesDir);
-  const wrapperPkg = await readPackageJson(join4(wrapperDir, "package.json"));
+  const wrapperDir = dirname2(nodeModulesDir);
+  const wrapperPkg = await readPackageJson(join3(wrapperDir, "package.json"));
   const spec = wrapperSpec(wrapperDir, name) ?? wrapperPkg?.dependencies?.[name];
   if (!spec || !isAutoUpdatableSpec(spec)) return void 0;
   return wrapperDir;
@@ -2567,7 +2179,7 @@ async function findAutoUpdateWrapperDir(packageDir, name) {
 function wrapperSpec(wrapperDir, name) {
   if (name.startsWith("@")) {
     const [scope, pkg] = name.split("/");
-    if (!scope || !pkg || basename(dirname3(wrapperDir)) !== scope) return void 0;
+    if (!scope || !pkg || basename(dirname2(wrapperDir)) !== scope) return void 0;
     const prefix2 = `${pkg}@`;
     const base2 = basename(wrapperDir);
     return base2.startsWith(prefix2) ? base2.slice(prefix2.length) : void 0;
@@ -2648,63 +2260,45 @@ var server = (async (ctx) => {
   const config = getConfig(ctx);
   if (!config.enabled) return {};
   const logger = new Logger(config.debug);
-  const prompts = new PromptStore(
-    logger,
-    ctx.directory,
-    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,
-    tool: config.tool.enabled,
-    customPrompts: config.experimental.customPrompts
+    dtc: config.dtc.enabled,
+    tool: config.tool.enabled
   });
   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,
+    // 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. The compacting hook rides along
+    // solely to keep the host's native compaction input unfolded — the
+    // native prompt is never touched. With DTC off, DCP registers no
+    // compaction-adjacent hook at all.
+    ...config.dtc.enabled && {
+      "experimental.chat.messages.transform": createTransformHandler({
+        state,
+        config: config.dtc,
         logger
-      })
+      }),
+      "chat.params": createChatParamsHandler({ state, logger }),
+      "experimental.session.compacting": createSessionCompactingHandler({ 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;