@fishwithcat/dsh-tool-todo 0.0.0-stage → 0.2.2-alpha.3

package/README.i18n.yaml

@@ -0,0 +1,88 @@
+# Bilingual-pair consistency record for README.md (docs/i18n/README.md): per heading
+# section, a hash of its English and Chinese blocks outside code blocks and generated regions.
+# After editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/todo/tool-todo/README.md
+/:
+  en: 94e53ef3423c197f
+  zh: ad579992506261fa
+/deepseek-ai-dsh-tool-todo:
+  en: 06114b7b88112609
+  zh: a53c75adeeecf917
+/deepseek-ai-dsh-tool-todo/summary:
+  en: b6b3f4e412f33da2
+  zh: b4dbbe1a1e093179
+/deepseek-ai-dsh-tool-todo/table-of-contents:
+  en: d152484eb41ac6b4
+  zh: 09388d293f9be9cb
+/deepseek-ai-dsh-tool-todo/use-this-package:
+  en: d10c650faab8695d
+  zh: 6018b5a53501d88b
+/deepseek-ai-dsh-tool-todo/use-this-package/when-to-choose-it:
+  en: c964ee10289fcd21
+  zh: 4c1e68220906eb06
+/deepseek-ai-dsh-tool-todo/use-this-package/minimal-configuration:
+  en: 02ee43b537f8ab85
+  zh: a20116a4fcc36a33
+/deepseek-ai-dsh-tool-todo/use-this-package/what-each-call-does:
+  en: 96e2488d0a5b8f96
+  zh: abc33a2f87f539dc
+/deepseek-ai-dsh-tool-todo/use-this-package/single-owner:
+  en: f051cbd97dab2436
+  zh: 18976a8affed8cab
+/deepseek-ai-dsh-tool-todo/understand-the-implementation:
+  en: 8d94a7381bca3fa9
+  zh: f4bd2866fff6fa8d
+/deepseek-ai-dsh-tool-todo/understand-the-implementation/design-philosophy:
+  en: e9cf462797eaf9f2
+  zh: 02d9a7fce90936c3
+/deepseek-ai-dsh-tool-todo/understand-the-implementation/source-map:
+  en: 51328ad8c7fcbfd0
+  zh: 2614ec42b61ff3ef
+/deepseek-ai-dsh-tool-todo/understand-the-implementation/export-shape:
+  en: 35b4f6c718e60dab
+  zh: 9bffe86c88a7ad6d
+/deepseek-ai-dsh-tool-todo/understand-the-implementation/session-projection:
+  en: 2d49c8af46b16dd2
+  zh: 71a3073433b579d4
+/deepseek-ai-dsh-tool-todo/understand-the-implementation/call-mechanics:
+  en: d55f6a32b05ed686
+  zh: c815f930a2acebda
+/deepseek-ai-dsh-tool-todo/further-exploration:
+  en: 38488722b03c25dd
+  zh: 23efe2cce1e29917
+/deepseek-ai-dsh-tool-todo/model-experience:
+  en: 215e7ba838619b7b
+  zh: a311da3843709f90
+/deepseek-ai-dsh-tool-todo/model-experience/tool-schema:
+  en: e4c7376d4f29dbd5
+  zh: 6b7a9eaf69c9ea53
+/deepseek-ai-dsh-tool-todo/model-experience/tool-schema/what-the-model-sees:
+  en: 1d761e1652e9fc94
+  zh: f847760856f74c8b
+/deepseek-ai-dsh-tool-todo/model-experience/tool-schema/token-effect:
+  en: a0a8f5ec3db0f500
+  zh: eac37a524c6e777e
+/deepseek-ai-dsh-tool-todo/model-experience/tool-schema/kv-cache-effect:
+  en: b385b04c94496e5b
+  zh: 3a361ac90ef5f037
+/deepseek-ai-dsh-tool-todo/model-experience/tool-call-history-and-result:
+  en: 9717b983b6a857e3
+  zh: 611a2dadf7c0c706
+/deepseek-ai-dsh-tool-todo/model-experience/tool-call-history-and-result/what-the-model-sees:
+  en: 05644654d1bce8c6
+  zh: ea2a42470fbb2ee1
+/deepseek-ai-dsh-tool-todo/model-experience/tool-call-history-and-result/token-effect:
+  en: 7763a0e875faf53d
+  zh: fe33c3973215dc53
+/deepseek-ai-dsh-tool-todo/model-experience/tool-call-history-and-result/kv-cache-effect:
+  en: f5d5f97a153f7c70
+  zh: a5411047e008a0c1
+/deepseek-ai-dsh-tool-todo/known-limitations-and-deferred-work:
+  en: 71e2aed21b2545c3
+  zh: 775300a3618a861a
+/deepseek-ai-dsh-tool-todo/known-limitations-and-deferred-work/dev-note:
+  en: ac1d08360a93382b
+  zh: 703a65fbcc38edc7
+/deepseek-ai-dsh-tool-todo/known-limitations-and-deferred-work/dev-note/future-cross-agent-and-shared-lists:
+  en: 071b9c5be71f799f
+  zh: dee15fe922a3ab95

package/README.md

@@ -1,3 +1,171 @@
-# Temporary Holding Version
+---
+description: "The model-facing todo_write tool over the DeepSeek Harness session log: whole-list replacement, per-session ownership, and the todos projection, for users and maintainers choosing, configuring, or debugging the tool."
+kind: "package-reference"
+---
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @deepseek-ai/dsh-tool-todo
+
+English | [中文](README.zh.md)
+
+## Summary
+
+`dsh-tool-todo` gives the agent a structured task list to plan with: break multi-step work into concrete tasks, mark the task you are working on, and check tasks off as they finish. The list survives across turns and reopened sessions, so the agent and the UI always see the latest plan. One configuration flag decides whether several tasks may be in progress at once, for agents that run work in parallel. Use it wherever an agent should keep a visible task list; each update replaces the whole list, and only the owning agent session can change it.
+
+## Table of Contents
+
+- [Use this package](#use-this-package)
+- [Understand the implementation](#understand-the-implementation)
+- [Further Exploration](#further-exploration)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## Use this package
+
+Use this package when you want the agent to maintain a visible task list while it works: plan multi-step work, show what is active, and record completion. Mounting it with the parallelism flag is the only setup; the agent then updates the list through its own planning tool whenever the plan changes.
+
+### When to choose it
+
+Choose it when one agent session should own the task list and whole-list updates are fine — the common shape for planning tools. Avoid it when several agents must share one list or when you need per-item edits: the list belongs to one agent and every update replaces the whole list. It needs an agent session to exist at all; automation-only surfaces that never run an agent cannot use it.
+
+### Minimal configuration
+
+`allowParallelInProgress` is required with no default: a composition that omits it fails at load, and a non-boolean value is rejected. Set `true` for agents that may run work concurrently (subagents, background commands, workflow fan-out) and `false` for the single-active discipline.
+
+```yaml
+- name: '@deepseek-ai/dsh-tool-todo'
+  config:
+    allowParallelInProgress: true
+```
+
+| Field | Default | Meaning |
+|---|---|---|
+| `allowParallelInProgress` | required | Whether several todos may be `in_progress` at once; also selects the active-status clause of the model description |
+
+The generated [configuration catalog](../../../docs/config-catalog.md#deepseek-aidsh-tool-todo) is the exhaustive source for the accepted field.
+
+### What each call does
+
+The agent sends the ENTIRE list on every update; the new list replaces the previous one, so there are no partial updates or per-item edits. Each item is a short task description plus a status of `pending`, `in_progress`, or `completed`. A successful update returns the new counts — `Updated todo list: <pending> pending, <inProgress> in progress, <completed> completed.` — and the UI shows the new plan. The terminal surface draws that plan as a checklist — the completed/total count in the card title and one `☐`/`◐`/`☑`-marked line per task, instead of the raw argument JSON. Updates fail visibly when a task description is empty or duplicated, when an item carries fields beyond the description and status, or — when parallel work is disabled — when more than one task is marked in progress.
+
+### Single owner
+
+The task list belongs to the one agent session that created it — subagents and other agents each keep their own list, and there is no way to share a list between agents. A call from outside an agent session is rejected, so the agent learns the update failed instead of silently writing nowhere. If you need a list shared across agents, this package does not provide it.
+
+-----
+
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+
+<details>
+<summary>Implementation internals — click to expand</summary>
+
+This section explains the design decisions behind the tool and points at the code that realizes them; the observable behavior is fully covered in [Use this package](#use-this-package).
+
+### Design philosophy
+
+The tool is built on four commitments:
+
+- **Whole-list replace, log-backed state.** The model resends the entire list; the `todo/write` snapshot lives on the event-sourced session log, so durability, replay, and resume reconstruction come from the log rather than a service.
+- **Single owner.** The list belongs to the calling agent session; there is no shared or swarm scope, and non-agent callers are rejected.
+- **Deployment policy, not a coded rule.** `allowParallelInProgress` is a required composition choice because the tool cannot observe runtime concurrency.
+- **Validation keeps the logged snapshot honest.** Schema-level rejection of unknown keys and `execute`-level rejection of empty or duplicate content keep the durable snapshot equal to what the model believes it wrote.
+
+The [todo_write tool Agent Note](../../../.agents/notes/archived/feature/2026-06-29-todo-write-tool.md) records the original design and alternatives; the [parallel in-progress Agent Note](../../../.agents/notes/archived/feature/2026-07-26-todo-parallel-in-progress.md) records the policy decision.
+
+### Source map
+
+| File | Role |
+|---|---|
+| [`src/index.ts`](src/index.ts) | Plugin entry: `Config` schema, tool registration, `todos` projection unit |
+| [`src/types.ts`](src/types.ts) | The one home of the `todos` projection-key declaration and its payload types |
+| [`src/client.ts`](src/client.ts) | Client-namespace re-export of the types outlet |
+
+### Export shape
+
+The plugin is a function/namespace plugin: it exports `name` / `inject` / `apply` and no default export. A stray `export default` would make the Loader's `unwrapExports` collapse the module and drop `inject` (see [postmortem 0001](../../../docs/postmortem/0001-acp-default-export-drops-inject.md)).
+
+### Session projection
+
+When the composition mounts `ctx.sessionProjections` ([`@deepseek-ai/dsh-session-projection`](../../session/session-projection/README.md)), this package registers the `todos` unit on an injected child: the projection is the standing plan — the latest whole `todo/write` list, `null` before the first write, cleared when the next turn starts while `turn/end` keeps the finished checklist visible. The key merges into `SessionProjectionMap` here; carriers serve the value on the history tail page and the `session/projection` push frame. Compositions without the registry are unaffected; see [src/index.ts](src/index.ts) for the unit registration.
+
+### Call mechanics
+
+Each call validates the submitted list against the schema, rejects incoherent input, and on success appends the full snapshot as a `todo/write` session event and returns the new counts; the current list is always the most recent `todo/write` in the log (last-write-wins on replay). See [src/index.ts](src/index.ts) for the exact validation and append steps.
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+Read these pages when the package-level contract is not enough. They move from the session subsystem to the generated catalogs and the decision records behind the tool.
+
+- [Todo subsystem](../../../docs/subsystems/todo.md) — the `todo/write` event payload, ownership rules, and `TodoItem`.
+- [todo group map](../README.md) — the sibling group page and its package table.
+- [Generated tool catalog](../../../docs/tool-catalog.md#deepseek-aidsh-tool-todo) — the `todo_write` schema the model receives.
+- [Generated configuration catalog](../../../docs/config-catalog.md#deepseek-aidsh-tool-todo) — every accepted config field and its source declaration.
+- [todo_write tool Agent Note](../../../.agents/notes/archived/feature/2026-06-29-todo-write-tool.md) — the original design, alternatives, and dropped fields.
+- [parallel in-progress Agent Note](../../../.agents/notes/archived/feature/2026-07-26-todo-parallel-in-progress.md) — why the active-count cap is a deployment policy.
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+### Tool schema
+
+#### What the model sees
+
+The model sees the generated [`todo_write` schema](../../../docs/tool-catalog.md#deepseek-aidsh-tool-todo): an object with one required `todos` array of `{ content, status }` items, where `status` is `pending`, `in_progress`, or `completed`. The `todos` description states that each call replaces the whole list; the tool description's active-status clause follows `allowParallelInProgress`.
+
+#### Token effect
+
+Fixed schema cost on every request where the tool is visible; the description and schema are stable for a given configuration.
+
+#### KV Cache effect
+
+Prefix-stable while the definition and visibility are unchanged. Plugin lifecycle or scoped restrictions may invalidate reuse from this schema.
+
+### Tool-call history and result
+
+#### What the model sees
+
+Each assistant tool call retains the entire replacement list in its arguments. Success returns exactly `Updated todo list: <pending> pending, <inProgress> in progress, <completed> completed.` Stable failures are ``Error: invalid todo: `content` must be a non-empty string``, `Error: invalid todos: duplicate content "<content>"`, `Error: todo_write requires an owning agent session`, and — only where the deployment set `allowParallelInProgress: false` — `Error: invalid todos: at most one task may be in_progress (got <n>)`. The full `todo/write` session event is UI and replay state, not a second model message.
+
+#### Token effect
+
+Token growth scales with every full list the model submits, and those call arguments remain until compaction. The result itself is small and fixed-shape.
+
+#### KV Cache effect
+
+Append-only; newly visible content follows the reusable request prefix and does not invalidate existing KV-cache entries.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+These limits define when the tool is a poor fit. They are current package constraints, not a task backlog.
+
+- **Single-owner scope only** — the list belongs to the one calling agent session; subagent, shared, and swarm scopes are a deliberate cut, and a non-agent caller is rejected.
+- **The item shape is deliberately minimal** — `content` plus three-state `status`; whole-list replacement needs no stable id, priority, or active-form fields.
+- **Whole-list replacement is the only operation** — no partial updates, no read-back tool, and no per-item edits; the model must resend the entire list each call.
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+This Dev Note is working context for maintainers: open questions and directions that are not decided. It is explicitly non-authoritative — shipped behavior, limits, and accepted rationale live in the sections above, the package code, and the linked Agent Notes.
+
+#### Future: cross-agent and shared lists
+
+The single-owner scope is a deliberate cut, and cross-agent or shared lists remain a separate future design: they would need per-item log deltas and explicit scope selection, and would change the model-visible contract. No design exists yet.
+
+</details>

package/README.zh.md

@@ -0,0 +1,171 @@
+---
+description: "面向 DeepSeek Harness 会话日志的模型侧 todo_write 工具：整表替换、单一会话归属与 todos 投影，供选择、配置或排查该工具的用户与维护者阅读。"
+kind: "package-reference"
+---
+
+# @deepseek-ai/dsh-tool-todo
+
+[English](README.md) | 中文
+
+## 概述
+
+`dsh-tool-todo` 为 agent（智能体）提供一份可用于规划的结构化任务列表：把多步工作拆成具体任务、标记正在进行的任务、完成后逐项勾掉。列表跨轮次、跨重新打开的会话持续存在，agent 与 UI 始终看到最新计划。一个配置开关决定是否允许多个任务同时处于进行中，适用于并行开展工作的 agent。凡是希望 agent 维护可见任务列表的场景都可以使用它；每次更新整体替换列表，只有拥有该列表的 agent 会话才能修改。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
+
+当你希望 agent 在工作时维护一份可见的任务列表时使用本包：规划多步工作、展示当前进行中的任务、记录完成情况。挂载它并设置并行开关是唯一的配置步骤；此后每次计划变化，agent 都会通过它自己的规划工具更新列表。
+
+### 何时选择
+
+当某个 agent 会话应当拥有任务列表、且整表更新即可满足需求时选择它——这是规划工具的常见形态。当多个 agent 必须共享同一份列表、或需要逐项编辑时，请避开：列表只属于一个 agent，每次更新都会替换整个列表。它要求环境中确实存在 agent 会话；从不运行 agent 的纯自动化入口无法使用它。
+
+### 最小配置
+
+`allowParallelInProgress` 是必填项、没有默认值：省略它的组合会在加载时失败，非布尔值也会被拒绝。可能并发运行工作的 agent（subagent、后台命令、工作流扇出）设为 `true`，需要单活跃项纪律的设为 `false`。
+
+```yaml
+- name: '@deepseek-ai/dsh-tool-todo'
+  config:
+    allowParallelInProgress: true
+```
+
+| 字段 | 默认值 | 含义 |
+|---|---|---|
+| `allowParallelInProgress` | 必填 | 是否允许多个 todo 同时处于 `in_progress`；同时选择模型描述中的活跃状态条款 |
+
+生成的[配置目录](../../../docs/config-catalog.zh.md#deepseek-aidsh-tool-todo)是每个受支持字段的穷尽式真源。
+
+### 每次调用做什么
+
+agent 每次更新都发送完整列表；新列表替换旧列表，因此没有部分更新或逐项编辑。每个条目是一句简短的任务描述，外加 `pending`、`in_progress` 或 `completed` 状态。成功的更新会返回新的计数——`Updated todo list: <pending> pending, <inProgress> in progress, <completed> completed.`——UI 随即展示新计划。终端界面会把该计划画成清单——卡片标题给出已完成/总数，每个任务一行并以 `☐`/`◐`/`☑` 标记状态，而不是展示原始参数 JSON。任务描述为空或重复、条目带有描述与状态之外的字段、或（禁用并行时）多个任务被标记为进行中，这些情况下更新都会明确失败。
+
+### 单一所有者
+
+任务列表属于创建它的那一个 agent 会话——subagent 与其他 agent 各自维护自己的列表，不存在跨 agent 共享列表的方式。来自 agent 会话之外的调用会被拒绝，因此 agent 会得知更新失败，而不是被静默丢弃。如果你需要多个 agent 共享同一份列表，本包不提供该能力。
+
+-----
+
+<a id="understand-the-implementation"></a>
+## 理解实现
+
+<details>
+<summary>实现细节——点击展开</summary>
+
+本节解释工具背后的设计决策，并指出实现它们的代码位置；可观察行为已在[使用本包](#use-this-package)中完整说明。
+
+### 设计理念
+
+本工具建立在四项承诺之上：
+
+- **整表替换、日志承载状态。** 模型重新发送整个列表；`todo/write` 快照存放在事件溯源的会话日志上，持久性、回放与恢复重建都来自日志而非服务。
+- **单一所有者。** 列表属于调用 agent 会话；不存在共享或 swarm 作用域，非 agent 调用方会被拒绝。
+- **部署策略，而非编码规则。** `allowParallelInProgress` 是必填组合选择，因为工具无法观测运行时并发。
+- **校验确保日志快照如实反映输入。** schema 层拒绝未知键、`execute` 层拒绝空或重复 content，使持久快照与模型自认为写入的内容一致。
+
+[todo_write 工具 Agent Note](../../../.agents/notes/archived/feature/2026-06-29-todo-write-tool.md) 记录原始设计与备选方案；[并行 in-progress Agent Note](../../../.agents/notes/archived/feature/2026-07-26-todo-parallel-in-progress.md) 记录该策略决策。
+
+### 源码地图
+
+| 文件 | 职责 |
+|---|---|
+| [`src/index.ts`](src/index.ts) | 插件入口：`Config` schema、工具注册、`todos` 投影单元 |
+| [`src/types.ts`](src/types.ts) | `todos` 投影键声明及其载荷类型的唯一归属地 |
+| [`src/client.ts`](src/client.ts) | 客户端命名空间对类型出口的再导出 |
+
+### 导出形状
+
+本插件是函数／命名空间插件：导出 `name`、`inject`、`apply`，没有默认导出。多余的 `export default` 会让 Loader 的 `unwrapExports` 折叠模块并丢弃 `inject`（参见 [postmortem 0001](../../../docs/postmortem/0001-acp-default-export-drops-inject.zh.md)）。
+
+### 会话投影
+
+当组合挂载 `ctx.sessionProjections`（[`@deepseek-ai/dsh-session-projection`](../../session/session-projection/README.zh.md)）时，本包在注入的子插件中注册 `todos` 单元：投影即有效计划——最新的整份 `todo/write` 列表，首次写入前为 `null`，下一轮次开始时清空，而 `turn/end` 保留刚完成的清单。该键在此处合并进 `SessionProjectionMap`；载体通过历史尾页与 `session/projection` 推送帧提供该值。未挂载注册表的组合不受影响；单元注册见 [src/index.ts](src/index.ts)。
+
+### 调用机制
+
+每次调用都会先校验提交的列表是否符合 schema，拒绝不一致的输入，成功后把完整快照作为 `todo/write` 会话事件追加并返回新的计数；当前列表始终是日志中最近一次 `todo/write`（回放时后写覆盖先写）。确切的校验与追加步骤见 [src/index.ts](src/index.ts)。
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+当包级约定不够用时阅读以下页面。它们从会话子系统逐步进入生成的目录，以及工具背后的决策记录。
+
+- [Todo 子系统](../../../docs/subsystems/todo.zh.md)——`todo/write` 事件载荷、归属规则与 `TodoItem`。
+- [todo 组映射](../README.zh.md)——同级组页面及其包表格。
+- [生成的工具目录](../../../docs/tool-catalog.zh.md#deepseek-aidsh-tool-todo)——模型接收的 `todo_write` schema。
+- [生成的配置目录](../../../docs/config-catalog.zh.md#deepseek-aidsh-tool-todo)——每个受支持配置字段及其源声明。
+- [todo_write 工具 Agent Note](../../../.agents/notes/archived/feature/2026-06-29-todo-write-tool.md)——原始设计、备选方案与未采纳的字段。
+- [并行 in-progress Agent Note](../../../.agents/notes/archived/feature/2026-07-26-todo-parallel-in-progress.md)——为何活跃计数上限成为部署策略。
+
+-----
+
+<a id="model-experience"></a>
+## 模型体验
+
+### 工具 schema
+
+#### 模型看到什么
+
+模型会看到生成的 [`todo_write` schema](../../../docs/tool-catalog.zh.md#deepseek-aidsh-tool-todo)：一个对象，含一个必填的 `todos` 数组，元素为 `{ content, status }`，其中 `status` 为 `pending`、`in_progress` 或 `completed`。`todos` 描述说明每次调用都会替换整个列表；工具描述中的活跃状态条款跟随 `allowParallelInProgress`。
+
+#### Token 影响
+
+工具可见的每个请求都有固定 schema 开销；在给定配置下描述与 schema 保持稳定。
+
+#### KV Cache 影响
+
+定义与可见性不变时前缀保持稳定。插件生命周期或作用域限制可能使从此 schema 起的复用失效。
+
+### 工具调用历史与结果
+
+#### 模型看到什么
+
+每次 assistant 工具调用都会在参数中保留整个替换列表。成功时原样返回 `Updated todo list: <pending> pending, <inProgress> in progress, <completed> completed.`。稳定失败文本为 ``Error: invalid todo: `content` must be a non-empty string``、`Error: invalid todos: duplicate content "<content>"`、`Error: todo_write requires an owning agent session`，以及——仅在部署设置 `allowParallelInProgress: false` 时——`Error: invalid todos: at most one task may be in_progress (got <n>)`。完整的 `todo/write` 会话事件是 UI 与回放状态，而非第二条模型消息。
+
+#### Token 影响
+
+token 用量随模型每次提交的完整列表增长，这些调用参数会保留到压缩（compaction）。结果本身很小且形状固定。
+
+#### KV Cache 影响
+
+仅追加；新可见内容位于可复用请求前缀之后，不会使既有 KV-cache 条目失效。
+
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+这些限制说明工具何时不合适。它们是当前包约束，不是任务积压。
+
+- **仅单一所有者作用域**——列表属于唯一调用 agent 会话；subagent、共享与 swarm 作用域是有意设置的限制，非 agent 调用方会被拒绝。
+- **条目形状刻意保持最小**——`content` 加三态 `status`；整表替换不需要稳定 id、优先级或 active-form 字段。
+- **整表替换是唯一操作**——没有部分更新、没有回读工具、没有逐项编辑；模型每次调用都必须重新发送完整列表。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+
+本开发备注是维护者的工作上下文：未决问题与尚未决定的方向。它明确不具权威性——已交付行为、限制与既定理由以上文、包代码和相关 Agent Note 为准。
+
+#### 未来：跨 agent 与共享列表
+
+单一所有者作用域是有意设置的限制，跨 agent 或共享列表仍是独立的未来设计：它们需要逐项日志增量与显式作用域选择，并会改变模型可见约定。目前尚不存在设计。
+
+</details>

package/lib/index.js

@@ -0,0 +1,219 @@
+import z from "@deepseek-ai/schemastery";
+import { z as z$1 } from "zod";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+//#region lib/types/index.js
+/**
+* Model-facing whole-list replacement. Each call appends a `todo/write` snapshot to the calling
+* agent's session; replay is last-write-wins, and UIs render from session events. A non-agent
+* caller has no owning list and is rejected. Named exports preserve loader injection metadata.
+* @module @deepseek-ai/dsh-tool-todo
+*/
+const name = "tool-todo";
+const inject = ["tools", "sessionProjections"];
+/** The valid {@link TodoItem} statuses, as a runtime set for input narrowing. */
+const STATUSES = [
+	"pending",
+	"in_progress",
+	"completed"
+];
+/** Checklist glyph for one {@link TodoItem} status; the terminal card draws one per task. */
+const STATUS_MARK = {
+	pending: "☐",
+	in_progress: "◐",
+	completed: "☑"
+};
+/** Schemastery configuration for the todo tool consumer. */
+const Config = z.object({ allowParallelInProgress: z.boolean().required() });
+const DESCRIPTION_HEAD = "Record and update a task list to plan multi-step work and show progress; skip it for trivial single-step tasks. Add one todo per concrete step before you start. ";
+const DESCRIPTION_PARALLEL = "While work remains, keep the todos being worked on `in_progress`, several only when work runs in parallel. ";
+const DESCRIPTION_SINGLE = "While work remains, keep exactly one todo `in_progress`. ";
+const DESCRIPTION_TAIL = "Mark each todo `completed` as soon as it is done.";
+/**
+* The model-facing description for one activation. The active-status clause is the only part that
+* varies, because it is the only instruction the parallel policy changes.
+* @param allowParallel - whether several todos may be `in_progress` at once.
+* @returns the composed tool description.
+*/
+function describe(allowParallel) {
+	return DESCRIPTION_HEAD + (allowParallel ? DESCRIPTION_PARALLEL : DESCRIPTION_SINGLE) + DESCRIPTION_TAIL;
+}
+/**
+* Validate the value constraints the ParameterSchemaSpec can't express and build the canonical {@link
+* TodoItem}[]: trimmed non-empty unique content, and at most one `in_progress` item unless the
+* deployment allows parallel work. The registry has already enforced the status enum and rejected
+* unknown item keys (`additionalProperties: false` — the logged snapshot must equal what the model
+* believes it wrote, so a nested/extended item shape fails loud at the schema boundary instead of
+* silently flattening); the cast below records that guarantee.
+* @param raw - the model-supplied list, already schema-checked.
+* @param allowParallel - whether several items may be `in_progress` at once.
+* @returns the canonical list.
+*/
+function toTodoList(raw, allowParallel) {
+	const todos = [];
+	const seen = /* @__PURE__ */ new Set();
+	let active = 0;
+	for (const item of raw) {
+		const content = item.content.trim();
+		if (content.length === 0) throw new Error("invalid todo: `content` must be a non-empty string");
+		if (seen.has(content)) throw new Error(`invalid todos: duplicate content ${JSON.stringify(content)}`);
+		seen.add(content);
+		if (item.status === "in_progress") active++;
+		todos.push({
+			content,
+			status: item.status
+		});
+	}
+	if (!allowParallel && active > 1) throw new Error(`invalid todos: at most one task may be in_progress (got ${active})`);
+	return todos;
+}
+/** Wire payload schema of the `todos` projection (whole list or pre-first-write null). */
+const todosProjectionSchema = z$1.union([z$1.array(z$1.object({
+	content: z$1.string(),
+	status: z$1.union([
+		z$1.literal("pending"),
+		z$1.literal("in_progress"),
+		z$1.literal("completed")
+	])
+})), z$1.null()]);
+/**
+* The terminal card for one whole-list update: the completed/total count in the
+* title and one status-marked line per task in model order. The title keeps the
+* count visible when a long list folds, and an empty list keeps the bare title so
+* the row falls back to the model-facing counts sentence.
+* @param todos - the schema-checked task list from the call arguments.
+* @returns the generic card the terminal surface draws.
+*/
+function presentTodoList(todos) {
+	const done = todos.filter((todo) => todo.status === "completed").length;
+	return {
+		card: "generic",
+		title: todos.length === 0 ? "Update todo list" : `Update todo list (${String(done)}/${String(todos.length)} done)`,
+		kind: "other",
+		...todos.length === 0 ? {} : { content: [{
+			type: "text",
+			text: todos.map((todo) => `${STATUS_MARK[todo.status]} ${todo.content}`).join("\n")
+		}] }
+	};
+}
+/**
+* Register the `todo_write` tool on `ctx.tools` and the `todos` unit on
+* `ctx.sessionProjections`.
+* @param ctx - registrant context carrying the tool and session-projection registries.
+* @param config - deployment's explicit todo policy.
+* @returns when the plugin is ready.
+*/
+async function apply(ctx, config) {
+	const allowParallel = config.allowParallelInProgress;
+	await ctx.sessionProjections.register({
+		key: "todos",
+		stateSchema: todosProjectionSchema,
+		init: () => null,
+		apply: (state, event) => {
+			if (event.type === "todo/write") return event.data.todos;
+			if (event.type === "turn/start") return null;
+			return state;
+		},
+		wire: {
+			viewSchema: todosProjectionSchema,
+			view: (state) => state,
+			summary: false
+		},
+		stateVersion: 2
+	});
+	ctx.tools.register(defineTool({
+		name: "todo_write",
+		description: describe(allowParallel),
+		parameters: { todos: {
+			type: "array",
+			required: true,
+			description: "The COMPLETE task list, replacing any previous list.",
+			items: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					content: {
+						type: "string",
+						required: true,
+						description: "What the task is — a short imperative line."
+					},
+					status: {
+						type: "string",
+						required: true,
+						enum: [...STATUSES],
+						description: "pending (not started) | in_progress (now) | completed (done)."
+					}
+				}
+			}
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					todos: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								content: {
+									type: "string",
+									required: true
+								},
+								status: {
+									type: "string",
+									required: true,
+									enum: [...STATUSES]
+								}
+							}
+						}
+					},
+					counts: {
+						type: "object",
+						additionalProperties: false,
+						required: true,
+						properties: {
+							pending: {
+								type: "integer",
+								required: true
+							},
+							inProgress: {
+								type: "integer",
+								required: true
+							},
+							completed: {
+								type: "integer",
+								required: true
+							}
+						}
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Updated todo list: ${value.counts.pending} pending, ${value.counts.inProgress} in progress, ${value.counts.completed} completed.`
+			}]
+		},
+		execute(args, exec) {
+			const todos = toTodoList(args.todos, allowParallel);
+			if (!exec.agent) throw new Error("todo_write requires an owning agent session");
+			exec.agent.session.append("todo/write", { todos });
+			const count = (status) => todos.filter((t) => t.status === status).length;
+			return Promise.resolve({
+				todos: todos.map((todo) => ({
+					content: todo.content,
+					status: todo.status
+				})),
+				counts: {
+					pending: count("pending"),
+					inProgress: count("in_progress"),
+					completed: count("completed")
+				}
+			});
+		},
+		presentCall: (args) => presentTodoList(args.todos)
+	}));
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/types/client.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Client-namespace projection of the todo domain: a pure re-export of the package's
+ * types outlet. Client code imports ONLY the client namespace (repo
+ * discipline), so `./client` projects the same single-source content
+ * `./types` serves to host consumers — zero duplication.
+ *
+ * @module @deepseek-ai/dsh-tool-todo/client
+ */
+export type * from './types.ts';
+//# sourceMappingURL=client.d.ts.map

package/lib/types/client.js

@@ -0,0 +1,10 @@
+/**
+ * Client-namespace projection of the todo domain: a pure re-export of the package's
+ * types outlet. Client code imports ONLY the client namespace (repo
+ * discipline), so `./client` projects the same single-source content
+ * `./types` serves to host consumers — zero duplication.
+ *
+ * @module @deepseek-ai/dsh-tool-todo/client
+ */
+export {};
+//# sourceMappingURL=client.js.map

package/lib/types/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Model-facing whole-list replacement. Each call appends a `todo/write` snapshot to the calling
+ * agent's session; replay is last-write-wins, and UIs render from session events. A non-agent
+ * caller has no owning list and is rejected. Named exports preserve loader injection metadata.
+ * @module @deepseek-ai/dsh-tool-todo
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export type * from './types.ts';
+export declare const name = "tool-todo";
+export declare const inject: string[];
+/** Model-facing todo tool configuration. */
+export interface Config {
+    /**
+     * Required deployment choice for whether several todos may be `in_progress` at once. True suits
+     * agents that run work concurrently — subagents, background commands, workflow fan-out — and the
+     * description then instructs the model to mark every actively worked task. False restores the
+     * single-active discipline: the description asks for exactly one, and a call marking more is
+     * rejected.
+     */
+    allowParallelInProgress: boolean;
+}
+/** Schemastery configuration for the todo tool consumer. */
+export declare const Config: z<Config>;
+/**
+ * Register the `todo_write` tool on `ctx.tools` and the `todos` unit on
+ * `ctx.sessionProjections`.
+ * @param ctx - registrant context carrying the tool and session-projection registries.
+ * @param config - deployment's explicit todo policy.
+ * @returns when the plugin is ready.
+ */
+export declare function apply(ctx: Context, config: Config): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -0,0 +1,208 @@
+/**
+ * Model-facing whole-list replacement. Each call appends a `todo/write` snapshot to the calling
+ * agent's session; replay is last-write-wins, and UIs render from session events. A non-agent
+ * caller has no owning list and is rejected. Named exports preserve loader injection metadata.
+ * @module @deepseek-ai/dsh-tool-todo
+ */
+import z from '@deepseek-ai/schemastery';
+import { z as zod } from 'zod';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+export const name = 'tool-todo';
+export const inject = ['tools', 'sessionProjections'];
+/** The valid {@link TodoItem} statuses, as a runtime set for input narrowing. */
+const STATUSES = ['pending', 'in_progress', 'completed'];
+/** Checklist glyph for one {@link TodoItem} status; the terminal card draws one per task. */
+const STATUS_MARK = {
+    pending: '☐',
+    in_progress: '◐',
+    completed: '☑',
+};
+/** Schemastery configuration for the todo tool consumer. */
+export const Config = z.object({
+    allowParallelInProgress: z.boolean().required(),
+});
+const DESCRIPTION_HEAD = 'Record and update a task list to plan multi-step work and show progress; skip it for trivial '
+    + 'single-step tasks. Add one todo per concrete step before you start. ';
+const DESCRIPTION_PARALLEL = 'While work remains, keep the todos being worked on `in_progress`, several only when work runs in parallel. ';
+const DESCRIPTION_SINGLE = 'While work remains, keep exactly one todo `in_progress`. ';
+const DESCRIPTION_TAIL = 'Mark each todo `completed` as soon as it is done.';
+/**
+ * The model-facing description for one activation. The active-status clause is the only part that
+ * varies, because it is the only instruction the parallel policy changes.
+ * @param allowParallel - whether several todos may be `in_progress` at once.
+ * @returns the composed tool description.
+ */
+function describe(allowParallel) {
+    return DESCRIPTION_HEAD
+        + (allowParallel ? DESCRIPTION_PARALLEL : DESCRIPTION_SINGLE)
+        + DESCRIPTION_TAIL;
+}
+/**
+ * Validate the value constraints the ParameterSchemaSpec can't express and build the canonical {@link
+ * TodoItem}[]: trimmed non-empty unique content, and at most one `in_progress` item unless the
+ * deployment allows parallel work. The registry has already enforced the status enum and rejected
+ * unknown item keys (`additionalProperties: false` — the logged snapshot must equal what the model
+ * believes it wrote, so a nested/extended item shape fails loud at the schema boundary instead of
+ * silently flattening); the cast below records that guarantee.
+ * @param raw - the model-supplied list, already schema-checked.
+ * @param allowParallel - whether several items may be `in_progress` at once.
+ * @returns the canonical list.
+ */
+function toTodoList(raw, allowParallel) {
+    const todos = [];
+    const seen = new Set();
+    let active = 0;
+    for (const item of raw) {
+        const content = item.content.trim();
+        if (content.length === 0) {
+            throw new Error('invalid todo: `content` must be a non-empty string');
+        }
+        if (seen.has(content)) {
+            throw new Error(`invalid todos: duplicate content ${JSON.stringify(content)}`);
+        }
+        seen.add(content);
+        if (item.status === 'in_progress')
+            active++;
+        todos.push({ content, status: item.status });
+    }
+    if (!allowParallel && active > 1) {
+        throw new Error(`invalid todos: at most one task may be in_progress (got ${active})`);
+    }
+    return todos;
+}
+/** Wire payload schema of the `todos` projection (whole list or pre-first-write null). */
+const todosProjectionSchema = zod.union([
+    zod.array(zod.object({
+        content: zod.string(),
+        status: zod.union([zod.literal('pending'), zod.literal('in_progress'), zod.literal('completed')]),
+    })),
+    zod.null(),
+]);
+/**
+ * The terminal card for one whole-list update: the completed/total count in the
+ * title and one status-marked line per task in model order. The title keeps the
+ * count visible when a long list folds, and an empty list keeps the bare title so
+ * the row falls back to the model-facing counts sentence.
+ * @param todos - the schema-checked task list from the call arguments.
+ * @returns the generic card the terminal surface draws.
+ */
+function presentTodoList(todos) {
+    const done = todos.filter(todo => todo.status === 'completed').length;
+    return {
+        card: 'generic',
+        title: todos.length === 0 ? 'Update todo list' : `Update todo list (${String(done)}/${String(todos.length)} done)`,
+        kind: 'other',
+        ...todos.length === 0 ? {} : {
+            content: [{
+                    type: 'text',
+                    text: todos.map(todo => `${STATUS_MARK[todo.status]} ${todo.content}`).join('\n'),
+                }],
+        },
+    };
+}
+/**
+ * Register the `todo_write` tool on `ctx.tools` and the `todos` unit on
+ * `ctx.sessionProjections`.
+ * @param ctx - registrant context carrying the tool and session-projection registries.
+ * @param config - deployment's explicit todo policy.
+ * @returns when the plugin is ready.
+ */
+export async function apply(ctx, config) {
+    const allowParallel = config.allowParallelInProgress;
+    // Standing-plan fold: latest whole todo/write list, cleared by the next
+    // turn/start (turn/end keeps the finished checklist visible); null before the
+    // first write or after a later turn begins; every other event returns the
+    // same state reference.
+    await ctx.sessionProjections.register({
+        key: 'todos',
+        stateSchema: todosProjectionSchema,
+        init: () => null,
+        apply: (state, event) => {
+            if (event.type === 'todo/write')
+                return event.data.todos;
+            if (event.type === 'turn/start')
+                return null;
+            return state;
+        },
+        wire: { viewSchema: todosProjectionSchema, view: state => state, summary: false },
+        stateVersion: 2,
+    });
+    ctx.tools.register(defineTool({
+        name: 'todo_write',
+        description: describe(allowParallel),
+        parameters: {
+            todos: {
+                type: 'array',
+                required: true,
+                description: 'The COMPLETE task list, replacing any previous list.',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        content: { type: 'string', required: true, description: 'What the task is — a short imperative line.' },
+                        status: {
+                            type: 'string',
+                            required: true,
+                            enum: [...STATUSES],
+                            description: 'pending (not started) | in_progress (now) | completed (done).',
+                        },
+                    },
+                },
+            },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    todos: {
+                        type: 'array',
+                        required: true,
+                        items: {
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                                content: { type: 'string', required: true },
+                                status: { type: 'string', required: true, enum: [...STATUSES] },
+                            },
+                        },
+                    },
+                    counts: {
+                        type: 'object',
+                        additionalProperties: false,
+                        required: true,
+                        properties: {
+                            pending: { type: 'integer', required: true },
+                            inProgress: { type: 'integer', required: true },
+                            completed: { type: 'integer', required: true },
+                        },
+                    },
+                },
+            },
+            render: (_args, value) => [{
+                    type: 'text',
+                    text: `Updated todo list: ${value.counts.pending} pending, ${value.counts.inProgress} in progress, ${value.counts.completed} completed.`,
+                }],
+        },
+        execute(args, exec) {
+            const todos = toTodoList(args.todos, allowParallel);
+            if (!exec.agent) {
+                // The list is per-agent-session state; a non-agent caller (no owning
+                // session) has nowhere to write it. Reject rather than silently no-op.
+                throw new Error('todo_write requires an owning agent session');
+            }
+            exec.agent.session.append('todo/write', { todos });
+            const count = (status) => todos.filter(t => t.status === status).length;
+            return Promise.resolve({
+                todos: todos.map(todo => ({ content: todo.content, status: todo.status })),
+                counts: {
+                    pending: count('pending'),
+                    inProgress: count('in_progress'),
+                    completed: count('completed'),
+                },
+            });
+        },
+        presentCall: args => presentTodoList(args.todos),
+    }));
+}
+//# sourceMappingURL=index.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Pure types of the todo domain: the ONE home of the `todos` projection-key
+ * declaration plus its payload types, free of this package's host-side value
+ * imports (dsh-tools, zod). Two namespace projections serve it — `./types`
+ * for host consumers, `./client/types` (the browser half-entry's re-export)
+ * for client aggregates — with zero content duplication.
+ *
+ * @module @deepseek-ai/dsh-tool-todo/types
+ */
+/**
+ * One entry in an agent's todo list — the unit of the `todo/write`
+ * whole-list snapshot declared by this package.
+ *
+ * Deliberately minimal: a human-readable `content` line and a three-state
+ * `status`. No id, priority, or `activeForm` — the list is replaced wholesale
+ * on every write (last-write-wins), so entries need no stable identity. The
+ * three statuses describe the complete portable lifecycle needed by model and
+ * UI consumers.
+ */
+export interface TodoItem {
+    /** What this task is — a short imperative line shown in the UI. */
+    content: string;
+    /** Lifecycle state. `in_progress` marks a task being worked now; parallel work may mark several. */
+    status: 'pending' | 'in_progress' | 'completed';
+}
+declare module '@deepseek-ai/dsh-session/types' {
+    interface SessionEventMap {
+        /** Whole-list snapshot; latest write wins on replay. Log-only UI state; never derived history. */
+        'todo/write': {
+            todos: TodoItem[];
+        };
+    }
+}
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionMap {
+        /**
+         * The agent's current whole todo list (the latest `todo/write` snapshot),
+         * or `null` before the first write. Whole-value rule: every `todo/write`
+         * carries the complete replacement list, so the fold is last-wins.
+         * Excluded from Session summary payloads, with `null` kept outside the
+         * exclusion mark so the pre-first-write value stays expressible.
+         */
+        todos: SessionProjectionSummaryExcluded<TodoItem[]> | null;
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,11 @@
+/**
+ * Pure types of the todo domain: the ONE home of the `todos` projection-key
+ * declaration plus its payload types, free of this package's host-side value
+ * imports (dsh-tools, zod). Two namespace projections serve it — `./types`
+ * for host consumers, `./client/types` (the browser half-entry's re-export)
+ * for client aggregates — with zero content duplication.
+ *
+ * @module @deepseek-ai/dsh-tool-todo/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/locale/de.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "To-Do-Listen-Tool",
+    "description": "Lassen Sie die KI Aufgaben-To-Do-Listen erstellen und aktualisieren."
+  }
+}

package/locale/en.json

@@ -0,0 +1,5 @@
+{
+  "meta": {
+    "title": "tool-todo"
+  }
+}

package/locale/es.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Herramienta de lista de tareas pendientes",
+    "description": "Deje que AI cree y actualice listas de tareas pendientes."
+  }
+}

package/locale/fr.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Outil de liste de tâches",
+    "description": "Laissez l'IA créer et mettre à jour des listes de tâches à effectuer."
+  }
+}

package/locale/ja.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "タスク一覧ツール",
+    "description": "AI が作業のタスク一覧を作成、更新できます。"
+  }
+}

package/locale/pt.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Ferramenta de lista de tarefas",
+    "description": "Deixe a IA criar e atualizar listas de tarefas pendentes."
+  }
+}

package/locale/ru.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Инструмент списка дел",
+    "description": "Позвольте ИИ создавать и обновлять списки дел."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "待办清单工具",
+    "description": "让 AI 创建和更新任务待办清单。"
+  }
+}

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@fishwithcat/dsh-tool-todo",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "Model-facing todo_write tool over the DeepSeek Harness event-sourced session log",
+  "version": "0.2.2-alpha.3",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FishwithCat/deepseek-harness-tui",
+    "directory": "packages/todo/tool-todo"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/types/client.d.ts",
+      "default": "./lib/types/client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
+  },
+  "files": [
+    "locale/*.json",
+    "lib/index.js",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@deepseek-ai/schemastery": "~3.18.6-alpha.2",
+    "zod": "4.4.3"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-agent": "0.2.2-alpha.3",
+    "@deepseek-ai/dsh-session": "0.2.2-alpha.3",
+    "@deepseek-ai/dsh-session-projection": "0.2.2-alpha.3",
+    "@deepseek-ai/dsh-tools": "0.2.2-alpha.3",
+    "@deepseek-ai/cordis": "~4.0.6-alpha.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis-plugin-include": "~1.0.11-alpha.2",
+    "@deepseek-ai/cordis-plugin-loader": "~1.0.7-alpha.2",
+    "@deepseek-ai/dsh-agent": "0.2.2-alpha.3",
+    "@deepseek-ai/dsh-agent-loop": "0.2.2-alpha.3",
+    "@deepseek-ai/dsh-agent-loop-testkit": "0.2.2-alpha.3",
+    "@deepseek-ai/dsh-llm": "0.2.2-alpha.3",
+    "@deepseek-ai/dsh-session": "0.2.2-alpha.3",
+    "@deepseek-ai/dsh-session-projection": "0.2.2-alpha.3",
+    "@deepseek-ai/dsh-system-prompt": "0.2.2-alpha.3",
+    "@deepseek-ai/dsh-tool-executor-native": "0.2.2-alpha.3",
+    "@deepseek-ai/dsh-tool-testkit": "0.2.2-alpha.3",
+    "@deepseek-ai/dsh-tools": "0.2.2-alpha.3",
+    "@deepseek-ai/dsh-user-questions": "0.2.2-alpha.3",
+    "@deepseek-ai/cordis": "~4.0.6-alpha.2"
+  }
+}