@aiwayds/dsh-dcp 0.4.0 → 0.5.1

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
@@ -39,6 +39,28 @@ import { registerDcpCommand } from './command.js'
 const require = createRequire(import.meta.url)
 const { version: VERSION } = require('../package.json')
 
+/**
+ * Per-engine state uses module-scoped symbol keys, never `#private` members.
+ * Cordis hands services to consuming fibers through derived receivers —
+ * `ctx.mixin` binds methods to a withProps proxy and `createTraceable` calls
+ * them on Object.create-derived shadows — so `/compact` and `/dcp compact`
+ * (both `ctx.compaction.compactNow(...)`) routinely execute engine methods
+ * with a `this` this class's constructor never initialized. Private members
+ * brand-check against exactly that and throw
+ * "Cannot read private member #triggerLabels from an object whose class did
+ * not declare it", while symbol lookups traverse those receivers to this
+ * instance's own state.
+ */
+const kRounds = Symbol('dsh-dcp.rounds')
+const kTriggerLabels = Symbol('dsh-dcp.triggerLabels')
+const kRoundInFlight = Symbol('dsh-dcp.roundInFlight')
+const kSessionStats = Symbol('dsh-dcp.sessionStats')
+const kRegisterRoundTrigger = Symbol('dsh-dcp.registerRoundTrigger')
+const kMaybeRoundCompact = Symbol('dsh-dcp.maybeRoundCompact')
+const kRecordStats = Symbol('dsh-dcp.recordStats')
+const kRecordSessionStats = Symbol('dsh-dcp.recordSessionStats')
+const kAppendNotice = Symbol('dsh-dcp.appendNotice')
+
 /**
  * Deterministic compaction engine: `summarize()` overridden, everything else
  * inherited. Registers the `/dcp` command beside the inherited `/compact`.
@@ -94,27 +116,20 @@ export class DcpEngine extends BasicCompactionEngine {
   /** Absolute module path, echoed by `/dcp set` for persistence snippets. */
   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.
-   */
-  #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()
-
   constructor(ctx, config = {}) {
     const { basic, dcp } = splitConfig(config)
     super(ctx, basic)
+    // Constructor assignments, not class fields: Node 26's V8 silently drops
+    // every symbol-keyed class field after the first one in a derived class
+    // (plain string-keyed and base-class fields are unaffected).
+    /** Per-session assistant-message counters since the last dsh-dcp compaction. */
+    this[kRounds] = new WeakMap()
+    /** Sessions whose next `compactNow` is a round-interval trigger, not manual. */
+    this[kTriggerLabels] = new WeakMap()
+    /** Sessions with a round-triggered compaction still in flight. */
+    this[kRoundInFlight] = new WeakSet()
+    /** Per-session compaction records for `/dcp` (weak so disposed sessions drop out). */
+    this[kSessionStats] = new WeakMap()
     this.dcp = { ...resolveDcpConfig(dcp) }
     this.dcpStats = { compactions: 0, shadowedTokens: 0, lastAt: null }
     this.pluginPath = fileURLToPath(import.meta.url)
@@ -122,27 +137,32 @@ export class DcpEngine extends BasicCompactionEngine {
     ctx.effect(function* () {
       yield registerDcpCommand(ctx, engine, VERSION)
     }, 'dsh-dcp /dcp command lifecycle')
-    if (this.config.auto) this.#registerRoundTrigger()
+    if (this.config.auto) this[kRegisterRoundTrigger]()
   }
 
   /**
-   * 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() {
+  [kRegisterRoundTrigger]() {
     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
-      if (event.type !== 'turn/end' || event.data.reason?.kind !== 'completed') return
-      this.#rounds.set(session, (this.#rounds.get(session) ?? 0) + 1)
+      // 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[kRounds].set(session, (this[kRounds].get(session) ?? 0) + 1)
     })
     ctx.on('agent/status', ({ agent, status }) => {
-      if (status === 'idle') this.#maybeRoundCompact(agent)
+      if (status === 'idle') this[kMaybeRoundCompact](agent)
     })
   }
 
@@ -151,20 +171,20 @@ 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) {
+  [kMaybeRoundCompact](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)
+    if (session === undefined || this[kRoundInFlight].has(session)) return
+    if ((this[kRounds].get(session) ?? 0) < interval) return
+    this[kTriggerLabels].set(session, 'round')
+    this[kRoundInFlight].add(session)
+    const settle = () => this[kRoundInFlight].delete(session)
     const consume = () => {
-      this.#rounds.delete(session)
+      this[kRounds].delete(session)
       settle()
     }
     void this.compactNow(agent, new AbortController().signal).then(consume, (error) => {
@@ -201,7 +221,7 @@ export class DcpEngine extends BasicCompactionEngine {
   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)
+    if (result !== null) this[kAppendNotice](agent.session, result, label)
     return result
   }
 
@@ -213,25 +233,25 @@ export class DcpEngine extends BasicCompactionEngine {
    */
   async compactNow(agent, signal, sourceCommandId) {
     const session = agent.session
-    const trigger = this.#triggerLabels.get(session) === 'round' ? 'round' : 'manual'
+    const trigger = this[kTriggerLabels].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)
+      if (result === null) this[kRounds].delete(session)
       else this.recordCompaction(session, result, trigger)
       return result
     } finally {
-      this.#triggerLabels.delete(session)
+      this[kTriggerLabels].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)
+    this[kRecordStats](agent.session, result)
     return result
   }
 
@@ -239,11 +259,25 @@ export class DcpEngine extends BasicCompactionEngine {
    * Record one committed compaction: bump the `/dcp` counters and restart the
    * round-interval counting.
    */
-  #recordStats(session, result) {
+  [kRecordStats](session, result) {
     this.dcpStats.compactions += 1
     this.dcpStats.shadowedTokens += result.shadowedTokenCount
     this.dcpStats.lastAt = Date.now()
-    this.#rounds.delete(session)
+    this[kRounds].delete(session)
+    this[kRecordSessionStats](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.
+   */
+  [kRecordSessionStats](session, shadowedTokenCount) {
+    if (session === undefined || session === null || typeof session !== 'object') return
+    const entry = this[kSessionStats].get(session) ?? { compactions: 0, shadowedTokens: 0 }
+    entry.compactions += 1
+    entry.shadowedTokens += shadowedTokenCount
+    this[kSessionStats].set(session, entry)
   }
 
   /**
@@ -251,7 +285,7 @@ export class DcpEngine extends BasicCompactionEngine {
    * 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) {
+  [kAppendNotice](session, result, trigger) {
     if (!this.dcp.notice) return
     const summary = boundContextSummary(noticeText(this.dcp.language, result.shadowedSeqs.length, result.shadowedTokenCount, trigger))
     try {
@@ -273,10 +307,36 @@ export class DcpEngine extends BasicCompactionEngine {
    *
    * Internal seam: `compactNow` calls it after its durable commit; tests
    * drive it directly instead of mocking the upstream region machinery.
+   * Public-named but not part of the dsh compaction contract.
    */
   recordCompaction(session, result, trigger) {
-    this.#recordStats(session, result)
-    this.#appendNotice(session, result, trigger)
+    this[kRecordStats](session, result)
+    this[kAppendNotice](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[kSessionStats].get(session)
+      if (entry === undefined) continue
+      overview.push({
+        id: session.header?.id ?? '<unknown>',
+        compactions: entry.compactions,
+        shadowedTokens: entry.shadowedTokens,
+      })
+    }
+    return overview
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwayds/dsh-dcp",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "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",
@@ -62,18 +62,42 @@
     "@deepseek-ai/schemastery": "^3.18.1"
   },
   "peerDependenciesMeta": {
-    "@deepseek-ai/cordis": { "optional": true },
-    "@deepseek-ai/dsh-agent": { "optional": true },
-    "@deepseek-ai/dsh-brand": { "optional": true },
-    "@deepseek-ai/dsh-commands": { "optional": true },
-    "@deepseek-ai/dsh-compaction": { "optional": true },
-    "@deepseek-ai/dsh-compaction-basic": { "optional": true },
-    "@deepseek-ai/dsh-compaction-tool-result-pruner": { "optional": true },
-    "@deepseek-ai/dsh-invariants": { "optional": true },
-    "@deepseek-ai/dsh-llm": { "optional": true },
-    "@deepseek-ai/dsh-session": { "optional": true },
-    "@deepseek-ai/dsh-token-meter": { "optional": true },
-    "@deepseek-ai/schemastery": { "optional": true }
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-agent": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-brand": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-commands": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-compaction": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-compaction-basic": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-compaction-tool-result-pruner": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-invariants": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-token-meter": {
+      "optional": true
+    },
+    "@deepseek-ai/schemastery": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",