@aiwayds/dsh-dcp 0.4.0 → 0.5.0

package/README.en.md

@@ -115,16 +115,23 @@ Settable: `dedup`, `purgeErrors`, `maxItems`, `maxItemChars`,
 `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` (default 0.7) × context window, inherited |
+| 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` completed turns | added by this plugin; one round = one successfully completed turn. **Default 50**: first compaction at turn 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` |
+| **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 children) dispatch through the same events, so pressure/overflow/round triggers count and fire per child session independently.
+- **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
@@ -133,8 +140,8 @@ All optional, defaults work out of the box:
 
 | Key | Default | Meaning |
 |---|---|---|
-| `thresholdRatio` | 0.7 | pressure trigger; 0.7 recommended for CJK-heavy sessions |
-| `roundInterval` | 50 | compact every N completed turns (0 disables). Default 50: 50, 100, 150… — the clock restarts after every compaction |
+| `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 |
@@ -143,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)
@@ -151,7 +160,7 @@ All optional, defaults work out of the box:
 ## Development
 
 ```bash
-npm install && npm test     # 61 tests: extractor/compaction/command/config/triggers/setup
+npm install && npm test     # 65 tests: extractor/compaction/command/config/triggers/setup
 ```
 
 ## License

package/README.md

@@ -92,16 +92,18 @@ npx dsh-dcp-setup                   # 安全脚本：带日期备份 → 只追
 
 可调键：`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.7）× 上下文窗口，继承官方 |
+| 压力触发 | 每步请求前 | token ≥ `thresholdRatio`（继承上游默认 0.8；本插件 bundle 挂载默认 0.7，见配置表）× 上下文窗口 |
 | 溢出恢复 | 模型报 context 超限时 | 继承官方 |
-| **轮数触发** | 会话每完成 `roundInterval` 轮 | 本插件新增；一轮 = 一次正常完成的 turn。**默认 50**：第 50 轮触发第一次，之后每 50 轮一次（100、150……）；任何一次压缩（含压力触发）都会重置轮数时钟。到达轮数后的第一个空闲点触发（阈值之下也压）。`0` 关闭；需保持 `auto: true`（默认开） |
+| **轮数触发** | 会话每收到 `roundInterval` 条 assistant message | 本插件新增；一条 = 一次 LLM 往返（每轮工具迭代各算一条，one-shot 子代理也能触发）。**默认 50**：第 50 条后触发第一次，之后每 50 条一次（100、150……）；任何一次压缩（含压力触发）都会重置轮数时钟。到达条数后的第一个空闲点触发（阈值之下也压）。`0` 关闭；需保持 `auto: true`（默认开） |
 | 手动 | `/dcp compact`、`/compact` | 随时可用 |
 
-- **subagent 同样生效**：进程内 subagent（含 continuable 子代理）走同一套事件分发，压力/溢出/轮数触发对子会话独立计数、独立触发。
+- **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 提交各计一次）。
 
 ## 配置
@@ -110,8 +112,8 @@ npx dsh-dcp-setup                   # 安全脚本：带日期备份 → 只追
 
 | 键 | 默认 | 说明 |
 |---|---|---|
-| `thresholdRatio` | 0.7 | 压力触发阈值；中文场景建议 0.7 |
-| `roundInterval` | 50 | 每 N 轮触发一次压缩（0 关闭）。默认 50：50、100、150……每次压缩后重数 |
+| `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` 与宿主一致 |
@@ -120,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)
@@ -128,7 +132,7 @@ npx dsh-dcp-setup                   # 安全脚本：带日期备份 → 只追
 ## 开发
 
 ```bash
-npm install && npm test     # 61 个用例：抽取/压缩/命令/配置/触发/安装脚本
+npm install && npm test     # 65 个用例：抽取/压缩/命令/配置/触发/安装脚本
 ```
 
 ## License

package/lib/command.js

@@ -81,6 +81,22 @@ function statusText(engine, version) {
     `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/index.js

@@ -19,8 +19,8 @@
  * - id: compaction-basic
  *   name: /absolute/path/to/dsh-dcp/lib/index.js
  *   config:
- *     thresholdRatio: 0.7   # optional; every key is optional
- *     roundInterval: 100    # optional; also compact every N completed turns (default 50)
+ *     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
@@ -95,9 +95,10 @@ export class DcpEngine extends BasicCompactionEngine {
   pluginPath
 
   /**
-   * Completed-turn counters since the last dsh-dcp compaction, per session —
-   * one "round" is one `turn/end` whose reason is `completed`. Weak keys:
-   * disposed sessions (including one-shot subagents) drop out with the object.
+   * 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()
 
@@ -112,6 +113,16 @@ export class DcpEngine extends BasicCompactionEngine {
   /** 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)
@@ -126,11 +137,13 @@ export class DcpEngine extends BasicCompactionEngine {
   }
 
   /**
-   * Round-interval trigger: count completed turns 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.
+   * 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
@@ -138,7 +151,10 @@ export class DcpEngine extends BasicCompactionEngine {
       // 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
-      if (event.type !== 'turn/end' || event.data.reason?.kind !== 'completed') 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 }) => {
@@ -151,7 +167,7 @@ export class DcpEngine extends BasicCompactionEngine {
    * 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 completed turns behind it. Any other failure warns
+   * 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) {
@@ -244,6 +260,20 @@ export class DcpEngine extends BasicCompactionEngine {
     this.dcpStats.shadowedTokens += result.shadowedTokenCount
     this.dcpStats.lastAt = Date.now()
     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)
   }
 
   /**
@@ -278,6 +308,31 @@ export class DcpEngine extends BasicCompactionEngine {
     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
+  }
 }
 
 export default DcpEngine

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwayds/dsh-dcp",
-  "version": "0.4.0",
+  "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",