rcs-context 0.0.0-stage → 0.1.39

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ScreamingMaggot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,195 @@
-# Temporary Holding Version
+# RCS — 上下文折叠 · 外置推理 · 转录日志 · 外部记忆
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![dshfind](https://dshfind.com/api/badge/ScreamingMaggot/rcs-context?lang=zh)](https://dshfind.com/zh/plugins/ScreamingMaggot/rcs-context?ref=badge)
+
+**给 DeepSeek Harness (DSH) 的插件包。** 长会话里工具输出和模型回复很快把上下文吃满，RCS 把它们压成可随时展开的一行摘要，把会话事实沉淀成带证据的外部记忆。
+
+> 同样的窗口跑更多轮，同样的轮数花更少 token；折叠是**可逆**的——原文永远能展开，证据不丢。
+
+## 它解决什么问题
+
+一个真实的 DSH 长会话里，**工具输出 + 模型回复**往往比用户输入大两个数量级。几百步之后会出现三件事：
+
+1. **窗口被吃满** —— 1M token 的窗口也会被工具日志填到 40% 以上；
+2. **宿主原生压缩反复触发** —— 每次都要把整段对话交给主模型重新总结，**贵**，而且**不可逆**：细节一旦被总结就找不回来；
+3. **记忆无处安放** —— 上个会话的结论、约束、文件位置，下个会话要从零再说一遍。
+
+RCS 用三件事同时处理它们：**折叠**（省窗口）、**外置推理**（省主模型轮次）、**外部记忆**（跨会话）。四个插件可独立启停，互不依赖。
+
+## 实测：折叠到底省了多少
+
+本机真实会话档案，DSH 0.2.2-rc.1 + `deepseek-v4.1-flash`（1,048,576 token 窗口），折叠档位 = 单压缩，2026-11。
+
+| 会话 | 步数 | 累计工具输出+回复 | 折叠后驻留 | 压缩比 | 上下文占用 中位 / P90 | 峰值 | 原生压缩 |
+|---|---|---|---|---|---|---|---|
+| `c76c469f` | 1,482 | 24.54 MB | 0.68 MB | **36×** | 15.0% / 18.5% | 59.6% | 22 次 |
+| `6ff460cb` | 416 | 8.71 MB | 0.14 MB | **61×** | 15.1% / 18.2% | 39.8% | 9 次 |
+| `fde06aba` | 333 | 8.36 MB | 0.03 MB | **263×** | 12.3% / 17.9% | 42.0% | 3 次 |
+| `8f473b7d` | 346 | 4.86 MB | 0.08 MB | **63×** | 10.2% / 15.6% | 24.0% | 6 次 |
+
+**合计 12 个有折叠记录的单压缩档会话、2,869 步**：累计 50.18 MB 的工具输出与模型回复，折叠后实际驻留 0.96 MB（**52×**）。按中英混排约 3.5 字节/token 折算，50 MB ≈ 1,500 万 token，是 1M 窗口的 **14.3 倍**——不折叠的话这段内容要反复触发原生压缩；折叠后只占 **0.28 个窗口**。
+
+口径说明：
+- **累计工具输出+回复** = 该会话全部 `tool/result` + `assistant/message` + `user/message` 的原始字节，取自已归档的 session 事件流；
+- **折叠后驻留** = 插件最后一份 `last-fold` 记录的 `transcriptBytes`，即模型真正携带的折叠版 transcript；
+- **上下文占用** = 每个模型步的 `inputTokens + cacheReadTokens` ÷ 1,048,576，取全部步的中位 / P90；**峰值**含原生压缩那次请求（它要读整段对话，所以偏高）。
+
+可自行复算：`node tools/session-econ.mjs --dsh-home "$DSH_HOME" --mode single`（读本机会话档案，不上传任何数据）。
+
+## 四个插件
+
+| 插件 | 作用 | 默认 | 解决的问题 |
+|---|---|---|---|
+| **CONTEXTinjector** | 工具结果折叠、语义压缩、值保真提取 | 关（按会话启用） | 窗口被工具日志吃满 |
+| **EXTREASON** | 只读子代理先核实（记忆/转录/文件/网页），主模型再动手 | 开 | 主模型空转、返工 |
+| **LOGcompiler** | 转录日志，完整记录会话事件流 | 开 | 事后复盘与证据回溯 |
+| **memory.mjs** | 外部记忆：SQLite + 中文检索 + 分层加载 + 生命周期 + 受控写入 | 关 | 跨会话失忆、重复交代 |
+
+## 适用 / 不适用
+
+**适合**
+- 单会话几百步以上的长任务（重构、调研、排障、论文/工程迭代）；
+- 工具输出重、日志多的场景（`pwsh`、编译、测试、爬取结果）；
+- 需要跨会话延续的项目（约定、约束、文件位置、决策）。
+
+**不太需要**
+- 一问一答的短会话（折叠与记忆都有固定开销，收益抵不过）；
+- 完全不让模型跑工具的纯对话；
+- 对“每一字节原文都必须留在上下文里”的合规场景——折叠虽可展开，但驻留的是摘要。
+
+**安全边界**：记忆写入受控（用户明说或事实有原话支撑才收）；注入内容一律标记为**不可信背景**，模型不得执行其中的指令；记忆文件只在本机 `$DSH_HOME` 下，不联网。
+
+## 快速开始
+
+**方式一：插件包（推荐）**
+
+```bash
+dsh plugin --profile web add github:ScreamingMaggot/rcs-context
+```
+
+然后在 `<DSH_HOME>/profiles/web/package.json` 的 `dsh.profile.bundles` 里加入 `"rcs-context"`，重启 `dsh web`。
+
+**方式二：脚本直装**（离线 / 无 pnpm 时）
+
+```bash
+git clone https://github.com/ScreamingMaggot/rcs-context.git
+cd rcs-context
+powershell -ExecutionPolicy Bypass -File ./install.ps1
+```
+
+脚本会备份现网、落位插件、追加补丁层并自校验；重复运行安全。
+
+装完 **重启 `dsh web`**（客户端插件按名缓存，刷新页面不够），会话侧边栏会出现「注入」和「记忆」两个 tab。
+
+## 折叠档位与成本
+
+在会话输入框上方的 dock 或「注入」tab 里按会话选档：
+
+| 档位 | 做什么 | 模型调用 | 适用 |
+|---|---|---|---|
+| **工具折叠**（无损） | 纯规则：`[T]` 工具结果压成一行，`[V]` 抽取值 | 0 次 | 默认，零成本零风险 |
+| **单压缩** | 每轮把本轮的回复与工具输出交给轻模型压一遍 | 1 次/轮 | 绝大多数长会话（**推荐**） |
+| **双压缩** | 两遍压缩，更短、更慢、更贵 | 2 次/轮 | 极长会话、窗口特别紧 |
+
+压缩模型建议指向**廉价或本地**模型，别用主模型：
+
+```json
+// $DSH_HOME/state-compiler/control.json
+{ "condenseProvider": "ollama", "condenseModel": "qwen3:4b-instruct-2507-q4_K_M" }
+```
+
+本机实测用的就是 `opencode-go / deepseek-v4.1-flash`（快而便宜）。弱模型压缩率略低、单次 7–15 s，**失败一律无损回退**，不影响档案完整性。
+
+> 折叠在 `agent/pre-step` 阻塞 join（3 s 超时闸），保证每轮都吃到压缩收益；超时则放行、后台继续。
+
+## 转录行与回取（`[T]` / `transcript_expand`）
+
+折叠之后，模型看到的工具痕迹是**一行**一条：
+
+```
+[T] read | D:/proj/a.mjs | OK | raw=167
+[T] memory_correct | - | FAIL(need-explicit-user-intent) | {"ok":false,"error":"need-explicit-user-intent"}
+[T] transcript_expand | - | PENDING
+```
+
+- **判定列是业务语义，不是传输语义**：回执 `{"ok":false,"error":"x"}` 记 `FAIL(x)`（工具跑通了、业务拒绝了），传输层报错记 `ERR`，其余 `OK`。只看传输层会让"同一件事连错三次"在转录里全印成 OK——真机上就是这样连错三回合的。
+- **指针有体积门槛（缺省 1024 B）**：正文够大才挂 `raw=<seq>`；小结果把有界预览（≤160 字）内联在同一行。回取是一次工具往返，为几百字节换一次调用不划算。`control.rawPtrMinBytes` 可热调，`0` 退回"永远挂指针"的旧行为。
+- **未落盘 ≠ 失败**：raw 落盘是异步的，行渲染时该 seq 可能还没 flush，回执为 `seq-not-in-raw` 且带 `pending:true`；这类行记中性状态 `PENDING`，稍后重取即可，不该与业务失败同权重。
+- **回取**：`transcript_expand(seq)` 从 `raw/<sid>.jsonl` 取回该 seq 的原文（只读、按 session 隔离）。工具注册走 generator 持有器——`ctx.effect(() => dispose())` 会**立即执行**并当成 disposer，等于"注册完立刻注销"，这是"register 不抛错、工具却始终不在模型可见表里"的真正原因。
+
+`[T]` 行契约由 `tests/transcript-row-contract.test.mjs`、`tests/transcript-row-replay.test.mjs`（含"旧版 vs 新版"的同一份存证回放）、`tests/transcript-pending-row.test.mjs`、`tests/tool-registration-visible.test.mjs` 钉住。
+
+## 外部记忆
+
+开启：`control.json` 写 `"memoryEnabled": true`（可再开 `"memoryLlmEnabled": true` 让轻模型把事件编译成事实），重启后看「记忆」tab。
+
+给模型的工具：`memory_catalog` / `memory_search` / `memory_get` / `memory_ls`（只读）、`memory_remember` / `memory_forget` / `memory_correct`（受控写入）。
+
+亮点一句话版：
+
+- **`rcs://` 寻址**：记忆像文件系统一样浏览，先看目录再取正文；
+- **L0/L1/L2 分层**：目录只带 ≤50 字摘要，需要细节才升级读取，700 字预算能塞 8 条事实；
+- **中文检索**：trigram 精确子串 + 2-gram bm25，自然问句也能命中（真实语料 recall@5 17/24 → 23/24）；
+- **事实有生命周期**：`state / constraint / task / history`，冲突不露面，删除后不再复述被删内容；
+- **证据链**：每条事实可回查来源会话、seq、原文。
+
+完整机制（检索、分层、生命周期、整理、巡检、向量、轨迹、面板）见 [docs/MEMORY.md](docs/MEMORY.md)。
+
+## 兼容性
+
+| DSH 版本 | 状态 |
+|---|---|
+| 0.2.2-rc.2 | 🟡 静态差异比对通过（runtime 待验） |
+| 0.2.2-rc.1 | ✅ 已验证（live 实例四插件装载、`turn/end` 折叠提交、转录写入、状态接口 200；`install.ps1` 已适配 npm 扁平布局） |
+| 0.2.1-rc.5 | 🟡 静态差异比对通过（市场索引构建的钉定版本） |
+| 0.2.1-rc.3 | ✅ 已验证（五插件 + ledger-online，隔离实例与 live 实测） |
+| 0.2.1-rc.2 | ✅ 已验证 |
+| 0.2.0-rc.2 | ✅ 已验证（14 个关键宿主包中 10 个逐字节相同，16 条接缝 0 消失 0 改名） |
+| 0.1.7-rc.2 | ✅ 已验证（session-format v4 全链路） |
+| 0.1.5-rc.2 | ✅ 兼容 |
+
+`package.json` 的 `engines.dsh` / `peerDependencies` 用显式预发布分支覆盖上述全部版本：
+
+```
+>=0.1.5-rc.2 <0.1.6-0 || >=0.1.7-rc.2 <0.2.0-0 || >=0.2.0-rc.2 <0.2.1-0 || >=0.2.1-rc.2 <0.2.2-0 || >=0.2.2-rc.1 <0.3.0-0
+```
+
+⚠️ node-semver 只在范围里**某个比较符与该版本 `major.minor.patch` 元组完全一致、且自身带预发布标签**时才放行预发布版本。因此早先的 `>=0.1.5-rc.2` 看似宽松，实际只匹配 `0.1.5-rc.2` 与 `0.2.0`——`0.2.1-rc.5`、`0.2.2-rc.1` 等预发布宿主全被静默排除（插件市场会据此直接丢弃整个条目）。上面这种逐元组列出的写法才是对的。
+
+同一份代码内含多代兼容层（0.2.2 / 0.2.1 / 0.2.0 / 0.1.7 / 0.1.5），无需按宿主版本换分支。
+
+## 目录结构
+
+```
+web/                      插件本体（折叠 / 转录 / 外置推理 / 记忆）
+condense/                 共享压缩器与分型
+toolfold/                 结构化工具折叠（A 档）
+contextinjector-webui/    WebUI 面板（注入 / 记忆两 tab）
+tests/                    回归测试（76 套 / 2257 断言）
+tools/                    辅助脚本（会话经济性复算 session-econ.mjs、成本标定、提示面测量）
+docs/                     机制说明、性能基线、面板差距
+install.ps1 uninstall.ps1 install.cmd   安装与卸载
+cordis.patch.yml          bundle 补丁层
+version.json              版本与构建信息
+```
+
+## 数据与卸载
+
+- 运行时：`$DSH_HOME/state-compiler/`（`control.json`、`transcripts/`、`.ctxinjector/`）
+- 记忆库：`$DSH_HOME/state-compiler/memory/memory.sqlite`（破坏性操作前自动备份，默认留 5 份）
+- 安装备份：`$DSH_HOME/.statecompiler-backup-<时间戳>/`
+
+卸载：`powershell -ExecutionPolicy Bypass -File ./uninstall.ps1`，回滚备份并移除补丁项，重启生效。
+
+## 深入
+
+| 文档 | 内容 |
+|---|---|
+| [docs/MEMORY.md](docs/MEMORY.md) | 记忆层全部机制：检索、URI、分层、生命周期、整理、巡检、向量、轨迹、面板 |
+| [docs/PERFORMANCE-BASELINE.md](docs/PERFORMANCE-BASELINE.md) | 内存/折叠/检索性能基线 |
+| [docs/MEMORY-UI-GAPS.md](docs/MEMORY-UI-GAPS.md) | 记忆面板与前沿产品的差距与验收口径 |
+| [contextinjector-webui/README.md](contextinjector-webui/README.md) | 面板与插件侧的档位/同步约定 |
+
+## 许可证
+
+MIT

package/condense/chunk.mjs

@@ -0,0 +1,258 @@
+// Copyright (c) 2026 ScreamingMaggot. This source code is licensed under the MIT License.
+// chunk.mjs — Phase A 纯函数模块（无 DSH 运行时依赖，可离线单测）
+//   1. chunkForCompressor  按语义断点切分超窗口文本（§5.2 / §5.3）
+//   2. detectMilestone     不依赖 LLM 的里程碑语块检测（§5.4，仅检测信号）
+//   3. classifyCondenseError 压缩失败分型（§6.1）
+//   4. CONDENSE_BUDGET     压缩预算表（§5.6，v1.1 已决）
+// 设计依据：docs/v2-优化设计.md
+
+// ============ 1. 分块压缩（§5.2 / §5.3） ============
+export const CHUNK_DEFAULT_WINDOW_LINES = 24 // 回找上限（行）
+// 切点优先级（§5.3）：段落空行 > 换行 > 句末标点（不含 '.'，避免劈开 obj.method()/URL/小数）
+const SENT_END_RE = /[。！？!?]/
+
+// 在 [start, hardEnd) 区间内，从截断处往回找最佳语义断点；找不到且 allowHardCut ⇒ 硬切
+function findCut(src, start, maxBytes, windowBytes, allowHardCut) {
+  const hardEnd = Math.min(start + maxBytes, src.length)
+  if (hardEnd >= src.length) return src.length // 末尾，整段为一块
+  const lookStart = Math.max(start, hardEnd - windowBytes)
+  const seg = src.slice(lookStart, hardEnd)
+  // 优先：段落空行（\n[ \t]*\n）
+  let idx = seg.lastIndexOf('\n\n')
+  if (idx < 0) idx = seg.lastIndexOf('\n \n')
+  if (idx >= 0) return lookStart + idx + 2 // 含空行，下块从空行后起
+  // 次：换行（按行切对代码类工具结果最安全）
+  const nl = seg.lastIndexOf('\n')
+  if (nl >= 0) return lookStart + nl + 1
+  // 再次：句末标点（中/英，不含孤立 '.'）
+  for (let i = seg.length - 1; i >= 0; i--) {
+    if (SENT_END_RE.test(seg[i])) return lookStart + i + 1
+  }
+  // 兜底：硬切（allowHardCut）或整段作单块（交由上层）
+  return allowHardCut ? hardEnd : src.length
+}
+
+export function chunkForCompressor(text, maxBytes, opts = {}) {
+  const windowLines = opts.windowLines ?? CHUNK_DEFAULT_WINDOW_LINES
+  const allowHardCut = opts.allowHardCut !== false
+  const windowBytes = windowLines * 120 // 行→字节量级近似
+  const src = String(text)
+  const out = []
+  let start = 0
+  while (start < src.length) {
+    const cut = findCut(src, start, maxBytes, windowBytes, allowHardCut)
+    if (cut <= start) { out.push(src.slice(start)); break } // 兜底防死循环
+    out.push(src.slice(start, cut))
+    start = cut
+  }
+  return out
+}
+
+// ============ 2. 里程碑检测（§5.4，仅检测信号） ============
+export const MILESTONE_THRESHOLD_K_DEFAULT = 3 // 默认 3× 起步（评审建议值 2026-09-08）
+export const MILESTONE_MIN_BYTES = 512 // 绝对下限 512B（评审建议值）
+// 描述性/总结性启发式词（命中才视作"阶段总结"而非普通工具输出）
+const MILESTONE_DESCRIPTIVE_RE = /(已完成|总结|发现|关键|阶段性|本轮|结论|成果|重大|进展|已解决|已确认|成功|失败|注意)/
+
+export function detectMilestone(text, stat = {}) {
+  const minBytes = stat.minBytes ?? MILESTONE_MIN_BYTES
+  const k = stat.thresholdK ?? MILESTONE_THRESHOLD_K_DEFAULT
+  const mean = stat.meanBlockBytes && stat.meanBlockBytes > 0 ? stat.meanBlockBytes : minBytes
+  const len = String(text).length
+  if (len < minBytes) return false
+  if (!MILESTONE_DESCRIPTIVE_RE.test(text)) return false // 非描述性/总结性 ⇒ 不算里程碑
+  return len > k * mean
+}
+
+// ============ 3. 压缩失败分型（§6.1） ============
+// 把自由文本失败原因归一到 enum 值；disposal 由调用方按处置路径填（见 §6.3）
+export function classifyCondenseError(reason) {
+  const r = String(reason ?? '')
+  if (/llm service unavailable|llm 服务缺失|未提供 llm/.test(r)) return 'llm-unavailable'
+  if (/condense route missing|no condense route|无浓缩路由/.test(r)) return 'route-missing'
+  if (/stream error|流错误|流式异常/i.test(r)) return 'stream-error'
+  if (/no finish chunk|无 finish/.test(r)) return 'no-finish'
+  if (/finish=/.test(r)) {
+    const m = r.match(/finish=(\w+)/)
+    return m ? 'finish-' + m[1] : 'finish-other'
+  }
+  if (/parse|解析失败|行协议|不合规/.test(r)) return 'parse-error'
+  if (/payload|值校验|保真|载荷未过/.test(r)) return 'fidelity-blocked'
+  if (/timeout|超时|abort/i.test(r)) return 'timeout'
+  if (/ollama/i.test(r)) return 'ollama-error'
+  if (/empty|空输出|返回空/.test(r)) return 'empty-output'
+  if (/未短|not shortened|复读|未缩短/.test(r)) return 'not-shortened'
+  return 'other'
+}
+
+// ============ 4. 压缩预算表（§5.6，v1.1 已决） ============
+// 预算 = 该信息类型的保真权重（浓缩强度上限，1=全保真、0=可全丢）；与档位(single/double)正交
+export const CONDENSE_BUDGET = {
+  user_instruction: 0.9, // 用户指令：高保真
+  tool_error: 0.6, // 工具错误：保留诊断
+  ai_summary: 0.15, // AI 阶段性总结：最可压缩
+  exploration: 0.05, // 探索/试错往返：最低保真
+}
+// 按 [A] 块上下文推断信息类型（启发式；与相邻 [T] ERR / 里程碑 / 普通轮流）：
+//   - 附近 [T] 带 ERR ⇒ tool_error
+//   - 命中里程碑（detectMilestone） ⇒ ai_summary
+//   - 否则普通 AI 轮 ⇒ exploration
+export function inferBlockType(text, opts = {}) {
+  if (opts.nearToolError) return 'tool_error'
+  if (opts.milestone) return 'ai_summary'
+  return 'exploration'
+}
+
+// ============ 5. 消息来源分型（§13，2026-09-08 实测） ============
+// 背景：DSH 把系统注入（system-reminder / background job 通知 / 审批策略变更 / subagent
+//   回传）以 role:'user' 写进会话历史，旧判定只看 role ⇒ ROUND 被灌水 4.8×（实测 29 轮仅 6 轮真实）。
+//
+// 事件/消息结构（关键）：
+//   user/message 事件：data = { content, source, role, id }
+//     —— source 在 **data.source**；不存在 data.message 这一层。
+//        （旧 logcompiler 误取 data.message?.source，导致 source 检查恒为 undefined、从未生效）
+//   deriveMessages() 的消息：m.source（同一 MessageSource 形状）
+//
+// source.kind 是 merge-extensible 联合类型，除文档四选一 user/plugin/model/tool 外，
+//   实测另有 skill-catalog / subagent-settled / subagent-report ⇒
+//   **只能用 kind === 'user' 判真实用户轮**，不可做"非 user 即插件"的二分假设。
+export const SELF_PLUGIN_NAME = 'CONTEXTinjector'
+// 已知 notice 类插件名 → 子类（用于 [N] 行细分）
+const NOTICE_SUB_BY_PLUGIN = { 'tool-jobs': 'job', 'user-approval': 'approval' }
+
+// 【#2 修复（取自 RCS-0.1.0 返回包）】注入类 user 消息的文本前缀集 —— **单一来源**。
+// 背景：注入器与 logcompiler 在 source 缺失（DSH 规定必填，缺失属异常）时的回退分支
+//   此前各写一套前缀，同一事件可能一侧跳过、一侧计入 ROUND → 审计轮号与注入侧分叉。
+//   此处提为唯一来源，两处均从此导入，杜绝再次漂移。
+export const INJECTED_USER_PREFIXES = [
+  'Current runtime context',
+  // DSH 0.2.2-rc.2 wraps runtime-context in <system-reminder> and opens with this
+  // sentence instead of "Current runtime context:"; callers strip the wrapper first.
+  'The following information describes your current session',
+  'Current DSH file policy',
+  'Current DSH permission mode',
+  'sandbox:',
+  '[ROUND]',
+]
+
+// 【v1.10.27 · DSH 0.1.6+ session-format v4 兼容】
+//   v4 退役了 {kind:'plugin', plugin:'X'} 包装（持久化层对 kind==='plugin' 直接抛
+//   "format v4 message requires a producer-owned source kind"，且在编码路径上**打死宿主进程**），
+//   官方 v3→v4 迁移器把老数据重写为 {kind:'plugin:X'}。故写侧一律发新形态（v3 持久化对 kind
+//   无枚举校验，同一形态两类宿主通吃）；读侧必须同时认两种形态——老宿主给旧形态，
+//   迁移后的会话数据给新形态。
+export function pluginIdOf(source) {
+  const k = source?.kind
+  if (typeof k !== 'string') return null
+  if (k === 'plugin') return typeof source.plugin === 'string' && source.plugin.length > 0 ? source.plugin : null
+  if (k.startsWith('plugin:')) return k.slice(7)
+  // 压缩检查点：宿主只认 kind='compact-checkpoint'。插件自己的检查点额外带 plugin 字段，
+  // 读侧据此仍能识别为自身转录（宿主原生 compaction 不带该字段）。
+  if (k === 'compact-checkpoint') return typeof source.plugin === 'string' && source.plugin.length > 0 ? source.plugin : null
+  return null
+}
+
+export function classifyMessageSource(source, opts = {}) {
+  const self = opts.selfPlugin ?? SELF_PLUGIN_NAME
+  const src = source ?? null
+  if (!src || typeof src !== 'object') return { cls: 'opaque', kind: undefined }
+  const kind = src.kind
+  const form = src.form
+  const plugin = pluginIdOf(src) ?? (typeof src.plugin === 'string' ? src.plugin : undefined)
+  if (kind === 'user') return { cls: 'user' }
+  if (plugin === self) return { cls: 'self' }
+  // 【extreason 接入（取自 RCS-0.1.0）】外置推理简报：文本本身已是 `[R] …` 行 ⇒ 单独一类，
+  //   两个转录器都按行保留、不计 ROUND。它是 append-only 日志的一部分（会被折进转录并永久保留），
+  //   不是易失注入。位置必须在 opaque 兜底之前，否则会落 opaque ⇒ 两转录器都不转录（静默丢内容）。
+  if (plugin === 'EXTREASON') return { cls: 'extreason' }
+  // subagent 报告：内容需主模型看到，但语义接近工具结果 ⇒ 走 [T]/[V]，不计 ROUND
+  if (kind === 'subagent-report' || form === 'relay') return { cls: 'relay', agentId: opts.agentId ?? null }
+  if (kind === 'subagent-settled') return { cls: 'notice', sub: 'subagent' }
+  // 无 form 的 notice 类插件（实测 user-approval 不带 form）
+  if (plugin !== null && plugin !== undefined && NOTICE_SUB_BY_PLUGIN[plugin]) return { cls: 'notice', sub: NOTICE_SUB_BY_PLUGIN[plugin] }
+  if (form === 'snapshot') return { cls: 'snapshot', sections: Array.isArray(src.sections) ? src.sections : [] }
+  if (form === 'catalog' || kind === 'skill-catalog') return { cls: 'catalog' }
+  if (form === 'notice') return { cls: 'notice', sub: NOTICE_SUB_BY_PLUGIN[plugin] ?? 'notice' }
+  // 未知 kind（含未来新增）⇒ 保守跳过并回传 kind，便于调用方计数/上报
+  return { cls: 'opaque', kind }
+}
+
+// 事件适配器：读 data.source（**不是** data.message.source）
+export function classifyUserMessage(ev, opts = {}) {
+  return classifyMessageSource(ev?.data?.source, opts)
+}
+
+const SUBAGENT_ID_RE = /subagent\s+([0-9a-fA-F][0-9a-fA-F-]{7,})/
+export function subagentIdOf(text) {
+  const m = SUBAGENT_ID_RE.exec(String(text ?? ''))
+  return m ? m[1] : null
+}
+
+// 快照摘要：只留 sections 名。runtime 快照每 step 重注入（实测 14 次），
+// 全量转录会显著膨胀，故 [S] 行只存摘要。
+export function snapshotSummary(sections) {
+  if (!Array.isArray(sections) || !sections.length) return 'runtime snapshot'
+  const names = sections.map((s) => s && s.name).filter(Boolean)
+  return names.length ? 'runtime snapshot: ' + names.join(', ') : 'runtime snapshot'
+}
+
+// ============ 6. 单块压缩 token 预算（§4.2 纯算术部分） ============
+// 说明：§4 的完整 resolveCondenseMaxTokens 需异步取 ctx.llm.resolveModelInfo（真机侧），
+//   此处仅落**纯算术**分支（§4.2）：给定已解析的 ctxWindow / defaultMaxTokens / 硬覆盖，
+//   折算单块压缩 token 预算。真机接线在拿到窗口值后调用本函数即可，默认回退内置 700，
+//   无回退风险、不触碰折叠主链路。建议值（评审 2026-09-08）：min(defaultMaxTokens,
+//   ctxWindow − inputBudget − 20%余量)，不必 ×0.5；预算下限 256。
+//   MAX_TOKEN_FLOOR = 256（语义：预算过小会退回无损，故设下限防无意义压缩）
+export const MAX_TOKEN_FLOOR = 256
+export function resolveMaxTokenBudget({ hardOverride, ctxWindow, defaultMaxTokens, inputBudget = 0, fallback = 700, floor = MAX_TOKEN_FLOOR } = {}) {
+  const b = Math.max(0, Number(inputBudget) || 0)
+  if (hardOverride != null && Number.isFinite(hardOverride)) return Math.max(floor, Math.floor(hardOverride))
+  if (ctxWindow != null && defaultMaxTokens != null && ctxWindow > 0 && defaultMaxTokens > 0) {
+    const ctxW = Math.floor(ctxWindow)
+    const headroom = Math.max(0, ctxW - b - Math.floor(ctxW * 0.2))
+    return Math.max(floor, Math.min(defaultMaxTokens, headroom))
+  }
+  if (defaultMaxTokens != null && defaultMaxTokens > 0) return Math.max(floor, Math.floor(defaultMaxTokens))
+  if (ctxWindow != null && ctxWindow > 0) {
+    const ctxW = Math.floor(ctxWindow)
+    return Math.max(floor, Math.floor(ctxW * 0.8 - b))
+  }
+  return Math.max(floor, Math.floor(fallback))
+}
+
+// ============ 路由可用性（折叠与记忆共用） ============
+// 上游会整条下线模型（真机：minimax-m3.1-flash-free 从免费名单消失），宿主也可能根本没配
+// 某个 id（UNKNOWN_MODEL）。这两种都不是"重试能好"的错，只有换路由才有产出。
+const AUX_ROUTE_DEAD_RE = /Model is unavailable|no configured model|UNKNOWN_MODEL|model.{0,16}(not found|unavailable|does not exist)|unsupported model|no condense route|route missing/i
+
+export function parseRouteSpec(spec) {
+  const t = String(spec ?? '').trim()
+  const i = t.indexOf('/')
+  if (i <= 0 || i === t.length - 1) return null
+  return { provider: t.slice(0, i), model: t.slice(i + 1) }
+}
+
+export function auxFallbackRoutes(control = {}, env = process.env) {
+  const raw = []
+  // 首选回退：压缩路由（同一 provider 的另一个模型通常最先可用，也无需额外配置）
+  if (control?.condenseProvider && control?.condenseModel) raw.push(control.condenseProvider + '/' + control.condenseModel)
+  if (Array.isArray(control?.auxFallbackRoutes)) raw.push(...control.auxFallbackRoutes)
+  if (env.DSH_AUX_FALLBACK_MODELS) raw.push(...String(env.DSH_AUX_FALLBACK_MODELS).split(','))
+  // 本机模型恒列最后兜底：它由宿主配置直接可用，且不花外部额度。
+  raw.push('ollama-local/qwen3.5:4b', 'ollama-local/qwen3-8b-q4:latest')
+  const out = []
+  const seen = new Set()
+  for (const s of raw) {
+    const r = parseRouteSpec(s)
+    if (!r) continue
+    const k = r.provider + '/' + r.model
+    if (seen.has(k)) continue
+    seen.add(k)
+    out.push(r)
+  }
+  return out
+}
+
+export function isRouteDead(error) {
+  return AUX_ROUTE_DEAD_RE.test(String(error ?? ''))
+}

package/condense/ivr.mjs

@@ -0,0 +1,104 @@
+// Copyright (c) 2026 ScreamingMaggot. This source code is licensed under the MIT License.
+// ivr.mjs — 「压缩器IO比」口径计量 + 错误时间线（§2 / §6.4）
+//   纯簿记模块，依赖 node:fs，不依赖 DSH 运行时；与 contextinjector.mjs 同目录。
+//   读法：ratio = inBytes / outBytes（输入 ÷ 输出）
+//     ratio ≈ 1 属正常 = 主流程已无冗余可压；> 1 = 压掉的量更大；< 1 = 输出比输入还大。
+//   只作**回归哨兵**：比值明显变大=冗余回流，< 1=有内容被重复注入。
+// 设计依据：docs/v2-优化设计.md
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+// 文件名用"裸 sid"（去 session- 前缀），与 contextinjector per-sid 落盘 & host /status 读取一致
+const normSid = (s) => String(s ?? 'unknown').replace(/^session-?/i, '').replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 120)
+
+// ============ 压缩器IO比（§2） ============
+// 【2026-09-09（用户定名："压缩器IO比"）】
+//   每轮记两个数，再给一个比值，不掺 S（系统提示字节）、不叫折扣：
+//     inBytes  = 本轮喂进压缩器的原始内容 = shadowedBytes − 上一轮转录字节
+//     outBytes = 本轮压缩器产出的转录增量 = transcriptBytes − 上一轮转录字节
+//     ratio    = inBytes / outBytes   （输入/输出：值越大=压掉的量越大；≈1=没冗余可压；<1=输出比输入还大）
+//   累计：cumIn/cumOut/cumRatio = cumIn / cumOut
+//   读法：RCS 架构下主流程已无冗余可压（reasoning 外置、工具结果折成 [T] 行、DSH 管线噪音被清），
+//   ratio≈1 属正常，只作**回归哨兵**（比值明显变大=冗余回流；<1=有内容被重复注入）。
+
+export function ivrLoad(stateDir, sid) {
+  try {
+    const fp = join(stateDir, 'ivr', normSid(sid) + '.json')
+    if (!existsSync(fp)) return null
+    return JSON.parse(readFileSync(fp, 'utf8'))
+  } catch { return null }
+}
+
+export function ivrEnsure(stateDir, sid, S) {
+  mkdirSync(join(stateDir, 'ivr'), { recursive: true })
+  const fp = join(stateDir, 'ivr', normSid(sid) + '.json')
+  let st = null
+  try { st = existsSync(fp) ? JSON.parse(readFileSync(fp, 'utf8')) : null } catch { st = null }
+  // 口径标记：旧文件（v1-role / v2-source）不与新口径混算 —— 旧轮次数据**整体重建丢弃**。
+  //   ⚠ 破坏性行为（用户已知并接受）：旧 rounds 会被清空，老会话的历史 IO 数据不再保留、也不可比。
+  // 口径 v3（io2）：旧行把**单折** shadowedBytes 当累计量去减上一轮转录，单折量小于累计时被钳成 0，
+  //   面板于是出现大量「输入 0B、比值 0」，累计比值也被带偏。旧行不再混算：保留一份备份后重建。
+  if (!st || st.roundSemantics !== 'io2') {
+    if (st && Array.isArray(st.rounds) && st.rounds.length) {
+      try { writeFileSync(fp + '.bak-' + (st.roundSemantics || 'io') + '-' + Date.now(), JSON.stringify(st, null, 2)) } catch { /* ignore */ }
+    }
+    st = { sessionId: sid, lastTranscriptBytes: 0, rounds: [], roundSemantics: 'io2' }
+  }
+  if (!Array.isArray(st.rounds)) st.rounds = []
+  void S // S（系统提示字节）在新口径中不再参与计算，仅为兼容旧调用签名而保留
+  writeFileSync(fp, JSON.stringify(st, null, 2), 'utf8')
+  return st
+}
+
+export function ivrRecord(stateDir, sid, fold) {
+  const st = ivrEnsure(stateDir, sid)
+  const prev = st.lastTranscriptBytes || 0
+  // inBytes = 本折真正喂进压缩器的原始内容（单折量，不减去累计转录）。
+  //   fold.inBytes 由调用方给出（= incrementalRawBytes）；缺省回落到单折 shadowedBytes 以兼容旧调用。
+  const rawIn = Number.isFinite(fold.inBytes) ? fold.inBytes : (Number.isFinite(fold.incrementalRawBytes) ? fold.incrementalRawBytes : fold.shadowedBytes)
+  const inBytes = Math.max(0, Math.floor(Number(rawIn) || 0))
+  const outBytes = Math.max(0, fold.transcriptBytes - prev)
+  const last = st.rounds[st.rounds.length - 1] || { cumIn: 0, cumOut: 0 }
+  const cumIn = last.cumIn + inBytes
+  const cumOut = last.cumOut + outBytes
+  const ratio = outBytes > 0 ? inBytes / outBytes : 1
+  const cumRatio = cumOut > 0 ? cumIn / cumOut : 1
+  const round = {
+    n: fold.n, step: fold.step, ts: fold.ts ?? Date.now(),
+    inBytes, outBytes,
+    ratio: Number(ratio.toFixed(4)),
+    cumIn, cumOut,
+    cumRatio: Number(cumRatio.toFixed(4)),
+    shadowedBytes: fold.shadowedBytes, transcriptBytes: fold.transcriptBytes,
+    stageAnchor: fold.stageAnchor === true, // §8 里程碑锚点
+  }
+  st.rounds.push(round)
+  st.lastTranscriptBytes = fold.transcriptBytes
+  st.cumRatio = round.cumRatio
+  writeFileSync(join(stateDir, 'ivr', normSid(sid) + '.json'), JSON.stringify(st, null, 2), 'utf8')
+  return round
+}
+
+export function ivrSeries(stateDir, sid) {
+  const st = ivrLoad(stateDir, sid)
+  return st ? st.rounds : []
+}
+
+export function ivrExport(stateDir, sid, format = 'csv') {
+  const st = ivrLoad(stateDir, sid)
+  if (!st) return ''
+  if (format === 'json') return JSON.stringify(st, null, 2)
+  const head = 'n,step,inBytes,outBytes,ratio,cumIn,cumOut,cumRatio,ts'
+  const rows = st.rounds.map((r) => [r.n, r.step, r.inBytes, r.outBytes, r.ratio, r.cumIn, r.cumOut, r.cumRatio, r.ts].join(','))
+  return [head, ...rows].join('\n')
+}
+
+// ============ 错误时间线（§6.4，append-only，对称 IVR） ============
+// $STATE_DIR/errors/<sid>.jsonl —— 与 IVR 共用同一 session 时间线（同 sid、同轮号）
+export function errAppend(stateDir, sid, entry) {
+  try {
+    mkdirSync(join(stateDir, 'errors'), { recursive: true })
+    const fp = join(stateDir, 'errors', normSid(sid) + '.jsonl')
+    appendFileSync(fp, JSON.stringify({ ts: Date.now(), ...entry }) + '\n', 'utf8')
+  } catch { /* best-effort */ }
+}

package/contextinjector-webui/README.md

@@ -0,0 +1,43 @@
+# contextinjector-webui — 「注入」面板（仓库权威副本）
+
+> 与 `../contextinjector.mjs`（折叠插件，Host 单文件）配对。本目录是 **npm 包形态** 的 WebUI 面板
+> （conversation.view「注入」tab + 自注册 `/api/context-inject/{status,config}`）。
+
+## 结构
+```
+webui/
+├── package.json        # main=host(lib/index.mjs)；exports["./client"] + dsh.client{platform:'web'}
+├── lib/index.mjs       # Host 半：ctx.webServer.register exact /api/context-inject/{status,config,session}
+│                       #   读 state-compiler/{control,runtime,last-fold}.json；本机 origin 校验写
+└── lib/client.js       # Client 半：lazy-CJS（__ModuleLoader__），两处注入
+                        #   ① conversation.view「注入」tab：启用开关 + workspace 分组白名单(标题/归档过滤)
+                        #      + 全局默认压缩档 + 折叠时间线(ErrorBoundary)
+                        #   ② conversation.input.dock（v1.7）：composer 上方「本会话压缩模式」四态选择器
+                        #      —— 空白会话(hero)同样渲染，首轮发送前即可定档
+```
+
+## 装载（正式区）
+1. 把本目录内容同步到 `$DSH_HOME/profiles/node_modules/contextinjector-webui/`（目录须在 node_modules，
+   包名 include 才被 client 收集——路径型 insert 不收集 client half）；
+2. web profile 的 `cordis.patch.yml` insert：`name: 'contextinjector-webui'`（包名，非路径）。
+折叠插件本尊：`contextinjector.mjs`（路径型 insert，Host 单文件）。
+
+## 端点与数据
+- `GET  /api/context-inject/status` → control/runtime/lastFold/会话索引（title 来自 projcache，同左侧栏）
+- `POST /api/context-inject/config` → `{enabled, sessions[], condense}`（白名单=session id 数组；condense=**全局默认档**）
+- `POST /api/context-inject/session`（v1.7）→ `{sessionId, mode}`，mode=`off|single|double|none`
+  → 一次动作 = 启用 + 该会话入白名单 + 写 `sessionModes[<sid>]`（none=移出白名单）。
+  原子读改写（展开 cur 保留未知字段，防 keepInject 被剥）；会话 id 前缀归一，键形式沿用既有记录。
+- 状态目录：`$DSH_HOME/state-compiler/`（CONTEXTinjector 插件写入；webui 只读+改 control）
+- 档位优先级（插件侧，v1.9）：env `DSH_CONTEXTINJECTOR_LOSSY` > `sessionModes[本会话]`
+  > （test/env 直通: off 兜底 | control 门控无档: **不折叠**）。**全局默认档已移除**——
+  顶部「注入」tab 无「AI 输出压缩档」chips；composer dock 是唯一选档入口，tab 勾选会话即写无损 off（取消= none）。
+
+## 同步约定
+- **本目录 = 源**；`$DSH_HOME/profiles/web/` 下的是装载副本；
+- 改 host 端点（index.mjs）或面板（client.js）后：同步副本 + **重启 web**（client bundle sha1 rev 变化；
+  装载器元数据按名缓存，重启前不失效）；
+- 回滚：删 cordis.patch 中 insert 与 node_modules 包目录即可。
+
+## 历史残留说明
+早期误置的 `profiles/web/contextinjector-webui/`（harness 版实验目录）已不被引用，若在可手动删除。