@aiwayds/dsh-dcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fan56
+
+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

@@ -0,0 +1,181 @@
+# dsh-dcp
+
+[dsh](https://github.com/deepseek-ai/deepseek-harness)（DeepSeek Harness）的**确定性 context 压缩后端**：把 `compaction-basic` 的 LLM 摘要换成纯代码抽取，**每次压缩零 LLM 调用**。
+
+设计参考 [Opencode-DCP/opencode-dynamic-context-pruning](https://github.com/Opencode-DCP/opencode-dynamic-context-pruning)（opencode 社区的 context 剪枝插件，即 oh-my-openagent 所用的 opencode-dcp）：重复调用去重、陈旧报错清理、"技术性摘要代替散文"、`/dcp` 命令、默认配置开箱即用——按 dsh 的 compaction capability seam 重新实现。
+
+## 为什么
+
+dsh 自带三层压缩里，`compaction-basic` 每次压缩都要付一次 LLM 摘要调用，且摘要质量取决于模型心情。dsh-dcp 换成确定性模板抽取：
+
+- **零 LLM 调用**：压缩触发不再产生额外的 token 消耗
+- **输出稳定**：相同输入永远得到相同摘要（可 diff、可测试）
+- **保留硬信息**：文件路径、命令、报错串、待办、用户原话逐字保留，废话全丢
+- **中文友好**：内容原样保留（不做英文转写），`thresholdRatio` 可直接调低提前触发
+- **继承一切安全机制**：压力触发、保留尾巴、溢出恢复、事务锁、tool-pairing 边界全部复用官方实现（只 override 官方留的唯一钩子 `summarize()`）
+
+## 快速开始
+
+```bash
+# 1. 克隆并安装（依赖与 dsh 0.1.0-rc.6 对齐）
+git clone git@github.com:fan56/dsh-dcp.git ~/github/dsh-dcp
+cd ~/github/dsh-dcp && npm install
+
+# 2. 挂载：在 ~/.dsh/cordis.patch.yml 追加（name 必须是绝对路径）
+# - id: compaction-basic
+#   name: /Users/<you>/github/dsh-dcp/lib/index.js
+
+# 3. 重启 dsh，输入 /dcp 验证
+```
+
+`/compact` 命令、自动压力触发、overflow 恢复、UI 的 checkpoint 卡片照常工作——它们只依赖 `ctx.compaction` 接口，与本后端无关。
+
+## `/dcp` 命令
+
+| 命令 | 作用 |
+|---|---|
+| `/dcp` | 状态：当前配置、压缩次数、shadowed token 数、省掉的 LLM 调用数 |
+| `/dcp compact` | 立即压缩（确定性，无 LLM 调用；等价 `/compact`） |
+| `/dcp set <k> <v>` | 本会话内调整参数，并打印持久化到 `cordis.patch.yml` 的片段 |
+| `/dcp help` | 用法 |
+
+可调键：`dedup`、`purgeErrors`、`maxItems`、`maxItemChars`、`maxSummaryTokens`、`language`、`thresholdRatio`。
+
+## 配置
+
+全部可选，默认即用。写在 `~/.dsh/cordis.patch.yml` 的 `config:` 下：
+
+```yaml
+- id: compaction-basic
+  name: /Users/<you>/github/dsh-dcp/lib/index.js
+  config:
+    thresholdRatio: 0.7   # 中文场景建议 0.7（默认 0.8）
+    language: zh          # 输出语言 en|zh：zh 额外启用中文报错/待办规则
+    # tokenEstimate: cjk  # 默认即 cjk：CJK 字符按 ~2 字符/token 计价
+```
+
+### dsh-dcp 自己的键
+
+| 键 | 默认 | 说明 |
+|---|---|---|
+| `dedup` | `true` | 统计重复的工具调用（同名+同参），在 Critical Context 里标注"×N，保留最近结果" |
+| `protectedTools` | `['write', 'edit', 'apply_patch']` | 去重时跳过这些名字（子串匹配）的工具；设为 `[]` 可让所有工具参与去重 |
+| `purgeErrors` | `true` | 旧报错折叠为一条省略提示，只保留最近 `maxItems` 条 |
+| `maxItems` | `10` | 每个 section 最多条数 |
+| `maxItemChars` | `200` | 每条最长字符（超出截断加 `…`） |
+| `maxSummaryTokens` | `2048` | 摘要 token 预算（超出自动降级到更紧凑的格式） |
+| `language` | `en` | 输出语言 `en`/`zh`。除填充文案外，`zh` 还启用**中文规则集**：识别中文报错关键词（找不到/失败/无法/拒绝/超时/崩溃…）和 `待办：` 标记；`en` 只用英文规则。section 标题固定英文（对下游模型是结构锚点） |
+| `tokenEstimate` | `cjk` | 摘要预算的 token 计价方式：`cjk`（默认）把 **CJK 字符**（中文汉字、日文假名、韩文谚文、全角标点——CJK 不止中文）按 **~2 字符/token** 计价，ASCII 按 4 字符/token；`ascii` 则与宿主 meter 完全一致，所有字符一律 4 字符/token |
+
+### 继承自 compaction-basic 的键
+
+`thresholdRatio`（0.8）、`retainRatio`（0.16）、`retainTokens`、`compactionRetries`、`maxOverflowRetries`、`modelPolicies`、`auto` 等原样透传，语义见 [dsh-compaction-basic README](https://github.com/deepseek-ai/deepseek-harness/blob/master/packages/compaction/compaction-basic/README.md)。`summarizationProvider/Model/maxTokens` 只影响被替换掉的 LLM 摘要路径，保留只为配置兼容。
+
+## 中文场景
+
+dsh 的 host meter 对所有字符一律按 **4 字符/token** 计价，这对英文合理，对 CJK 却会低估约 2 倍（真实分词器对汉字/假名/谚文约 1~2 字符/token）。dsh-dcp 在**摘要预算**上不沿用这个启发式：
+
+- **预算计价（`tokenEstimate: cjk`，默认）**：CJK 字符按 ~2 字符/token、ASCII 按 4 字符/token。纯英文文本与宿主 meter 完全一致；CJK 会话里预算反映真实成本，摘要不会因"中文被按 4 字符/token 贱卖"而膨胀到超出真实预算，也不会被 45% 预算规则饿死
+- **中文规则集（`language: zh`）**：报错识别补充中文关键词（找不到/未找到/不存在/失败/错误/报错/异常/无法/拒绝/超时/崩溃/致命），待办识别补充 `待办：` 标记；`en` 模式只认英文规则
+- **内容逐字保留**：用户原话、文件路径、命令、报错串原样进入摘要，不做英文转写，中文信息零损耗
+
+一个**已知边界**：压缩**触发阈值**仍由宿主 meter 决定（在父类 `compactIfNeeded` 里，不在我们的 seam 内）。中文会话里宿主低估实际占用，阈值可能触发偏晚。补偿办法：把 `thresholdRatio` 调低到 `0.6~0.7`（或用 `modelPolicies` 按模型单独设），让压力检查提前；若仍频繁触发 context-overflow 恢复，再继续下调。
+
+## 摘要长什么样
+
+```
+## Primary Request and Intent
+- Fix the login redirect bug and update README.
+
+## Files and Code
+- /app/src/auth/login.ts — W×1 R×1
+
+## Errors and Fixes
+- bash: FAIL src/auth.test.ts
+
+## Pending Jobs
+- add regression test
+
+## Current Work
+- Fix the login redirect bug and update README.
+
+## Next Step
+- add regression test
+
+## Critical Context
+- dsh-dcp 确定性压缩了 12 条消息 / 8 次工具调用（未调用 LLM 摘要）
+```
+
+Section 结构与 `compaction-basic` 的 checkpoint 指令一致，因此：已有的 `<compacted-summary>` 检查点会被解析、去重后合并进新摘要（陈旧的 Current Work / Next Step 丢弃重生成）；将来换回 basic 后端，它也能按官方规则合并 dsh-dcp 产生的检查点。
+
+## 工作原理
+
+```
+BasicCompactionEngine            dsh 官方：阈值/保留/事务/事件锁/tool-pairing
+        ▲
+        │ 仅 override summarize()
+DcpEngine ── register /dcp
+        │
+summarizeDeterministically()     纯代码：抽取 → 合并 prior checkpoint → 预算压缩
+```
+
+- 压缩区间选择、`compaction/start → summary → end` 事件序、`surfaceOp: replace`、收敛校验（摘要必须小于被压区间）、`ManualCompactionError` 错误分类，全部由父类承担
+- 摘要预算 = `min(maxSummaryTokens, 45% × 被压区间)`，按 `tokenEstimate` 计价（默认 cjk，对中文准确；对纯英文与宿主一致）；超出时逐级降级（砍条数 → 丢空 section → terse 固定格式 → 硬截断）。45% 的余量保证收敛校验（宿主按 4 字符/token 计价）总能通过
+- 挂载方式是 `cordis.patch.yml` 按 `id: compaction-basic` 覆盖 `name`，行 id 不变、仍留在原 isolate 组内，隔离语义不破坏
+
+## 与参考对象的差异
+
+| | opencode-dcp | dsh-dcp |
+|---|---|---|
+| 宿主 | opencode | dsh（DeepSeek Harness） |
+| 接入点 | 插件 + 模型可调的 compress 工具 | 官方 compaction seam 的 `summarize()` 钩子 |
+| 历史 | 不改 session，请求前换占位符 | 走官方 durable 替换事务（`surfaceOp: replace`） |
+| 摘要 | 模型生成技术摘要 | 确定性模板抽取，零 LLM 调用 |
+| 命令 | `/dcp` TUI 面板 + `/dcp-compress` | `/dcp`（status/compact/set） |
+| 配置 | `dcp.jsonc`（~30 键） | `cordis.patch.yml` config（8 个自有键） |
+
+## 局限
+
+- 确定性抽取不"理解"代码：它保路径/命令/报错/待办/用户原话，但不做语义归纳。需要语义摘要的场景请继续用默认 `compaction-basic`
+- 摘要预算对中文已按真实密度计价（`tokenEstimate: cjk`）；但**压缩触发阈值**仍在宿主侧按 4 字符/token 计价，中文会话触发偏晚，需手动调低 `thresholdRatio`（见"中文场景"）
+- 依赖绝对路径挂载 + 本目录 `npm install`（私仓未发 npm）；`@deepseek-ai/*` 版本需与本机 dsh 一致（当前 `0.1.0-rc.6`，见 `package.json` 的 `overrides`）
+
+## 开发
+
+```bash
+npm install
+npm test        # node:test，35 个用例：config / summarizer / command / engine
+```
+
+### 缓存对比脚本
+
+`scripts/compare.mjs` 用真实 dsh 会话日志（`~/.dsh/sessions/**/session.jsonl.zstd`）静态模拟 provider 前缀缓存，对比"不压缩"基线与 dcp 后端：
+
+```bash
+node scripts/compare.mjs <session.jsonl.zstd> [contextWindow] [thresholdRatio] [retainRatio] [language]
+```
+
+模拟的缓存模型与真实服务商一致：请求 N 的缓存命中 = 与请求 N-1 的最长公共 token 前缀；纯追加时上一请求是完整前缀（≈全命中），压缩把头部替换成新 checkpoint 后下一请求从冷开始。
+
+**3 条真实会话验证**（128k 窗口、0.8 阈值、0.16 保留；session3 为 64k 窗口）：
+
+| 会话 | 体量 | 基线 hit / 输入 | dcp hit / 输入 | 压缩次数 | 压缩率 |
+|---|---|---|---|---|---|
+| S1（759 节点，中文主题调试） | 18.2 万 tok | 99.6% / 4152 万 | 99.1% / 2206 万（-47%） | 1 | 81,632→514（**158.8x**） |
+| S2（765 节点） | 18.7 万 tok | 99.1% / 4187 万 | 98.8% / 2102 万（-50%） | 2 | 82,525→577、82,163→821（143x/100x） |
+| S3（128k 未触发） | 12.3 万 tok | 98.6% / 1234 万 | 98.6% / 1234 万（不变） | 0 | — |
+| S3（64k 窗口） | 12.3 万 tok | 98.6% / 1234 万 | 97.2% / 715 万（-42%） | 3 | 42,085→325 等（80~130x） |
+
+结论：压缩让命中率下降不到 1 个百分点，绝对 miss 增加约等于每次压缩后那一个冷请求（1~2 万 token），而这个代价是**所有压缩后端共有的**（头部替换导致新 checkpoint 无前缀可蹭）；同时总输入 token 减半。dcp 与官方 basic 的唯一差异在摘要大小与零 LLM 调用，不在缓存机制。
+
+**摘要瘦身优化**（对注入上下文做了过滤，见 `extractFacts` 的 `isInjectedContext`）：system-prompt 快照、skills 目录、AGENTS.md 指令这些每轮重新注入的消息不再进入摘要——S1 摘要 717→514 token（-28%），S2 摘要 693→577、883→821。纯英文与中英混合会话均无回归。
+
+- `lib/index.js` — `DcpEngine`（挂载入口，default export）
+- `lib/summarizer.js` — 确定性抽取与预算压缩（纯函数，可独立复用）
+- `lib/command.js` — `/dcp` 命令
+- `lib/config.js` — 配置切分与校验
+- 升级 dsh 后：同步 `package.json` 里 `@deepseek-ai/*` 的版本与 `overrides`，`npm install && npm test`
+
+## License
+
+MIT

package/cordis.patch.example.yml

@@ -0,0 +1,19 @@
+# Example: mount dsh-dcp as the compaction backend.
+#
+# Append to ~/.dsh/cordis.patch.yml (home level, applies to every profile).
+# The row id stays `compaction-basic` (patch overrides by id), so the line
+# remains inside the standard preset's compaction isolate group and every
+# consumer (/compact, UI checkpoint card, pressure triggers) keeps working.
+#
+# `name` MUST be an absolute path to this checkout's entry file; relative
+# paths resolve against the loader's baseUrl and are easy to get wrong.
+- id: compaction-basic
+  name: /Users/CHANGE/ME/dsh-dcp/lib/index.js
+  config:
+    thresholdRatio: 0.7   # optional: trigger earlier for CJK-heavy sessions
+    language: zh          # optional: filler text language (content is verbatim)
+    # dedup: true         # optional: every dsh-dcp key may be omitted
+    # purgeErrors: true
+    # maxItems: 10
+    # maxItemChars: 200
+    # maxSummaryTokens: 2048

package/lib/command.js

@@ -0,0 +1,128 @@
+/**
+ * The `/dcp` slash command: status, manual compaction, and runtime knobs —
+ * one entry point, no required arguments (design references opencode-dcp's
+ * `/dcp` panel in a dsh-idiomatic, text-only form).
+ *
+ * @module dsh-dcp/command
+ */
+
+import { ManualCompactionError } from '@deepseek-ai/dsh-compaction'
+import { RUNTIME_SETTABLE } from './config.js'
+
+const USAGE = `Usage:
+  /dcp                show status (mode, config, compaction stats)
+  /dcp compact        compact now (deterministic, no LLM call)
+  /dcp set <k> <v>    adjust a knob for this session (dedup, purgeErrors,
+                      maxItems, maxItemChars, maxSummaryTokens, language,
+                      tokenEstimate, thresholdRatio)`
+
+const FAILURE_TEXT = Object.freeze({
+  busy: 'Compaction is unavailable because this process has an active compaction, or the agent is not idle.',
+  cancelled: 'Compaction cancelled.',
+  changed: 'The history selected for compaction changed before it could be replaced. The conversation is unchanged.',
+  summary: 'Compaction could not produce a useful summary. The conversation is unchanged.',
+  commit: 'Compaction did not finish cleanly; inspect the current session state before retrying.',
+  persistence: 'Compaction finished, but the session could not be saved.',
+})
+
+function success(text, sourceEventSeq) {
+  return sourceEventSeq === undefined ? { kind: 'success', text } : { kind: 'success', text, sourceEventSeq }
+}
+
+function failure(text) {
+  return { kind: 'error', text }
+}
+
+/** One `key=value` runtime assignment, or a diagnostic string. */
+function applySet(engine, key, rawValue) {
+  const kind = RUNTIME_SETTABLE[key]
+  if (kind === undefined) return `unknown key "${key}" — settable: ${Object.keys(RUNTIME_SETTABLE).join(', ')}`
+  const value = rawValue.toLowerCase()
+  if (kind === 'boolean') {
+    if (!['on', 'off', 'true', 'false'].includes(value)) return `${key} expects on/off/true/false`
+    engine.dcp[key] = value === 'on' || value === 'true'
+    return `${key} = ${engine.dcp[key]} (this session)`
+  }
+  if (kind === 'language') {
+    if (value !== 'en' && value !== 'zh') return 'language expects en or zh'
+    engine.dcp.language = value
+    return `language = ${value} (this session)`
+  }
+  if (kind === 'token-estimate') {
+    if (value !== 'cjk' && value !== 'ascii') return 'tokenEstimate expects cjk or ascii'
+    engine.dcp.tokenEstimate = value
+    return `tokenEstimate = ${value} (this session)`
+  }
+  const numeric = Number(rawValue)
+  if (!Number.isFinite(numeric)) return `${key} expects a number`
+  if (kind === 'ratio') {
+    if (numeric <= 0 || numeric > 1) return 'thresholdRatio expects a number in (0, 1]'
+    if (engine.config.retainRatio !== undefined && engine.config.retainRatio >= numeric) {
+      return `thresholdRatio must stay above retainRatio (${engine.config.retainRatio})`
+    }
+    engine.config = Object.freeze({ ...engine.config, thresholdRatio: numeric })
+    return `thresholdRatio = ${numeric} (this session)`
+  }
+  if (!Number.isInteger(numeric) || numeric < 1) return `${key} expects a positive integer`
+  engine.dcp[key] = numeric
+  return `${key} = ${numeric} (this session)`
+}
+
+/** Human-readable engine status block. */
+function statusText(engine, version) {
+  const stats = engine.dcpStats
+  const lines = [
+    `dsh-dcp ${version} — deterministic compaction backend (zero LLM summarization calls)`,
+    `config: dedup=${engine.dcp.dedup} purgeErrors=${engine.dcp.purgeErrors} maxItems=${engine.dcp.maxItems} maxItemChars=${engine.dcp.maxItemChars} maxSummaryTokens=${engine.dcp.maxSummaryTokens} language=${engine.dcp.language} tokenEstimate=${engine.dcp.tokenEstimate} protectedTools=[${engine.dcp.protectedTools.join(', ')}] thresholdRatio=${engine.config.thresholdRatio}`,
+    `stats: ${stats.compactions} compaction${stats.compactions === 1 ? '' : 's'}, ~${stats.shadowedTokens} tokens shadowed, ${stats.compactions} LLM summary call${stats.compactions === 1 ? '' : 's'} avoided`,
+  ]
+  if (stats.lastAt !== null) lines.push(`last compaction: ${new Date(stats.lastAt).toLocaleString()}`)
+  return lines.join('\n')
+}
+
+/** `/dcp compact` — manual deterministic compaction through the seam. */
+async function compactNow(ctx, invocation, engine) {
+  try {
+    const result = await ctx.compaction.compactNow(invocation.agent, invocation.signal, invocation.commandId)
+    if (result === null) return success('No compactable history yet.')
+    return success(
+      `Compacted ${result.shadowedSeqs.length} history items (~${result.shadowedTokenCount} tokens) deterministically — no LLM call used.`,
+      result.summarySeq,
+    )
+  } catch (error) {
+    if (invocation.signal.aborted) return failure(FAILURE_TEXT.cancelled)
+    if (error instanceof ManualCompactionError) return failure(FAILURE_TEXT[error.code] ?? error.message)
+    throw error
+  }
+}
+
+/** Dispatch one `/dcp` invocation. */
+export async function executeDcp(ctx, invocation, engine, version) {
+  const tokens = invocation.rawInput.trim().split(/\s+/).filter((token) => token.length > 0)
+  const [subcommand, ...rest] = tokens
+  if (subcommand === undefined) return success(statusText(engine, version))
+  if (subcommand === 'status') return success(statusText(engine, version))
+  if (subcommand === 'help') return success(USAGE)
+  if (subcommand === 'compact') return compactNow(ctx, invocation, engine)
+  if (subcommand === 'set') {
+    if (rest.length < 2) return failure(USAGE)
+    const outcome = applySet(engine, rest[0], rest.slice(1).join(' '))
+    if (!/^[\w.]+ = /.test(outcome)) return failure(outcome)
+    return success(
+      `${outcome}\npersist across restarts in ~/.dsh/cordis.patch.yml:\n  - id: compaction-basic\n    name: ${engine.pluginPath ?? '<abs path to dsh-dcp>/lib/index.js'}\n    config:\n      ${rest[0]}: ${rest.slice(1).join(' ')}`,
+    )
+  }
+  return failure(`unknown subcommand "${subcommand}"\n${USAGE}`)
+}
+
+/**
+ * Register `/dcp` on the host command registry.
+ * @returns {() => void} disposer for cordis effect teardown.
+ */
+export function registerDcpCommand(ctx, engine, version) {
+  return ctx.commands.register({
+    name: 'dcp',
+    description: 'dsh-dcp: deterministic compaction status and controls',
+    handler: (invocation) => executeDcp(ctx, invocation, engine, version),
+  })
+}

package/lib/config.js

@@ -0,0 +1,113 @@
+/**
+ * dsh-dcp configuration: the dcp-specific knobs layered on top of
+ * compaction-basic's policy keys. Everything here is optional — the resolved
+ * defaults are the documented out-of-the-box behavior.
+ *
+ * @module dsh-dcp/config
+ */
+
+/** dcp-specific keys this plugin adds on top of compaction-basic. */
+export const DCP_CONFIG_KEYS = [
+  'dedup',
+  'purgeErrors',
+  'maxItems',
+  'maxItemChars',
+  'maxSummaryTokens',
+  'language',
+  'tokenEstimate',
+  'protectedTools',
+]
+
+/** compaction-basic policy keys forwarded to the parent engine verbatim. */
+export const BASIC_CONFIG_KEYS = [
+  'thresholdRatio',
+  'retainRatio',
+  'retainTokens',
+  'summarizationProvider',
+  'summarizationModel',
+  'maxTokens',
+  'compactionRetries',
+  'maxOverflowRetries',
+  'modelPolicies',
+  'auto',
+]
+
+const DEFAULTS = Object.freeze({
+  dedup: true,
+  purgeErrors: true,
+  maxItems: 10,
+  maxItemChars: 200,
+  maxSummaryTokens: 2048,
+  language: 'en',
+  tokenEstimate: 'cjk',
+  protectedTools: Object.freeze(['write', 'edit', 'apply_patch']),
+})
+
+/**
+ * Split one loader-level plugin config into the parent engine's keys and the
+ * dcp keys, rejecting unknown keys loudly (mirrors compaction-basic's own
+ * fail-fast validation so typos never hide behind defaults).
+ *
+ * @param {Record<string, unknown>} config - untrusted plugin configuration.
+ * @returns {{ basic: Record<string, unknown>, dcp: Record<string, unknown> }}
+ */
+export function splitConfig(config = {}) {
+  const known = new Set([...BASIC_CONFIG_KEYS, ...DCP_CONFIG_KEYS])
+  for (const key of Object.keys(config)) {
+    if (!known.has(key)) throw new Error(`DcpConfig: unknown key "${key}"`)
+  }
+  const basic = {}
+  for (const key of BASIC_CONFIG_KEYS) {
+    if (config[key] !== undefined) basic[key] = config[key]
+  }
+  const dcp = {}
+  for (const key of DCP_CONFIG_KEYS) {
+    if (config[key] !== undefined) dcp[key] = config[key]
+  }
+  return { basic, dcp }
+}
+
+/**
+ * Validate and resolve dcp defaults.
+ *
+ * @param {Record<string, unknown>} raw - the dcp half of {@link splitConfig}.
+ * @returns {Readonly<{dedup: boolean, purgeErrors: boolean, maxItems: number, maxItemChars: number, maxSummaryTokens: number, language: 'en'|'zh', tokenEstimate: 'cjk'|'ascii', protectedTools: readonly string[]}>}
+ */
+export function resolveDcpConfig(raw = {}) {
+  if (raw.dedup !== undefined && typeof raw.dedup !== 'boolean') {
+    throw new Error('DcpConfig: dedup must be a boolean')
+  }
+  if (raw.purgeErrors !== undefined && typeof raw.purgeErrors !== 'boolean') {
+    throw new Error('DcpConfig: purgeErrors must be a boolean')
+  }
+  if (raw.language !== undefined && raw.language !== 'en' && raw.language !== 'zh') {
+    throw new Error('DcpConfig: language must be "en" or "zh"')
+  }
+  if (raw.tokenEstimate !== undefined && raw.tokenEstimate !== 'cjk' && raw.tokenEstimate !== 'ascii') {
+    throw new Error('DcpConfig: tokenEstimate must be "cjk" or "ascii"')
+  }
+  for (const key of ['maxItems', 'maxItemChars', 'maxSummaryTokens']) {
+    const value = raw[key]
+    if (value !== undefined && (typeof value !== 'number' || !Number.isInteger(value) || value < 1)) {
+      throw new Error(`DcpConfig: ${key} (${String(value)}) must be a positive integer`)
+    }
+  }
+  if (raw.protectedTools !== undefined) {
+    if (!Array.isArray(raw.protectedTools) || raw.protectedTools.some((item) => typeof item !== 'string' || item.length === 0)) {
+      throw new Error('DcpConfig: protectedTools must be an array of non-empty strings')
+    }
+  }
+  return Object.freeze({ ...DEFAULTS, ...raw })
+}
+
+/** Keys `/dcp set` may adjust at runtime, with their value kind for parsing. */
+export const RUNTIME_SETTABLE = Object.freeze({
+  dedup: 'boolean',
+  purgeErrors: 'boolean',
+  maxItems: 'positive-integer',
+  maxItemChars: 'positive-integer',
+  maxSummaryTokens: 'positive-integer',
+  language: 'language',
+  tokenEstimate: 'token-estimate',
+  thresholdRatio: 'ratio',
+})

package/lib/index.js

@@ -0,0 +1,129 @@
+/**
+ * dsh-dcp — deterministic context-pruning compaction backend for dsh.
+ *
+ * Replaces `compaction-basic`'s LLM summarization with a deterministic,
+ * template-based checkpoint extractor: zero auxiliary LLM calls per
+ * compaction, stable output for identical input, Chinese-friendly trigger
+ * tuning via the usual policy keys. Everything else — pressure triggers,
+ * retention, overflow recovery, durable transactions, tool-pairing safety —
+ * is inherited from `BasicCompactionEngine`, whose `summarize()` is the sole
+ * customization seam (see docs/subsystems/compaction.md in deepseek-harness).
+ *
+ * Design references Opencode-DCP/opencode-dynamic-context-pruning: dedup
+ * repeated tool calls, purge stale errors, technical summaries instead of
+ * prose, `/dcp` command, defaults that work with no configuration.
+ *
+ * Mount (home-level patch, `~/.dsh/cordis.patch.yml`):
+ *
+ * ```yaml
+ * - id: compaction-basic
+ *   name: /absolute/path/to/dsh-dcp/lib/index.js
+ *   config:
+ *     thresholdRatio: 0.7   # optional; every key is optional
+ * ```
+ *
+ * @module dsh-dcp
+ */
+
+import { createRequire } from 'node:module'
+import { fileURLToPath } from 'node:url'
+import z from '@deepseek-ai/schemastery'
+import { BasicCompactionEngine } from '@deepseek-ai/dsh-compaction-basic'
+import { splitConfig, resolveDcpConfig } from './config.js'
+import { summarizeDeterministically } from './summarizer.js'
+import { registerDcpCommand } from './command.js'
+
+const require = createRequire(import.meta.url)
+const { version: VERSION } = require('../package.json')
+
+/**
+ * Deterministic compaction engine: `summarize()` overridden, everything else
+ * inherited. Registers the `/dcp` command beside the inherited `/compact`.
+ */
+/** Element schema mirroring compaction-basic's model-policy override shape. */
+const modelPolicy = z.object({
+  provider: z.string().required(),
+  model: z.string().required(),
+  thresholdRatio: z.number(),
+  retainRatio: z.number(),
+  retainTokens: z.number().step(1).min(0),
+  summarizationProvider: z.string(),
+  summarizationModel: z.string(),
+  maxTokens: z.number().step(1).min(1),
+  compactionRetries: z.number().step(1).min(0),
+  maxOverflowRetries: z.number().step(1).min(0),
+})
+
+export class DcpEngine extends BasicCompactionEngine {
+  static inject = ['llm', 'tokenMeter', 'sessions', 'commands']
+
+  static Config = z.object({
+    // compaction-basic policy keys (forwarded verbatim)
+    thresholdRatio: z.number(),
+    retainRatio: z.number(),
+    retainTokens: z.number().step(1).min(0),
+    summarizationProvider: z.string(),
+    summarizationModel: z.string(),
+    maxTokens: z.number().step(1).min(1),
+    compactionRetries: z.number().step(1).min(0),
+    maxOverflowRetries: z.number().step(1).min(0),
+    modelPolicies: z.array(modelPolicy),
+    auto: z.boolean(),
+    // dsh-dcp knobs
+    dedup: z.boolean(),
+    purgeErrors: z.boolean(),
+    maxItems: z.number().step(1).min(1),
+    maxItemChars: z.number().step(1).min(1),
+    maxSummaryTokens: z.number().step(1).min(1),
+    language: z.string(),
+    tokenEstimate: z.string(),
+    protectedTools: z.array(z.string()),
+  })
+
+  /** Resolved dcp knobs; mutable at runtime through `/dcp set`. */
+  dcp
+
+  /** Compaction counters surfaced by `/dcp`. */
+  dcpStats
+
+  /** Absolute module path, echoed by `/dcp set` for persistence snippets. */
+  pluginPath
+
+  constructor(ctx, config = {}) {
+    const { basic, dcp } = splitConfig(config)
+    super(ctx, basic)
+    this.dcp = { ...resolveDcpConfig(dcp) }
+    this.dcpStats = { compactions: 0, shadowedTokens: 0, lastAt: null }
+    this.pluginPath = fileURLToPath(import.meta.url)
+    const engine = this
+    ctx.effect(function* () {
+      yield registerDcpCommand(ctx, engine, VERSION)
+    }, 'dsh-dcp /dcp command lifecycle')
+  }
+
+  /**
+   * The sole overridden seam: condense the replayed region deterministically.
+   * No LLM call, no cancellation window beyond the fast synchronous walk.
+   * Budgeting uses the CJK-aware estimator unless `tokenEstimate: ascii` is set.
+   */
+  async summarize(input, agent, signal) {
+    signal?.throwIfAborted()
+    try {
+      return summarizeDeterministically(input, this.dcp)
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      throw new Error(`dsh-dcp deterministic summarization failed: ${message}`, { cause: error })
+    }
+  }
+
+  /** Count every committed compaction (automatic and manual) for `/dcp`. */
+  async compactRegion(start, end, agent, signal) {
+    const result = await super.compactRegion(start, end, agent, signal)
+    this.dcpStats.compactions += 1
+    this.dcpStats.shadowedTokens += result.shadowedTokenCount
+    this.dcpStats.lastAt = Date.now()
+    return result
+  }
+}
+
+export default DcpEngine

package/lib/summarizer.js

@@ -0,0 +1,541 @@
+/**
+ * Deterministic region summarizer — the dsh-dcp core.
+ *
+ * Where compaction-basic replays the region into an LLM summarization call,
+ * this module condenses the same replayed messages with pure code: verbatim
+ * user intents, touched files, executed commands, one-line errors, pending
+ * todos, duplicate tool calls, and the durable facts of a prior checkpoint.
+ * Zero LLM calls, stable output for identical input (design references
+ * Opencode-DCP/opencode-dynamic-context-pruning: dedup, error purge,
+ * "technical summary instead of prose").
+ *
+ * The output keeps compaction-basic's checkpoint section names so downstream
+ * consumers (and a later basic-engine compaction merging prior
+ * `<compacted-summary>` blocks) see a familiar structure.
+ *
+ * @module dsh-dcp/summarizer
+ */
+
+/** Section headers shared with compaction-basic's checkpoint instruction. */
+export const SECTIONS = Object.freeze({
+  intent: 'Primary Request and Intent',
+  concepts: 'Key Technical Concepts',
+  files: 'Files and Code',
+  errors: 'Errors and Fixes',
+  todos: 'Pending Jobs',
+  current: 'Current Work',
+  next: 'Next Step',
+  context: 'Critical Context',
+})
+
+/** Prior-checkpoint sections worth carrying forward (stale ones regenerate). */
+const CARRIED_SECTIONS = new Set([
+  SECTIONS.intent,
+  SECTIONS.concepts,
+  SECTIONS.files,
+  SECTIONS.errors,
+  SECTIONS.context,
+])
+
+const SUMMARY_OPEN_TAG = '<compacted-summary>'
+const SUMMARY_CLOSE_TAG = '</compacted-summary>'
+
+/** Arg keys whose string value names a filesystem path. */
+const PATH_KEYS = ['file_path', 'absolute_path', 'notebook_path', 'path', 'glob', 'pattern']
+/** Arg keys whose string value is a shell command. */
+const COMMAND_KEYS = ['command', 'cmd', 'script']
+/** Tool-name fragments that mark a mutating (write-side) call. */
+const WRITE_TOOL = /write|edit|patch|delete|remove|mkdir|move|rename|create/i
+/** Command vocabulary lifted into Key Technical Concepts. */
+const COMMAND_CONCEPTS = /\b(git|npm|pnpm|yarn|bun|cargo|go|python|pip|uv|docker|kubectl|helm|make|gradle|maven|curl|terraform)\b/gi
+/** Checkbox todo lines in any user/assistant text. */
+const TODO_LINE = /^\s*[-*]\s+\[( |x|X)\]\s*(.+)$/gm
+/** English todo markers, colon-terminated to avoid prose hits. */
+const MARKER_TODO_EN = /^\s*(?:TODO|FIXME)\s*[:：]\s*(.+)$/gim
+/** Chinese todo marker, colon-terminated. */
+const MARKER_TODO_ZH = /^\s*待办\s*[:：]\s*(.+)$/gim
+/** First-line signals of a tool error, English set (terminal locale LANG=C). */
+const ERROR_LINE_EN = /(error|failed|failure|fatal|exception|enoent|eacces|eperm|denied|refused|not found|cannot |unable |exit code [1-9])/i
+/** First-line signals of a tool error, Chinese set — dsh-bash and friends can surface localized failures. */
+const ERROR_LINE_ZH = /(失败|错误|报错|异常|找不到|未找到|不存在|无法|拒绝|超时|崩溃|致命)/i
+
+/** Error regexes active for one output language. */
+function errorPatterns(language) {
+  return language === 'zh' ? [ERROR_LINE_EN, ERROR_LINE_ZH] : [ERROR_LINE_EN]
+}
+
+/** Todo-line regexes active for one output language, split by shape. */
+function todoPatterns(language) {
+  const markers = language === 'zh' ? [MARKER_TODO_EN, MARKER_TODO_ZH] : [MARKER_TODO_EN]
+  return { checkbox: TODO_LINE, markers }
+}
+
+/**
+ * CJK scripts and full-width forms priced denser than ASCII: Han (中文), kana
+ * (日文), hangul (韩文), plus CJK punctuation and full-width variants. CJK is
+ * not only Chinese — every script here encodes a character in roughly one
+ * token in real tokenizers.
+ */
+const CJK_CHAR = /[\u3000-\u303f\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uff00-\uffef\uac00-\ud7af]/g
+
+/**
+ * Token heuristic, selectable by the `tokenEstimate` config:
+ *
+ * - `cjk` (default): CJK scripts at ~2 chars/token, ASCII at 4. The host
+ *   meter prices every character at 4/token, which matches English but
+ *   underestimates CJK by ~2x, so CJK-heavy regions get compacted late and
+ *   starved of budget. This mode prices all CJK scripts near reality while
+ *   staying identical to the host for pure-ASCII text.
+ * - `ascii`: flat 4 chars/token for every character — exactly the host
+ *   meter's numbers, for users who want byte-identical behavior.
+ *
+ * @param {string} text - text to price.
+ * @param {'cjk'|'ascii'} [mode] - pricing mode.
+ * @returns {number} estimated tokens.
+ */
+export function estimateTextTokens(text, mode = 'cjk') {
+  const source = String(text)
+  if (mode === 'ascii') return Math.ceil(source.length / 4)
+  const cjk = (source.match(CJK_CHAR) ?? []).length
+  return Math.ceil(cjk / 2 + (source.length - cjk) / 4)
+}
+
+/**
+ * Token estimate for one message: text blocks, tool-call arguments, and
+ * tool-result payloads (the same content the host meter prices, minus its
+ * per-block overhead).
+ *
+ * @param {{ content?: Array<{ type: string }> }} message - any message-shaped object.
+ * @param {'cjk'|'ascii'} [mode] - pricing mode, see {@link estimateTextTokens}.
+ * @returns {number} estimated tokens.
+ */
+export function estimateMessageTokens(message, mode = 'cjk') {
+  const parts = []
+  for (const block of message?.content ?? []) {
+    if (block.type === 'text') parts.push(block.text)
+    else if (block.type === 'tool-call') parts.push(block.arguments)
+    else if (block.type === 'tool-result') {
+      for (const inner of block.content ?? []) {
+        if (inner.type === 'text') parts.push(inner.text)
+      }
+    }
+  }
+  return estimateTextTokens(parts.join('\n'), mode)
+}
+
+const i18n = Object.freeze({
+  en: Object.freeze({
+    none: '(none)',
+    elidedIntents: '({n} earlier user messages elided)',
+    elidedErrors: '({n} earlier errors elided)',
+    dedupNote: '{tool}({args}) ran {n}x — identical repeats, latest result kept in the retained tail',
+    contextNote: '{messages} messages / {calls} tool calls compacted deterministically by dsh-dcp (no LLM summarization call)',
+    carried: 'carried from prior checkpoint',
+    terseHeader: '{messages} messages ({calls} tool calls) compacted deterministically by dsh-dcp.',
+  }),
+  zh: Object.freeze({
+    none: '（无）',
+    elidedIntents: '（省略 {n} 条较早的用户消息）',
+    elidedErrors: '（省略 {n} 条较早的报错）',
+    dedupNote: '{tool}({args}) 执行了 {n} 次 —— 重复调用，仅保留最近一次结果',
+    contextNote: 'dsh-dcp 确定性压缩了 {messages} 条消息 / {calls} 次工具调用（未调用 LLM 摘要）',
+    carried: '继承自上一次压缩检查点',
+    terseHeader: 'dsh-dcp 确定性压缩了 {messages} 条消息（{calls} 次工具调用）。',
+  }),
+})
+
+/** Collapse whitespace and hard-cap one item's length with an ellipsis. */
+export function clip(text, maxChars) {
+  const flat = String(text).replace(/\s+/g, ' ').trim()
+  return flat.length <= maxChars ? flat : flat.slice(0, maxChars - 1) + '…'
+}
+
+/** Message text blocks joined with newlines (tool results and reasoning excluded). */
+function textOf(message) {
+  return message.content
+    .filter((block) => block.type === 'text')
+    .map((block) => block.text)
+    .join('\n')
+}
+
+/**
+ * Re-injected host context that appears as user-role messages every turn:
+ * system-prompt snapshots, skill catalogs, and AGENTS.md-style instructions.
+ * The host re-sends these on every request, so copying them into a checkpoint
+ * is pure waste — the model never loses them. (A prior compaction checkpoint
+ * is handled separately, and plugin notice/relay/recall forms stay.)
+ */
+function isInjectedContext(message) {
+  const kind = message.source?.kind
+  if (kind === 'skill-catalog' || kind === 'agent-instructions') return true
+  return kind === 'plugin' && message.source.form === 'snapshot'
+}
+
+/**
+ * One-line summary a producer attached to a `notice`-form message (e.g. a
+ * settled subagent's closing account). Prefer it over the full text: it is
+ * the host's own terse condensation, bounded by CONTEXT_SUMMARY_MAX_CHARS.
+ */
+function noticeSummary(message) {
+  const source = message.source
+  if (source?.form === 'notice' && typeof source.summary === 'string' && source.summary.length > 0) {
+    return source.summary
+  }
+  return undefined
+}
+
+/** Tool-result blocks flattened as text, first non-empty line kept per block. */
+function resultFirstLines(blocks) {
+  const lines = []
+  for (const block of blocks) {
+    if (block.type !== 'tool-result') continue
+    const text = block.content
+      .filter((inner) => inner.type === 'text')
+      .map((inner) => inner.text)
+      .join('\n')
+      .split('\n')
+      .map((line) => line.trim())
+      .find((line) => line.length > 0)
+    if (text !== undefined) lines.push({ isError: block.isError === true, line: text })
+  }
+  return lines
+}
+
+/**
+ * Parse one prior checkpoint text into its `## ` sections.
+ * @returns {Map<string, string[]>} header → bullet/item lines (markers stripped).
+ */
+export function parseCheckpointSections(text) {
+  const inner = text.includes(SUMMARY_OPEN_TAG)
+    ? text.slice(text.indexOf(SUMMARY_OPEN_TAG) + SUMMARY_OPEN_TAG.length, text.lastIndexOf(SUMMARY_CLOSE_TAG))
+    : text
+  const sections = new Map()
+  let header = ''
+  for (const line of inner.split('\n')) {
+    const match = /^##\s+(.+?)\s*$/.exec(line)
+    if (match !== null) {
+      header = match[1]
+      if (!sections.has(header)) sections.set(header, [])
+      continue
+    }
+    if (header !== '' && line.trim().length > 0) sections.get(header).push(line.trim().replace(/^[-*]\s+/, ''))
+  }
+  return sections
+}
+
+/** File path named by a parsed tool-call argument, when there is one. */
+function argPath(parsed) {
+  if (parsed === undefined || parsed === null) return undefined
+  for (const key of PATH_KEYS) {
+    const value = parsed[key]
+    if (typeof value === 'string' && value.length > 0) return value
+  }
+  return undefined
+}
+
+/** Shell command named by a parsed tool-call argument, when there is one. */
+function argCommand(parsed) {
+  if (parsed === undefined || parsed === null) return undefined
+  for (const key of COMMAND_KEYS) {
+    const value = parsed[key]
+    if (typeof value === 'string' && value.length > 0) return value
+  }
+  return undefined
+}
+
+/** Short display form of one call's arguments for dedup notes. */
+function argDisplay(name, parsed) {
+  const path = argPath(parsed)
+  if (path !== undefined) return clip(path, 80)
+  const command = argCommand(parsed)
+  if (command !== undefined) return clip(command, 80)
+  if (parsed !== undefined && parsed !== null && typeof parsed === 'object') {
+    const first = Object.values(parsed).find((value) => typeof value === 'string' && value.length > 0)
+    if (first !== undefined) return clip(first, 80)
+  }
+  return ''
+}
+
+/**
+ * Walk the replayed region and collect every deterministic fact.
+ *
+ * @param {import('@deepseek-ai/dsh-llm').Message[]} messages - region messages in surface order.
+ * @param {'en'|'zh'} [language] - which error/todo keyword set applies; `zh` also
+ *   recognizes localized (Chinese) failures and `待办` markers.
+ * @returns {object} the extracted fact bundle.
+ */
+export function extractFacts(messages, language = 'en') {
+  const facts = {
+    messageCount: messages.length,
+    intents: [],
+    files: new Map(),
+    commands: [],
+    errors: [],
+    pendingTodos: [],
+    concepts: new Set(),
+    dupCounts: new Map(),
+    toolCallCount: 0,
+    lastUserText: '',
+    lastAssistantText: '',
+    carried: new Map(),
+  }
+  const callsById = new Map()
+  const errorRegexes = errorPatterns(language)
+  const { checkbox, markers } = todoPatterns(language)
+
+  const rememberTodoLines = (text) => {
+    checkbox.lastIndex = 0
+    for (const match of text.matchAll(checkbox)) {
+      const item = match[2].trim()
+      if (item.length === 0) continue
+      if (match[1] === ' ') {
+        if (!facts.pendingTodos.some((existing) => existing === item)) facts.pendingTodos.push(item)
+      } else {
+        const index = facts.pendingTodos.indexOf(item)
+        if (index !== -1) facts.pendingTodos.splice(index, 1)
+      }
+    }
+    for (const pattern of markers) {
+      pattern.lastIndex = 0
+      for (const match of text.matchAll(pattern)) {
+        const item = match[1].trim()
+        if (item.length > 0 && !facts.pendingTodos.some((existing) => existing === item)) facts.pendingTodos.push(item)
+      }
+    }
+  }
+
+  for (const message of messages) {
+    if (message.role === 'assistant') {
+      const text = textOf(message)
+      if (text.trim().length > 0) {
+        facts.lastAssistantText = text
+        rememberTodoLines(text)
+      }
+      for (const block of message.content) {
+        if (block.type !== 'tool-call') continue
+        facts.toolCallCount += 1
+        let parsed
+        try {
+          parsed = JSON.parse(block.arguments)
+        } catch {
+          parsed = undefined
+        }
+        const info = { name: block.name, parsed }
+        callsById.set(block.id, info)
+
+        const path = argPath(parsed)
+        if (path !== undefined) {
+          const entry = facts.files.get(path) ?? { reads: 0, writes: 0 }
+          if (WRITE_TOOL.test(block.name)) entry.writes += 1
+          else entry.reads += 1
+          facts.files.set(path, entry)
+          const extension = /\.([a-z0-9]{1,5})$/i.exec(path)
+          if (extension !== null) facts.concepts.add(extension[1].toLowerCase())
+        }
+        const command = argCommand(parsed)
+        if (command !== undefined) {
+          facts.commands.push(command)
+          for (const match of command.match(COMMAND_CONCEPTS) ?? []) facts.concepts.add(match.toLowerCase())
+        }
+        const key = `${block.name}\u0000${block.arguments}`
+        const dup = facts.dupCounts.get(key) ?? { name: block.name, parsed, count: 0 }
+        dup.count += 1
+        facts.dupCounts.set(key, dup)
+      }
+      continue
+    }
+
+    // user-role messages: tool results, prior checkpoints, real user text
+    const results = resultFirstLines(message.content)
+    if (results.length > 0) {
+      for (const result of results) {
+        const isError = result.isError || errorRegexes.some((pattern) => pattern.test(result.line))
+        if (!isError) continue
+        const call = message.source?.kind === 'tool' ? callsById.get(message.source.callId) : undefined
+        const who = call === undefined ? 'tool' : call.name
+        facts.errors.push(`${who}: ${result.line}`)
+      }
+      continue
+    }
+    const text = textOf(message)
+    if (text.trim().length === 0) continue
+    if (message.source?.kind === 'plugin' && message.source.plugin === 'compact') {
+      facts.carried = parseCheckpointSections(text)
+      continue
+    }
+    if (isInjectedContext(message)) continue
+    const intentText = noticeSummary(message) ?? text
+    facts.lastUserText = intentText
+    facts.intents.push(intentText)
+    rememberTodoLines(intentText)
+  }
+
+  for (const command of facts.commands) facts.concepts.add(command.split(/\s+/)[0]?.toLowerCase() ?? '')
+  return facts
+}
+
+/** Merge carried checkpoint lines with freshly extracted ones, deduped in order. */
+function mergeCarried(facts, maxItems) {
+  const carriedOf = (header) => facts.carried.get(header) ?? []
+  const dedupe = (lines) => {
+    const seen = new Set()
+    const merged = []
+    for (const line of lines) {
+      const key = line.toLowerCase().replace(/[^a-z0-9/\u4e00-\u9fff]/g, '')
+      if (key.length === 0 || seen.has(key)) continue
+      seen.add(key)
+      merged.push(line)
+    }
+    return merged
+  }
+  const withElision = (lines, elidedTemplate, t) => {
+    if (lines.length <= maxItems) return lines
+    const kept = lines.slice(-Math.max(1, maxItems - 1))
+    kept.unshift(t(elidedTemplate).replace('{n}', String(lines.length - kept.length)))
+    return kept
+  }
+  const mergeFileLines = (fresh, carried) => {
+    const freshPaths = new Set(fresh.map((line) => line.split(/\s+[—-]\s+/)[0]?.trim() ?? line))
+    const survivors = carried.filter((line) => {
+      const path = line.split(/\s+[—-]\s+/)[0]?.trim() ?? line
+      return !freshPaths.has(path)
+    })
+    return [...fresh, ...survivors]
+  }
+  return { carriedOf, dedupe, withElision, mergeFileLines }
+}
+
+/** Render one section with bullets, or the localized "(none)"; null when dropped. */
+function renderSection(header, items, t, dropEmpty) {
+  const unique = [...new Set(items.filter((item) => item !== undefined && item !== null && String(item).trim().length > 0))]
+  if (dropEmpty && unique.length === 0) return null
+  const body = unique.length === 0 ? [t('none')] : unique.map((item) => `- ${item}`)
+  return [`## ${header}`, ...body, '']
+}
+
+/**
+ * Compose the deterministic checkpoint summary.
+ *
+ * @param {object} facts - {@link extractFacts} output.
+ * @param {object} options - resolved dcp config plus degradation knobs.
+ * @returns {string} markdown summary text.
+ */
+export function composeSummary(facts, options) {
+  const { maxItems, maxItemChars, language, dedup, purgeErrors, protectedTools = [], sectionCap = maxItems, itemChars = maxItemChars, dropEmpty = false } = options
+  const t = (key) => i18n[language][key]
+  const { carriedOf, dedupe, withElision, mergeFileLines } = mergeCarried(facts, sectionCap)
+
+  const intents = dedupe([
+    ...carriedOf(SECTIONS.intent),
+    ...facts.intents.map((text) => clip(text, itemChars)),
+  ])
+  const intentItems = withElision(intents, 'elidedIntents', t)
+
+  const conceptItems = dedupe([...carriedOf(SECTIONS.concepts), ...facts.concepts])
+
+  const freshFileItems = [...facts.files.entries()].map(([path, ops]) =>
+    clip(`${path} — ${ops.writes > 0 ? `W×${ops.writes}${ops.reads > 0 ? ` R×${ops.reads}` : ''}` : `R×${ops.reads}`}`, itemChars),
+  )
+  const fileItems = dedupe(mergeFileLines(freshFileItems, carriedOf(SECTIONS.files))).slice(0, sectionCap)
+
+  // purgeErrors collapses older errors to an elision note (most recent kept);
+  // when disabled every distinct error survives up to the section cap.
+  const errorItems = dedupe([...carriedOf(SECTIONS.errors), ...facts.errors.map((line) => clip(line, itemChars))])
+  const errorLines = (purgeErrors ? withElision(errorItems, 'elidedErrors', t) : errorItems).slice(0, sectionCap)
+
+  const todoItems = facts.pendingTodos.map((item) => clip(item, itemChars)).slice(0, sectionCap)
+
+  const currentItems = []
+  if (facts.lastUserText.trim().length > 0) currentItems.push(clip(facts.lastUserText, itemChars))
+  if (facts.lastAssistantText.trim().length > 0) {
+    currentItems.push(clip(facts.lastAssistantText.split('\n').filter((line) => line.trim().length > 0).slice(0, 2).join(' / '), itemChars))
+  }
+
+  const nextItem = todoItems.length > 0 ? todoItems[todoItems.length - 1] : t('none')
+
+  const contextItems = [...carriedOf(SECTIONS.context)]
+  if (dedup) {
+    for (const dup of facts.dupCounts.values()) {
+      if (dup.count < 2) continue
+      const isProtected = protectedTools.some((p) => dup.name.includes(p))
+      if (isProtected) continue
+      const args = argDisplay(dup.name, dup.parsed)
+      contextItems.push(t('dedupNote').replace('{tool}', dup.name).replace('{args}', args).replace('{n}', String(dup.count)))
+    }
+  }
+  contextItems.push(t('contextNote').replace('{messages}', String(facts.messageCount)).replace('{calls}', String(facts.toolCallCount)))
+
+  const blocks = [
+    renderSection(SECTIONS.intent, intentItems, t, dropEmpty),
+    renderSection(SECTIONS.concepts, conceptItems, t, dropEmpty),
+    renderSection(SECTIONS.files, fileItems, t, dropEmpty),
+    renderSection(SECTIONS.errors, errorLines, t, dropEmpty),
+    renderSection(SECTIONS.todos, todoItems, t, dropEmpty),
+    renderSection(SECTIONS.current, currentItems, t, dropEmpty),
+    renderSection(SECTIONS.next, [nextItem], t, dropEmpty),
+    renderSection(SECTIONS.context, contextItems, t, dropEmpty),
+  ]
+  return blocks
+    .filter((section) => section !== null)
+    .map((section) => section.join('\n'))
+    .join('\n')
+    .trim()
+}
+
+/** Last-resort fixed-shape summary for pathological budget situations. */
+function composeTerse(facts, t, itemChars) {
+  const files = [...facts.files.keys()].slice(0, 12).join(', ')
+  const lastError = facts.errors.length > 0 ? clip(facts.errors[facts.errors.length - 1], Math.min(itemChars, 120)) : t('none')
+  const next = facts.pendingTodos.length > 0 ? clip(facts.pendingTodos[facts.pendingTodos.length - 1], Math.min(itemChars, 120)) : t('none')
+  const carriedIntents = (facts.carried.get(SECTIONS.intent) ?? []).slice(0, 3).map((line) => clip(line, Math.min(itemChars, 100)))
+  const lines = [
+    t('terseHeader').replace('{messages}', String(facts.messageCount)).replace('{calls}', String(facts.toolCallCount)),
+    `Request: ${clip(facts.lastUserText || carriedIntents[0] || t('none'), 160)}`,
+    files.length > 0 ? `Files: ${files}` : `Files: ${t('none')}`,
+    `Errors: ${lastError}`,
+    `Next: ${next}`,
+    ...carriedIntents.map((line) => `Prior: ${line}`),
+  ]
+  return lines.join('\n').trim()
+}
+
+/**
+ * Deterministically summarize one compaction region under a token budget.
+ *
+ * Budgets with the CJK-aware estimator by default (honoring
+ * `dcp.tokenEstimate`); an explicit estimator may be supplied to mirror a
+ * different meter.
+ *
+ * @param {{ messages: import('@deepseek-ai/dsh-llm').Message[] }} input - replayed region.
+ * @param {object} dcp - resolved dcp config.
+ * @param {(message: unknown) => number} [estimateMessageLike] - token estimator; defaults to {@link estimateMessageTokens}.
+ * @returns {{ summary: { type: 'text', text: string }[], provider: string, model: string }}
+ */
+export function summarizeDeterministically(input, dcp, estimateMessageLike = (message) => estimateMessageTokens(message, dcp.tokenEstimate)) {
+  const facts = extractFacts(input.messages, dcp.language)
+  const regionTokens = input.messages.reduce((total, message) => total + estimateMessageLike(message), 0)
+  const targetTokens = Math.min(dcp.maxSummaryTokens, Math.floor(regionTokens * 0.45))
+  const estimate = (text) => estimateMessageLike({ role: 'user', content: [{ type: 'text', text }], source: { kind: 'user' } })
+
+  const attempts = [
+    () => composeSummary(facts, dcp),
+    () => composeSummary(facts, { ...dcp, sectionCap: 3, itemChars: 80, dropEmpty: true }),
+    () => composeSummary(facts, { ...dcp, sectionCap: 2, itemChars: 60, dropEmpty: true }),
+    () => composeTerse(facts, (key) => i18n[dcp.language][key], dcp.maxItemChars),
+  ]
+
+  let text = attempts[0]()
+  for (const attempt of attempts.slice(1)) {
+    if (estimate(text) <= targetTokens) break
+    text = attempt()
+  }
+  if (estimate(text) > targetTokens) {
+    text = text.slice(0, Math.max(40, targetTokens * 3)).trim()
+  }
+
+  return {
+    summary: [{ type: 'text', text }],
+    provider: 'dsh-dcp',
+    model: 'deterministic-v1',
+  }
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@aiwayds/dsh-dcp",
+  "version": "0.1.0",
+  "description": "Deterministic context-pruning compaction backend for dsh (DeepSeek Harness) — zero-LLM summaries, /dcp command, works out of the box. Design references Opencode-DCP/opencode-dynamic-context-pruning.",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./summarizer": "./lib/summarizer.js",
+    "./config": "./lib/config.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "README.md",
+    "LICENSE",
+    "cordis.patch.example.yml"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "dsh-plugin",
+    "compaction",
+    "context-pruning",
+    "dcp"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fan56/dsh-dcp.git"
+  },
+  "homepage": "https://github.com/fan56/dsh-dcp",
+  "bugs": {
+    "url": "https://github.com/fan56/dsh-dcp/issues"
+  },
+  "dependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-brand": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-commands": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-compaction": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-compaction-basic": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-compaction-tool-result-pruner": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-invariants": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-token-meter": "0.1.0-rc.6",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "overrides": {
+    "@deepseek-ai/dsh-agent": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-brand": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-commands": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-compaction": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-compaction-tool-result-pruner": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-invariants": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-token-meter": "0.1.0-rc.6"
+  }
+}