@lexwdex-org/opencode-dcp 5.0.0 → 5.0.2

package/README.en.md

@@ -24,7 +24,7 @@ The host fires `experimental.chat.messages.transform` before every model request
 - **M middle zone**: long texts keep their first line; tool outputs get the host's native fold marker (rendered by the host as its own `[Old tool result content cleared]`); **tool arguments reduce to a target skeleton** (only filePath / command first line and friends — `oldString`/`newString`/`content` payloads are dropped); **failed attempts (error parts) fold to a short first line** — three edits on one file with two failures collapse to three recognizable call skeletons plus two single-line errors, with the final state owned by disk and the current-task zone; reasoning is emptied.
 - **D distant zone**: whole turns collapse into one mechanical digest line (intent / actions / files touched / outcome / error count) and tool inputs are cleared — hard facts live on in the digest.
 
-**Dynamic budget**: below `lowWatermarkRatio` of the context window (default 50%) **nothing is folded at all** — short sessions pay zero cost. Above it, folding escalates D→M→C from the far end until the estimate fits `targetRatio` (default 70%). The window size is learned per session from the `chat.params` hook; until it is known the engine fails open (no folding).
+**Dynamic budget**: below `lowWatermarkRatio` of the context window (default 50%) **nothing is folded at all** — short sessions pay zero cost. Above it, folding escalates D→M→C from the far end until the estimate fits `targetRatio` (default 70%). The window size is learned per session from the `chat.params` hook; until it is known the engine fails open (no folding). Session attribution reads `sessionID` straight off the message payload on official hosts; on fork hosts that strip message IDs into database columns, DTC falls back to a `chat.params`-recorded "user-message timestamp → session" index (content-keyed, so concurrent sessions never cross-attribute; a session's very first request has no record yet and skips folding).
 
 **Three structural laws** (the constructive exclusion of the old versions' "lost markers" failure):
 
@@ -89,7 +89,7 @@ DCP reads these layers in order; later layers override earlier ones:
 
 ## Migrating from 3.x / 4.0
 
-The 3.x `summarize` and `autoPrune` config blocks are gone (DCP no longer calls native summarize and has no heuristic triggers); since 4.1 `language` and `experimental.customPrompts` are gone as well — DCP no longer replaces the host's compaction prompt, so the `dcp-prompts` override machinery retired with it. Such keys produce a migration warning and are ignored. `autoPrune.driftThreshold` migrates automatically to `dtc.driftThreshold`. Older `compress`, `manualMode`, `strategies`, `turnProtection` keys remain removed.
+The 3.x `summarize` and `autoPrune` config blocks are gone (DCP no longer calls native summarize and has no heuristic triggers); since 5.0 `language` and `experimental.customPrompts` are gone as well — DCP no longer replaces the host's compaction prompt, so the `dcp-prompts` override machinery retired with it. Such keys produce a migration warning and are ignored. `autoPrune.driftThreshold` migrates automatically to `dtc.driftThreshold`. Older `compress`, `manualMode`, `strategies`, `turnProtection` keys remain removed.
 
 Behavior change: compression no longer produces a visible "checkpoint turn" and needs no at-rest boundaries or continuation machinery — context folds automatically inside each request, invisible to the session and its state machine. Semantic checkpoints are fully handed back to the host's native compaction (manual `/compact` or the overflow fallback): native prompt, native rolling merge — DCP only contributes the tail-protection defaults and full-fidelity protection of the summarizer input.
 

package/README.md

@@ -24,7 +24,7 @@ DCP 以**动态分级请求期压缩（DTC）**管理 OpenCode 会话上下文
 - **M 中距离区**：长文本保留首行；tool 输出打宿主原生折叠标记（渲染为宿主自己的 `[Old tool result content cleared]`）；**tool 参数规约为目标骨架**（仅留 filePath/command 首行等，`oldString`/`newString`/`content` 等载荷全部丢弃）；**失败尝试（error part）折为短首行**——同一文件连改 3 次错 2 次，折叠后只剩 3 个可辨识调用骨架 + 2 条单行错误，最终状态以磁盘与当前任务区为准；推理内容清空。
 - **D 远距离区**：整轮塌缩为一行机械摘要（意图 / 动作 / 涉及文件 / 结果 / 错误数），tool 参数一并清空——硬事实保留在摘要里。
 
-**动态预算**：估算低于上下文窗口的 `lowWatermarkRatio`（默认 50%）时**完全不折叠**，短会话零开销；超出则按 D→M→C 从远到近逐级加深，直到估算落回 `targetRatio`（默认 70%）以内。窗口大小由 `chat.params` 钩子按会话自动学习，未知时 fail-open 不折叠。
+**动态预算**：估算低于上下文窗口的 `lowWatermarkRatio`（默认 50%）时**完全不折叠**，短会话零开销；超出则按 D→M→C 从远到近逐级加深，直到估算落回 `targetRatio`（默认 70%）以内。窗口大小由 `chat.params` 钩子按会话自动学习，未知时 fail-open 不折叠。会话归属按官方宿主形状直读消息体 `sessionID`；fork 宿主把 id/sessionID 剥离进数据库列时，自动改用 `chat.params` 预记录的「用户消息时间戳 → 会话」索引反查归属（内容键关联，并发会话不串扰；会话首个请求尚无记录则跳过折叠）。
 
 **三条结构铁律**（老版本"丢失标记号"问题的构造性排除）：
 
@@ -89,7 +89,7 @@ DCP 依次读取以下配置，后面的层覆盖前面的层：
 
 ## 从 3.x / 4.0 迁移
 
-3.x 的 `summarize`、`autoPrune` 配置块已删除（DCP 不再调用原生 summarize，也不再有启发式触发器）；4.1 起 `language` 与 `experimental.customPrompts` 也已删除——DCP 不再替换宿主压缩提示词，`dcp-prompts` 覆盖机制随之退役。这些键会显示迁移警告并被忽略。`autoPrune.driftThreshold` 自动迁移为 `dtc.driftThreshold`。更早的 `compress`、`manualMode`、`strategies`、`turnProtection` 等键维持删除状态。
+3.x 的 `summarize`、`autoPrune` 配置块已删除（DCP 不再调用原生 summarize，也不再有启发式触发器）；5.0 起 `language` 与 `experimental.customPrompts` 也已删除——DCP 不再替换宿主压缩提示词，`dcp-prompts` 覆盖机制随之退役。这些键会显示迁移警告并被忽略。`autoPrune.driftThreshold` 自动迁移为 `dtc.driftThreshold`。更早的 `compress`、`manualMode`、`strategies`、`turnProtection` 等键维持删除状态。
 
 行为变化：压缩不再产生可见的"检查点回合"，也不再需要任何静息边界或续跑机制——上下文折叠在每次请求内自动完成，会话与状态机零感知。语义检查点完全交还宿主原生 compaction（手动 `/compact` 或溢出兜底）：原生提示词、原生滚动合并，DCP 仅贡献尾部保护默认值与摘要输入的全保真保护。
 

package/dist/index.js

@@ -1028,6 +1028,7 @@ function estimateSlice(messages, start, end) {
       }
       if (typeof state.output === "string") tokens += estimateTokens(state.output);
       if (state.input) tokens += estimateTokens(JSON.stringify(state.input));
+      if (typeof state.error === "string") tokens += estimateTokens(state.error);
     }
   }
   return tokens;
@@ -1080,7 +1081,7 @@ 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);
+  const sessionID = findSessionID(messages, deps.state);
   if (sessionID && deps.state.consumeCompactionSkip(sessionID)) {
     stats.skipped = "compaction";
     return stats;
@@ -1111,11 +1112,18 @@ function transformMessages(messages, deps) {
   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 appliedBand = 0;
+  const applyUpTo = (lvl) => {
+    while (appliedBand < lvl) {
+      appliedBand++;
+      applyBand(messages, headTurns, zones, appliedBand, deps, stats, now);
+    }
+  };
+  applyUpTo(level);
   let estimatedAfter = estimateSlice(messages, 0, messages.length);
   while (estimatedAfter > target && level < 3) {
     level = level + 1;
-    applyLevel(messages, headTurns, zones, level, deps, stats, now);
+    applyUpTo(level);
     estimatedAfter = estimateSlice(messages, 0, messages.length);
   }
   stats.level = level;
@@ -1154,19 +1162,16 @@ function computeZones(messages, headTurns, sessionID, state, config) {
   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) {
+function applyBand(messages, headTurns, zones, band, deps, stats, now) {
+  if (band === 1) {
     for (let t = 0; t < zones.mStart; t++) {
       foldDistant(messages, headTurns[t], t + 1, deps, stats, now);
     }
-  }
-  if (level >= 2 && prev < 2) {
+  } else if (band === 2) {
     for (let t = zones.mStart; t < zones.cStart; t++) {
       foldMiddle(messages, headTurns[t], stats, now);
     }
-  }
-  if (level >= 3 && prev < 3) {
+  } else if (band === 3) {
     for (let t = zones.cStart; t < headTurns.length; t++) {
       foldCurrent(messages, headTurns[t], deps.config.toolOutputKeepChars, stats);
     }
@@ -1289,11 +1294,20 @@ function foldErrorPart(part, keepChars, clearInput, stats) {
     stats.reducedInputs++;
   }
 }
-function findSessionID(messages) {
+function findSessionID(messages, state) {
   for (const message of messages) {
     const id = message?.info?.sessionID;
     if (typeof id === "string" && id) return id;
   }
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.info?.role !== "user") continue;
+    if ((message.parts ?? []).some((p) => p?.type === "compaction")) continue;
+    const created = message.info?.time?.created;
+    if (typeof created !== "number") continue;
+    const sessionID = state.sessionByUserTime(created);
+    if (sessionID) return sessionID;
+  }
   return void 0;
 }
 
@@ -1689,6 +1703,7 @@ Using previous/default values`
 // lib/dtc/state.ts
 var SESSION_LIMIT = 500;
 var DIGEST_LIMIT = 2e3;
+var PARAMS_INDEX_LIMIT = 200;
 function lruSet(map, key, value, limit) {
   if (map.has(key)) map.delete(key);
   map.set(key, value);
@@ -1701,6 +1716,8 @@ function lruSet(map, key, value, limit) {
 var DtcState = class {
   sessions = /* @__PURE__ */ new Map();
   digests = /* @__PURE__ */ new Map();
+  /** User-message creation time → sessionID, fed by `chat.params`. */
+  paramsIndex = /* @__PURE__ */ new Map();
   observeContextLimit(sessionID, contextTokens) {
     if (!sessionID || !contextTokens || !Number.isFinite(contextTokens) || contextTokens <= 0) {
       return;
@@ -1712,7 +1729,27 @@ var DtcState = class {
   contextTokens(sessionID) {
     return this.sessions.get(sessionID)?.contextTokens;
   }
-  /** Called by the compacting hook; consumed by the very next transform. */
+  /**
+   * Fork hosts strip id/sessionID out of message payloads (they live in
+   * database columns), so the transform cannot read the session off the
+   * messages like it does on the official host. `chat.params` fires on
+   * every request carrying both the sessionID and the triggering user
+   * message; recording that pair lets the NEXT request's transform resolve
+   * its session by matching user-message creation times. The key is
+   * content (a timestamp), not recency, so concurrent sessions never
+   * cross-attribute.
+   */
+  recordParamsSession(sessionID, userTimeCreated) {
+    if (!sessionID || !Number.isFinite(userTimeCreated)) return;
+    lruSet(this.paramsIndex, userTimeCreated, sessionID, PARAMS_INDEX_LIMIT);
+  }
+  sessionByUserTime(userTimeCreated) {
+    return this.paramsIndex.get(userTimeCreated);
+  }
+  /** Called by the compacting hook; consumed by the very next transform.
+   * Accepted leak: if the host aborts between the hook and the summarizer
+   * transform, the flag skips folding once for the next unrelated request —
+   * fail-open (extra tokens, never lost information) and self-healing. */
   armCompactionSkip(sessionID) {
     const state = this.session(sessionID);
     state.skipNextTransform = true;
@@ -1745,10 +1782,17 @@ var DtcState = class {
   }
   dropSession(sessionID) {
     this.sessions.delete(sessionID);
+    for (const [time, sid] of this.paramsIndex) {
+      if (sid === sessionID) this.paramsIndex.delete(time);
+    }
   }
   /** Test/inspection surface. */
   stats() {
-    return { sessions: this.sessions.size, digests: this.digests.size };
+    return {
+      sessions: this.sessions.size,
+      digests: this.digests.size,
+      params: this.paramsIndex.size
+    };
   }
   session(sessionID) {
     return this.sessions.get(sessionID) ?? {};
@@ -1789,6 +1833,10 @@ function createChatParamsHandler(deps) {
       if (typeof context === "number" && Number.isFinite(context) && context > 0) {
         deps.state.observeContextLimit(input.sessionID, context);
       }
+      const created = input.message?.time?.created;
+      if (input.sessionID && typeof created === "number" && Number.isFinite(created)) {
+        deps.state.recordParamsSession(input.sessionID, created);
+      }
     } catch (error) {
       deps.logger.debug("chat.params observation failed", {
         error: error instanceof Error ? error.message : String(error)