@aiwayds/dsh-dcp 0.3.2 → 0.5.0

package/README.en.md

@@ -79,7 +79,7 @@ A checkpoint produced on a real session (Chinese content kept verbatim):
   `compaction-basic`
 - **Things dsh already does, deliberately not re-implemented**:
   - tool-result pruning (`compaction-tool-result-pruner`, deterministic by size)
-  - trigger policy, retained tail, overflow recovery (inherited from official)
+  - trigger policy, retained tail, overflow recovery (inherited from official; this plugin only adds the round-interval trigger, see below)
   - `/compact` command, UI checkpoint cards (shipped with dsh)
 
 ## Install
@@ -112,7 +112,27 @@ npx dsh-dcp-setup                   # safe: date-stamped backup → append-only
 | `/dcp set <k> <v>` | adjust a knob for this session, with a persist hint |
 
 Settable: `dedup`, `purgeErrors`, `maxItems`, `maxItemChars`,
-`maxSummaryTokens`, `language`, `tokenEstimate`, `thresholdRatio`.
+`maxSummaryTokens`, `language`, `tokenEstimate`, `thresholdRatio`,
+`roundInterval`, `notice`.
+
+The `/dcp` status also lists every session that has compacted (subagents
+included): `per-session: session-1 (2 compactions, ~444 tokens), child
+(1 compaction, ~22 tokens)`. Compactions count per session; disposed
+sessions (one-shot subagents included) fall out of the overview
+automatically, and the list is capped at the first 10 sessions (`+N more`
+for the rest) so the status stays one line.
+
+## Triggers
+
+| Trigger | When | Notes |
+|---|---|---|
+| Pressure | before every step | tokens ≥ `thresholdRatio` (inherited upstream default 0.8; this plugin's bundle mounts 0.7 — see config table) × context window |
+| Overflow recovery | on a provider context-window error | inherited |
+| **Round interval** | every `roundInterval` assistant messages | added by this plugin; one round = one LLM roundtrip (each tool-iteration response counts, so one-shot subagents trigger too). **Default 50**: first compaction after message 50, then every 50 more (100, 150, …); any compaction (pressure included) restarts the clock. Fires at the first idle boundary after the count is reached (below the pressure threshold too). `0` disables; requires the default `auto: true` |
+| Manual | `/dcp compact`, `/compact` | anytime |
+
+- **Subagents are covered**: in-process subagents (including continuable and one-shot children) dispatch through the same events, so pressure/overflow/round triggers count and fire per child session independently. The round trigger counts assistant messages, so a one-shot subagent whose whole run is a single turn (many tool iterations) triggers too.
+- **Visibility**: after every trigger event a one-line notice row (`dcp: compacted N history items (~X tokens, trigger)`) is appended to the session; frontends render it as a collapsed row. Note the row also rides the model request context (~15–25 tokens per compaction), and it is **on by default since 0.4.0** — disable with `notice: false`. `/dcp` stats count every committed region (a pressure retry loop may commit several).
 
 ## Configuration
 
@@ -120,7 +140,9 @@ All optional, defaults work out of the box:
 
 | Key | Default | Meaning |
 |---|---|---|
-| `thresholdRatio` | 0.7 | compaction trigger; 0.7 recommended for CJK-heavy sessions |
+| `thresholdRatio` | 0.8 | pressure trigger (inherited upstream compaction-basic default 0.8; this plugin's bundle patch mounts 0.7, recommended for CJK-heavy sessions) |
+| `roundInterval` | 50 | compact every N assistant messages (one LLM roundtrip) (0 disables). Default 50: 50, 100, 150… — the clock restarts after every compaction |
+| `notice` | `true` | append the one-line compaction notice to the session |
 | `language` | `zh` | summary language; `zh` also enables Chinese error/"待办：" detection |
 | `tokenEstimate` | `cjk` | CJK (zh/ja/ko/full-width) at ~2 chars/token; `ascii` matches the host |
 | `dedup` | `true` | annotate repeated tool calls |
@@ -128,6 +150,8 @@ All optional, defaults work out of the box:
 | `maxItems` / `maxItemChars` | 10 / 200 | summary density |
 | `maxSummaryTokens` | 2048 | summary token budget |
 
+> **Upgrade note (0.5.0)**: the `roundInterval` counter switched from completed turns to assistant messages — the same value now triggers more often (a single turn usually contains several assistant messages).
+
 ## Design reference
 
 - [Opencode-DCP/opencode-dynamic-context-pruning](https://github.com/Opencode-DCP/opencode-dynamic-context-pruning)
@@ -136,7 +160,7 @@ All optional, defaults work out of the box:
 ## Development
 
 ```bash
-npm install && npm test     # 45 tests: extractor/compaction/command/config/setup
+npm install && npm test     # 65 tests: extractor/compaction/command/config/triggers/setup
 ```
 
 ## License

package/README.md

@@ -61,7 +61,7 @@ dsh 默认的压缩（`compaction-basic`）每次压缩都要让模型把旧对
 - **不做语义归纳**：不"理解"代码，只保留"出现过的事实"。需要深度语义摘要的场景，请继续用官方 `compaction-basic`
 - **dsh 已经有的我们不重复做**：
   - 工具结果剪枝（`compaction-tool-result-pruner`，确定性按大小剪）
-  - 触发策略、保留尾巴、溢出恢复（直接继承官方）
+  - 触发策略、保留尾巴、溢出恢复（直接继承官方；本插件仅新增轮数触发，见上）
   - `/compact` 命令、UI 检查点卡片（dsh 自带）
 
 ## 安装
@@ -90,7 +90,21 @@ npx dsh-dcp-setup                   # 安全脚本：带日期备份 → 只追
 | `/dcp compact` | 立即压缩（零 LLM） |
 | `/dcp set <k> <v>` | 会话内调参，并提示如何持久化 |
 
-可调键：`dedup`、`purgeErrors`、`maxItems`、`maxItemChars`、`maxSummaryTokens`、`language`、`tokenEstimate`、`thresholdRatio`。
+可调键：`dedup`、`purgeErrors`、`maxItems`、`maxItemChars`、`maxSummaryTokens`、`language`、`tokenEstimate`、`thresholdRatio`、`roundInterval`、`notice`。
+
+`/dcp` 状态还会列出每个发生过压缩的会话（per-session 概览，含子代理），例如 `per-session: session-1 (2 compactions, ~444 tokens), child (1 compaction, ~22 tokens)`。压缩按会话独立计数；已销毁的会话（含 one-shot 子代理）自动从概览消失；列表封顶一行（最多前 10 个会话，超出显示 `+N more`）。
+
+## 触发条件
+
+| 触发 | 时机 | 说明 |
+|---|---|---|
+| 压力触发 | 每步请求前 | token ≥ `thresholdRatio`（继承上游默认 0.8；本插件 bundle 挂载默认 0.7，见配置表）× 上下文窗口 |
+| 溢出恢复 | 模型报 context 超限时 | 继承官方 |
+| **轮数触发** | 会话每收到 `roundInterval` 条 assistant message | 本插件新增；一条 = 一次 LLM 往返（每轮工具迭代各算一条，one-shot 子代理也能触发）。**默认 50**：第 50 条后触发第一次，之后每 50 条一次（100、150……）；任何一次压缩（含压力触发）都会重置轮数时钟。到达条数后的第一个空闲点触发（阈值之下也压）。`0` 关闭；需保持 `auto: true`（默认开） |
+| 手动 | `/dcp compact`、`/compact` | 随时可用 |
+
+- **subagent 同样生效**：进程内 subagent（含 continuable 与 one-shot 子代理）走同一套事件分发，压力/溢出/轮数触发对子会话独立计数、独立触发。轮数触发按 assistant message 计数，所以全程只有 1 个 turn 的 one-shot 子代理（多次工具迭代）也能触发。
+- **压缩可见性**：每次压缩成功后，会话里追加一行 `dcp: 已压缩 N 条历史（约 X tokens，触发方式）` 通知行（前端渲染为折叠行）。注意该行也会作为上下文随请求发给模型（每次压缩约 15–25 tokens），且 **0.4.0 起默认开启**；`notice: false` 可关闭。`/dcp` 的 stats 持续累计（压力触发的多次 region 提交各计一次）。
 
 ## 配置
 
@@ -98,7 +112,9 @@ npx dsh-dcp-setup                   # 安全脚本：带日期备份 → 只追
 
 | 键 | 默认 | 说明 |
 |---|---|---|
-| `thresholdRatio` | 0.7 | 触发阈值；中文场景建议 0.7 |
+| `thresholdRatio` | 0.8 | 压力触发阈值（继承上游 compaction-basic 默认 0.8；本插件 bundle patch 挂载时默认 0.7，中文场景建议 0.7） |
+| `roundInterval` | 50 | 每 N 条 assistant message（一次 LLM 往返）触发一次压缩（0 关闭）。默认 50：50、100、150……每次压缩后重数 |
+| `notice` | `true` | 压缩后在会话中追加一行通知 |
 | `language` | `zh` | 摘要语言；`zh` 额外识别中文报错和"待办：" |
 | `tokenEstimate` | `cjk` | CJK（中/日/韩/全角）按 ~2 字符/token 计价；`ascii` 与宿主一致 |
 | `dedup` | `true` | 标注重复工具调用 |
@@ -106,6 +122,8 @@ npx dsh-dcp-setup                   # 安全脚本：带日期备份 → 只追
 | `maxItems` / `maxItemChars` | 10 / 200 | 摘要密度 |
 | `maxSummaryTokens` | 2048 | 摘要 token 预算 |
 
+> **升级提示（0.5.0）**：`roundInterval` 的计数单位由 completed turn 改为 assistant message——同值下触发会更频繁（一个 turn 内往往有多条 assistant message）。
+
 ## 设计参考
 
 - [Opencode-DCP/opencode-dynamic-context-pruning](https://github.com/Opencode-DCP/opencode-dynamic-context-pruning)
@@ -114,7 +132,7 @@ npx dsh-dcp-setup                   # 安全脚本：带日期备份 → 只追
 ## 开发
 
 ```bash
-npm install && npm test     # 45 个用例：抽取/压缩/命令/配置/安装脚本
+npm install && npm test     # 65 个用例：抽取/压缩/命令/配置/触发/安装脚本
 ```
 
 ## License

package/lib/command.js

@@ -14,7 +14,7 @@ const USAGE = `Usage:
   /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)`
+                      tokenEstimate, thresholdRatio, roundInterval, notice)`
 
 const FAILURE_TEXT = Object.freeze({
   busy: 'Compaction is unavailable because this process has an active compaction, or the agent is not idle.',
@@ -63,6 +63,11 @@ function applySet(engine, key, rawValue) {
     engine.config = Object.freeze({ ...engine.config, thresholdRatio: numeric })
     return `thresholdRatio = ${numeric} (this session)`
   }
+  if (kind === 'nonnegative-integer') {
+    if (!Number.isInteger(numeric) || numeric < 0) return `${key} expects 0 or a positive integer`
+    engine.dcp[key] = numeric
+    return `${key} = ${numeric}${numeric === 0 ? ' (disabled)' : ''} (this session)`
+  }
   if (!Number.isInteger(numeric) || numeric < 1) return `${key} expects a positive integer`
   engine.dcp[key] = numeric
   return `${key} = ${numeric} (this session)`
@@ -73,9 +78,25 @@ 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}`,
+    `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} roundInterval=${engine.dcp.roundInterval}${engine.dcp.roundInterval > 0 ? '' : ' (off)'} notice=${engine.dcp.notice}`,
     `stats: ${stats.compactions} compaction${stats.compactions === 1 ? '' : 's'}, ~${stats.shadowedTokens} tokens shadowed, ${stats.compactions} LLM summary call${stats.compactions === 1 ? '' : 's'} avoided`,
   ]
+  // Per-session dimension: one compacted session per entry, in store
+  // (creation) order. Bounded to one line so a long-lived host with many
+  // compacted children never floods the status.
+  const perSession = engine.sessionStatsOverview()
+  if (perSession.length > 0) {
+    const MAX_SESSIONS = 10
+    const shown = perSession.slice(0, MAX_SESSIONS)
+    const rest = perSession.length - shown.length
+    const items = shown.map(({ id, compactions, shadowedTokens }) => {
+      const unit = compactions === 1 ? 'compaction' : 'compactions'
+      const tokens = shadowedTokens > 0 ? `, ~${shadowedTokens} tokens` : ''
+      return `${id} (${compactions} ${unit}${tokens})`
+    })
+    if (rest > 0) items.push(`+${rest} more`)
+    lines.push(`per-session: ${items.join(', ')}`)
+  }
   if (stats.lastAt !== null) lines.push(`last compaction: ${new Date(stats.lastAt).toLocaleString()}`)
   return lines.join('\n')
 }

package/lib/config.js

@@ -16,6 +16,8 @@ export const DCP_CONFIG_KEYS = [
   'language',
   'tokenEstimate',
   'protectedTools',
+  'roundInterval',
+  'notice',
 ]
 
 /** compaction-basic policy keys forwarded to the parent engine verbatim. */
@@ -41,6 +43,8 @@ const DEFAULTS = Object.freeze({
   language: 'en',
   tokenEstimate: 'cjk',
   protectedTools: Object.freeze(['write', 'edit', 'apply_patch']),
+  roundInterval: 50,
+  notice: true,
 })
 
 /**
@@ -97,6 +101,15 @@ export function resolveDcpConfig(raw = {}) {
       throw new Error('DcpConfig: protectedTools must be an array of non-empty strings')
     }
   }
+  if (raw.roundInterval !== undefined) {
+    const value = raw.roundInterval
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
+      throw new Error('DcpConfig: roundInterval must be a non-negative integer (0 disables the round trigger)')
+    }
+  }
+  if (raw.notice !== undefined && typeof raw.notice !== 'boolean') {
+    throw new Error('DcpConfig: notice must be a boolean')
+  }
   return Object.freeze({ ...DEFAULTS, ...raw })
 }
 
@@ -110,4 +123,6 @@ export const RUNTIME_SETTABLE = Object.freeze({
   language: 'language',
   tokenEstimate: 'token-estimate',
   thresholdRatio: 'ratio',
+  roundInterval: 'nonnegative-integer',
+  notice: 'boolean',
 })

package/lib/index.js

@@ -19,7 +19,8 @@
  * - id: compaction-basic
  *   name: /absolute/path/to/dsh-dcp/lib/index.js
  *   config:
- *     thresholdRatio: 0.7   # optional; every key is optional
+ *     thresholdRatio: 0.7   # optional; 0.7 = this bundle patch's mount value, package default is 0.8; every key is optional
+ *     roundInterval: 100    # optional; also compact every N assistant messages, one per LLM roundtrip (default 50)
  * ```
  *
  * @module dsh-dcp
@@ -29,8 +30,10 @@ 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 { boundContextSummary, createUserMessage } from '@deepseek-ai/dsh-llm'
+import { ManualCompactionError } from '@deepseek-ai/dsh-compaction'
 import { splitConfig, resolveDcpConfig } from './config.js'
-import { summarizeDeterministically } from './summarizer.js'
+import { summarizeDeterministically, noticeText } from './summarizer.js'
 import { registerDcpCommand } from './command.js'
 
 const require = createRequire(import.meta.url)
@@ -78,6 +81,8 @@ export class DcpEngine extends BasicCompactionEngine {
     language: z.string(),
     tokenEstimate: z.string(),
     protectedTools: z.array(z.string()),
+    roundInterval: z.number().step(1).min(0),
+    notice: z.boolean(),
   })
 
   /** Resolved dcp knobs; mutable at runtime through `/dcp set`. */
@@ -89,6 +94,35 @@ export class DcpEngine extends BasicCompactionEngine {
   /** Absolute module path, echoed by `/dcp set` for persistence snippets. */
   pluginPath
 
+  /**
+   * Completed-assistant-message counters since the last dsh-dcp compaction,
+   * per session — one "round" is one `assistant/message` (one LLM roundtrip).
+   * Weak keys: disposed sessions (including one-shot subagents) drop out with
+   * the object.
+   */
+  #rounds = new WeakMap()
+
+  /**
+   * Sessions whose next `compactNow` is a round-interval trigger rather than
+   * a manual command. Only {@link DcpEngine.#maybeRoundCompact} writes;
+   * `compactNow` reads and clears its own entry, so a stale marker can only
+   * turn a manual compaction into a labeled `'round'` one — never the reverse.
+   */
+  #triggerLabels = new WeakMap()
+
+  /** Sessions with a round-triggered compaction still in flight. */
+  #roundInFlight = new WeakSet()
+
+  /**
+   * Per-session compaction records: one entry per session that committed at
+   * least one compaction, counting the compactions and the shadowed tokens.
+   * Weak keys (mirroring `#rounds`): disposed sessions — including one-shot
+   * subagents — drop out with the object. Not enumerated directly, because a
+   * WeakMap leaks nothing and lists nothing; `/dcp` walks the sessions
+   * service and looks each live session up here.
+   */
+  #sessionStats = new WeakMap()
+
   constructor(ctx, config = {}) {
     const { basic, dcp } = splitConfig(config)
     super(ctx, basic)
@@ -99,6 +133,63 @@ export class DcpEngine extends BasicCompactionEngine {
     ctx.effect(function* () {
       yield registerDcpCommand(ctx, engine, VERSION)
     }, 'dsh-dcp /dcp command lifecycle')
+    if (this.config.auto) this.#registerRoundTrigger()
+  }
+
+  /**
+   * Round-interval trigger: count assistant messages (one per LLM roundtrip)
+   * per session and, once the configured `roundInterval` is reached, compact
+   * at the agent's next idle boundary through the manual-compaction seam
+   * (`compactNow`). In-process subagents run through the same session/event
+   * and agent/status dispatch, so continuable children are covered exactly
+   * like the top-level session — and because one-shot subagents emit many
+   * assistant messages inside a single turn, they now trigger too.
+   */
+  #registerRoundTrigger() {
+    const { ctx } = this
+    ctx.on('session/event', (session, event) => {
+      // Counting is skipped while disabled, but the listener stays registered
+      // so `/dcp set roundInterval N` can arm it again at runtime.
+      if (!this.dcp.roundInterval) return
+      // Every assembled assistant message is one completed LLM roundtrip;
+      // counting it (instead of completed turns) also covers one-shot
+      // subagents, whose whole run is a single turn with many model calls.
+      if (event.type !== 'assistant/message') return
+      this.#rounds.set(session, (this.#rounds.get(session) ?? 0) + 1)
+    })
+    ctx.on('agent/status', ({ agent, status }) => {
+      if (status === 'idle') this.#maybeRoundCompact(agent)
+    })
+  }
+
+  /**
+   * Attempt one round-triggered compaction for an idle agent. The attempt is
+   * single-flight per session. `busy` (queued waking work won the race) and
+   * `cancelled` (the agent was interrupted mid-compaction) both keep the
+   * accumulated rounds for the next idle boundary — cancelling one attempt
+   * must not cancel the N assistant messages behind it. Any other failure warns
+   * and releases the boundary: the pressure trigger remains the safety net.
+   */
+  #maybeRoundCompact(agent) {
+    const interval = this.dcp.roundInterval
+    if (!interval) return
+    const session = agent?.session
+    if (session === undefined || this.#roundInFlight.has(session)) return
+    if ((this.#rounds.get(session) ?? 0) < interval) return
+    this.#triggerLabels.set(session, 'round')
+    this.#roundInFlight.add(session)
+    const settle = () => this.#roundInFlight.delete(session)
+    const consume = () => {
+      this.#rounds.delete(session)
+      settle()
+    }
+    void this.compactNow(agent, new AbortController().signal).then(consume, (error) => {
+      if (error instanceof ManualCompactionError && (error.code === 'busy' || error.code === 'cancelled')) {
+        return settle()
+      }
+      this.ctx.logger.warn(`round-interval compaction failed: ${error instanceof Error ? error.message : String(error)}`)
+      consume()
+    })
   }
 
   /**
@@ -116,13 +207,131 @@ export class DcpEngine extends BasicCompactionEngine {
     }
   }
 
-  /** Count every committed compaction (automatic and manual) for `/dcp`. */
+  /**
+   * Automatic triggers (pressure, overflow): every committed region is
+   * recorded through `compactRegion`, and ONE notice row is emitted per
+   * trigger event — the parent's retry loop may commit several regions
+   * before landing below the threshold, and stacking a near-duplicate row
+   * per region is noise, while the stats below count each real compaction.
+   */
+  async compactIfNeeded(agent, trigger, signal) {
+    const label = trigger === 'context-overflow' ? 'overflow' : 'auto'
+    const result = await super.compactIfNeeded(agent, trigger, signal)
+    if (result !== null) this.#appendNotice(agent.session, result, label)
+    return result
+  }
+
+  /**
+   * Manual seam (`/dcp compact`, `/compact`) and this plugin's own
+   * round-interval trigger — the parent's `compactNow` bypasses
+   * `compactRegion` (it drives `compactSurfaceRegion` directly), so without
+   * this override the manual path would miss stats and the transcript notice.
+   */
+  async compactNow(agent, signal, sourceCommandId) {
+    const session = agent.session
+    const trigger = this.#triggerLabels.get(session) === 'round' ? 'round' : 'manual'
+    try {
+      const result = await super.compactNow(agent, signal, sourceCommandId)
+      // `null` means no useful range existed: release the round counter so an
+      // early-session interval boundary cannot retry every idle boundary.
+      // Manual compactions share the release: a user-driven compact restarts
+      // interval counting whether or not it found anything to compact.
+      if (result === null) this.#rounds.delete(session)
+      else this.recordCompaction(session, result, trigger)
+      return result
+    } finally {
+      this.#triggerLabels.delete(session)
+    }
+  }
+
+  /** Stats and round-counter restart for every committed region. */
   async compactRegion(start, end, agent, signal) {
     const result = await super.compactRegion(start, end, agent, signal)
+    this.#recordStats(agent.session, result)
+    return result
+  }
+
+  /**
+   * Record one committed compaction: bump the `/dcp` counters and restart the
+   * round-interval counting.
+   */
+  #recordStats(session, result) {
     this.dcpStats.compactions += 1
     this.dcpStats.shadowedTokens += result.shadowedTokenCount
     this.dcpStats.lastAt = Date.now()
-    return result
+    this.#rounds.delete(session)
+    this.#recordSessionStats(session, result.shadowedTokenCount)
+  }
+
+  /**
+   * Accumulate one committed compaction against its session. WeakMap keys
+   * must be objects, so a session-less recording (should not happen) is
+   * skipped rather than thrown on.
+   */
+  #recordSessionStats(session, shadowedTokenCount) {
+    if (session === undefined || session === null || typeof session !== 'object') return
+    const entry = this.#sessionStats.get(session) ?? { compactions: 0, shadowedTokens: 0 }
+    entry.compactions += 1
+    entry.shadowedTokens += shadowedTokenCount
+    this.#sessionStats.set(session, entry)
+  }
+
+  /**
+   * Append the one-line notice row for one committed compaction. The notice
+   * is a `notice`-form plugin message, so every dsh frontend renders it as a
+   * collapsed transcript row, live and on replay.
+   */
+  #appendNotice(session, result, trigger) {
+    if (!this.dcp.notice) return
+    const summary = boundContextSummary(noticeText(this.dcp.language, result.shadowedSeqs.length, result.shadowedTokenCount, trigger))
+    try {
+      session.append('user/message', createUserMessage({
+        content: [{ type: 'text', text: summary }],
+        source: { kind: 'plugin', plugin: 'dsh-dcp', form: 'notice', summary },
+      }))
+    } catch (error) {
+      // The compaction already committed; a display-row failure must never
+      // surface as a compaction failure.
+      const message = error instanceof Error ? error.message : String(error)
+      this.ctx.logger.warn(`dsh-dcp notice append failed: ${message}`)
+    }
+  }
+
+  /**
+   * Record stats and append the notice row for one `compactNow`-path
+   * compaction.
+   *
+   * Internal seam: `compactNow` calls it after its durable commit; tests
+   * drive it directly instead of mocking the upstream region machinery.
+   */
+  recordCompaction(session, result, trigger) {
+    this.#recordStats(session, result)
+    this.#appendNotice(session, result, trigger)
+  }
+
+  /**
+   * Per-session compaction overview for `/dcp`: one entry per live session
+   * that has recorded at least one compaction. The WeakMap is not enumerable
+   * and must never retain sessions, so this walks the sessions service and
+   * looks each live session up. Disposed sessions (including one-shot
+   * subagents) fall out of the store, and their records with them.
+   *
+   * @returns {Array<{id: string, compactions: number, shadowedTokens: number}>}
+   */
+  sessionStatsOverview() {
+    const overview = []
+    // Services live on ctx for a cordis plugin instance (`inject` only
+    // declares them); this.sessions is undefined in production.
+    for (const session of this.ctx.sessions?.list?.() ?? []) {
+      const entry = this.#sessionStats.get(session)
+      if (entry === undefined) continue
+      overview.push({
+        id: session.header?.id ?? '<unknown>',
+        compactions: entry.compactions,
+        shadowedTokens: entry.shadowedTokens,
+      })
+    }
+    return overview
   }
 }
 

package/lib/summarizer.js

@@ -132,6 +132,7 @@ const i18n = Object.freeze({
     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.',
+    notice: 'dcp: compacted {items} history items (~{tokens} tokens, {trigger})',
   }),
   zh: Object.freeze({
     none: '（无）',
@@ -141,9 +142,18 @@ const i18n = Object.freeze({
     contextNote: 'dsh-dcp 确定性压缩了 {messages} 条消息 / {calls} 次工具调用（未调用 LLM 摘要）',
     carried: '继承自上一次压缩检查点',
     terseHeader: 'dsh-dcp 确定性压缩了 {messages} 条消息（{calls} 次工具调用）。',
+    notice: 'dcp: 已压缩 {items} 条历史（约 {tokens} tokens，{trigger}）',
   }),
 })
 
+/** One-line compaction account for the transcript notice row. */
+export function noticeText(language, items, tokens, trigger = 'auto') {
+  return i18n[language]?.notice
+    .replace('{items}', String(items))
+    .replace('{tokens}', String(tokens))
+    .replace('{trigger}', trigger) ?? ''
+}
+
 /** 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()
@@ -363,6 +373,9 @@ export function extractFacts(messages, language = 'en') {
       facts.carried = parseCheckpointSections(text)
       continue
     }
+    // dsh-dcp's own compaction notices are transcript display rows: the model
+    // learns nothing from them the checkpoint below does not already carry.
+    if (message.source?.kind === 'plugin' && message.source.plugin === 'dsh-dcp') continue
     if (isInjectedContext(message)) continue
     const intentText = noticeSummary(message) ?? text
     facts.lastUserText = intentText

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwayds/dsh-dcp",
-  "version": "0.3.2",
+  "version": "0.5.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",
@@ -20,7 +20,6 @@
     "README.md",
     "README.en.md",
     "LICENSE",
-    "cordis.patch.example.yml",
     "cordis.patch.yml"
   ],
   "scripts": {

package/cordis.patch.example.yml

@@ -1,19 +0,0 @@
-# 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