@qlzt/dsh-tool-goal 0.0.0-stage → 0.2.1-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.i18n.yaml

@@ -0,0 +1,79 @@
+# 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/goal/tool-goal/README.md
+/:
+  en: 1965bb8d690c2163
+  zh: ccbb80e24190cb70
+/deepseek-ai-dsh-tool-goal:
+  en: 942b1a25c527fe81
+  zh: f688d651470c7c5a
+/deepseek-ai-dsh-tool-goal/summary:
+  en: e949bc54b6e81b98
+  zh: 728896898f55353f
+/deepseek-ai-dsh-tool-goal/table-of-contents:
+  en: d152484eb41ac6b4
+  zh: 09388d293f9be9cb
+/deepseek-ai-dsh-tool-goal/use-this-package:
+  en: 0a5939086aa67be0
+  zh: c97e18432e623631
+/deepseek-ai-dsh-tool-goal/use-this-package/tools:
+  en: 1f9ad059567a448a
+  zh: d3f70b470e9317c4
+/deepseek-ai-dsh-tool-goal/use-this-package/configure-it:
+  en: e3f5e8d634a488b7
+  zh: 04dcf916aa2114d2
+/deepseek-ai-dsh-tool-goal/use-this-package/authority-rules:
+  en: a00f0dac577c3e9e
+  zh: 5dedb3dfcce449bc
+/deepseek-ai-dsh-tool-goal/understand-the-implementation:
+  en: 4e9fdb5a89f4baa3
+  zh: 50d182467ae1f3a7
+/deepseek-ai-dsh-tool-goal/understand-the-implementation/design:
+  en: a30f36299c8107f7
+  zh: 65e6e1e19aeb5281
+/deepseek-ai-dsh-tool-goal/understand-the-implementation/source-map:
+  en: 4d5c648787409868
+  zh: b4938bfe660f18aa
+/deepseek-ai-dsh-tool-goal/understand-the-implementation/tool-output:
+  en: 79e54f40e0bfbe2b
+  zh: 895f7ba22749bc07
+/deepseek-ai-dsh-tool-goal/further-exploration:
+  en: 870f9cbbc201e7f1
+  zh: 6fa3e87efd10940b
+/deepseek-ai-dsh-tool-goal/model-experience:
+  en: 215e7ba838619b7b
+  zh: a311da3843709f90
+/deepseek-ai-dsh-tool-goal/model-experience/system-prompt:
+  en: cf78b9dd5596495f
+  zh: bd44560f8c2435e8
+/deepseek-ai-dsh-tool-goal/model-experience/system-prompt/what-the-model-sees:
+  en: c4ddc481746664fc
+  zh: f86e0ba3bb0043be
+/deepseek-ai-dsh-tool-goal/model-experience/system-prompt/what-the-model-sees/goal-policy:
+  en: 452e35a67b130e54
+  zh: ad6030b6cb0eaabc
+/deepseek-ai-dsh-tool-goal/model-experience/system-prompt/token-effect:
+  en: 0ca47969efda70ab
+  zh: bfb6dd046182bcfe
+/deepseek-ai-dsh-tool-goal/model-experience/system-prompt/kv-cache-effect:
+  en: 1228efe95b389486
+  zh: 0eb2e21c6ab3bc33
+/deepseek-ai-dsh-tool-goal/model-experience/tool-schemas-and-results:
+  en: cadc497841430a21
+  zh: af4cc374d7d16917
+/deepseek-ai-dsh-tool-goal/model-experience/tool-schemas-and-results/what-the-model-sees:
+  en: a935557ea8afce8e
+  zh: 3e2b8208d0a22672
+/deepseek-ai-dsh-tool-goal/model-experience/tool-schemas-and-results/token-effect:
+  en: 636b06a2958786bd
+  zh: 4bb09f24ef382b3b
+/deepseek-ai-dsh-tool-goal/model-experience/tool-schemas-and-results/kv-cache-effect:
+  en: c2d2e98ce08fb40e
+  zh: 54d278190a1a9ed5
+/deepseek-ai-dsh-tool-goal/known-limitations-and-deferred-work:
+  en: c9b0f788467a5062
+  zh: 1a94e89fbb2e1e41
+/deepseek-ai-dsh-tool-goal/known-limitations-and-deferred-work/dev-note:
+  en: 47101daa04549489
+  zh: 1a3babd48193c068

package/README.md

@@ -1,3 +1,162 @@
-# Temporary Holding Version
+---
+description: "The model-facing goal tools for users and maintainers choosing, composing, or debugging get_goal, create_goal, and update_goal."
+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-goal
+
+English | [中文](README.zh.md)
+
+## Summary
+
+`dsh-tool-goal` lets a model read persisted goals and infer and create a long-running goal from a direct human request. Creating, editing, pausing, or resuming requires that direct request in a top-level agent turn; completing or blocking also works in an autonomous goal round. Updates require the exact goal id and revision returned by a prior read. `resume` rearms active-but-disarmed or blocked goals, while users resume durable paused goals through Web or `/goal resume`. Autonomous blocking requires the same condition for a configurable threshold of three consecutive rounds by default.
+
+## 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
+
+Mount `dsh-tool-goal` beside the goal service when the model should create and update persisted goals itself. The tools are the model-facing half of the goal surface; the `/goal` command is the human-facing half, and the continuation driver uses the same tools to complete or block goals at the end of autonomous rounds.
+
+### Tools
+
+All three tools return the same compact JSON — `{ goal: null }` when no goal is current, otherwise the goal's id, revision, objective, phase, rounds started, round cap, optional blocker reason, and whether continuation is armed — matching what Native callers already render.
+
+| Tool | What it does |
+|---|---|
+| `get_goal()` | Reads the current goal, or `null` when none is current |
+| `create_goal(objective, max_goal_rounds?)` | Creates one goal from a direct top-level human turn |
+| `update_goal(goal_id, revision, action, objective?, max_goal_rounds?, blocked_reason?)` | `edit`, `pause`, `resume`, `complete`, or `blocked` on the exact goal revision |
+
+Call `get_goal` before `update_goal` and copy the exact `goal_id` and `revision`; all calls are exclusive, so a model-ordered batch observes earlier mutations and their new revisions. Replacements belong only to `edit`; `blocked_reason` is required only for `blocked` and is persisted with the stable code `model-reported`. Strict-schema empty-string and zero fillers count as omitted, while meaningful values remain limited to their action.
+
+### Configure it
+
+```yaml
+- id: tool-goal
+  name: '@deepseek-ai/dsh-tool-goal'
+  config:
+    blockedAfterConsecutiveRounds: 3
+```
+
+The value must be a positive safe integer. It supplies both the hard lower bound on model self-blocking and the number named in model guidance. The generated [configuration catalog](../../../docs/config-catalog.md#deepseek-aidsh-tool-goal) is the exhaustive source for every accepted field.
+
+### Authority rules
+
+The tools execute only for the exact live calling agent inside its active driver with an open turn. `create`, `edit`, `pause`, and `resume` additionally require a direct human message in a runtime-root agent's current turn — a subagent or a non-human producer cannot create or edit goals. `resume` rejects a durable paused goal before the goal service runs; that state belongs to the user-facing resume path. `complete` and `blocked` also accept the exact current goal round: a goal-sourced round may complete the goal immediately, but a blocked call is mechanically rejected until the configured number of consecutive rounds has passed — the model judges whether the same condition actually persisted and must describe it in `blocked_reason`. A direct human request may stop a goal immediately.
+
+An autonomous round that successfully reports `complete` or `blocked` also ends the physical turn after that step, and the model receives a closing instruction to write the final message to the user. Direct-human mutations never trigger that stop: the assistant may acknowledge the change and the loop keeps concurrent human steering available.
+
+-----
+
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+
+<details>
+<summary>Implementation internals — click to expand</summary>
+
+This section explains how the tools enforce authority and render output; the observable contract is covered in [Use this package](#use-this-package).
+
+### Design
+
+- **Authority at execution.** Every call resolves the exact live agent, its inherited `AgentRegistry` initiator, running status, and an open turn; `create`, `edit`, `pause`, and `resume` additionally require an accepted `{ kind: 'user' }` message or steering event in a runtime-root agent's current turn. A durable paused goal fails the `resume` action with `GOAL_TOOL_RESUME_PAUSED`; the user-facing command or Web control owns that transition. Durable fork lineage does not demote a resumed root; live subagent ownership does.
+- **Host attestation of human input.** `{ kind: 'user' }` is assigned by `Agent.followup()` and `steer()` when their caller omits a source, so plugins, schedulers, and other non-human producers must pass their own source rather than inheriting human authority.
+- **System-prompt guidance with the configured threshold.** The package registers one `tool:goal` system-prompt section whose fixed text interpolates `blockedAfterConsecutiveRounds`; the same value is the hard lower bound enforced at execution.
+- **Wrap-up context for terminal rounds.** A successful autonomous `complete` or `blocked` defers a closing `<goal_complete>` or `<goal_blocked>` instruction so the model addresses the user once before the turn ends; direct-human mutations never defer this context.
+
+### Source map
+
+| File | Role |
+|---|---|
+| [`src/index.ts`](src/index.ts) | Plugin entry: tool registration, config, system-prompt section, result rendering |
+| [`src/authority.ts`](src/authority.ts) | Execution-time authority checks and goal-round acceptance |
+| [`src/wrapup.ts`](src/wrapup.ts) | Closing-message instruction for terminal autonomous updates |
+
+### Tool output
+
+All three tools share one canonical output: the compact JSON `{ goal: null }` or `{ goal: { id, revision, objective, phase, roundsStarted, maxGoalRounds, blockedReason? }, activation }`. `activation` in a result is a live observation and never becomes replay authority. UI clients receive pure generic cards — read for `get_goal`, other for mutations.
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+The tools are the model-facing half of the goal surface; read these pages for the state they mutate and the policy they defer to.
+
+- [Goal service](../goal/README.md) — the goal state and lifecycle the tools mutate.
+- [Goal group map](../README.md) — the goal packages and how they compose.
+- [Generated tool catalog](../../../docs/tool-catalog.md#deepseek-aidsh-tool-goal) — the exact schemas the model receives.
+- [Goal-tool Agent Note](../../../.agents/notes/implemented/feature/2026-07-19-model-facing-goal-tools.md) — the authority split and UX decisions.
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+### System prompt
+
+#### What the model sees
+
+A fixed goal policy allows inferring goal intent in any language, explains rearming after resume/fork, and limits completion/blocking claims; creation scope and read-before-update refs live in the tool definitions. Durable paused resume is rejected at execution with `GOAL_TOOL_RESUME_PAUSED`; the user-facing goal control owns that transition. The configured threshold is interpolated into that guidance.
+
+##### Goal policy
+
+```markdown
+create_goal may infer goal intent from a direct human request in any language. After session resume or fork, an active goal is disarmed: when a human asks to continue or resume in any wording or language, use update_goal action resume to rearm it. Mark complete only when the objective is actually achieved. Mark blocked only after the same blocking condition persists for at least 3 consecutive goal rounds, and report that concrete condition in blocked_reason; difficulty, uncertainty, or useful remaining work is not blocked.
+```
+
+#### Token effect
+
+Small fixed input cost on every request where this plugin's prompt registration is in scope.
+
+#### KV Cache effect
+
+Prefix-stable while the plugin scope, configured threshold, and guidance text are unchanged. Activation, disposal, or configuration changes may invalidate reuse from this prompt section.
+
+### Tool schemas and results
+
+#### What the model sees
+
+The generated [`get_goal`, `create_goal`, and `update_goal` schemas](../../../docs/tool-catalog.md#deepseek-aidsh-tool-goal). Successful results are compact JSON. A mutation appends the goal domain's durable `goal/change` event without queuing model context. `activation` in a result is a live observation and never becomes replay authority.
+
+#### Token effect
+
+Fixed schema cost plus one compact result per call. The durable mutation adds no separate model-visible context.
+
+#### KV Cache effect
+
+Schemas are prefix-stable while their definitions and visibility are unchanged. Calls and results append after the reusable request prefix without invalidating earlier entries.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+These limits define when the goal tools are a poor fit or need special care. They are current package constraints, not a task backlog.
+
+- **Semantic intent remains model judgment** — execution can prove that the current turn contains a direct human message, not whether the request is substantial enough to merit a goal.
+- **Same-condition blocking remains model judgment** — the runtime enforces distinct admitted-round count, not semantic equivalence of obstacles; an independent evaluator is deferred.
+- **No scheduling or direct human rendering** — these tools mutate state only; the same-session driver and `dsh-command-goal` are independent consumers of the same domain.
+- **Goal-round authority requires a driver** — the autonomous `complete`/`blocked` path is dormant unless a continuation driver admits goal-sourced user turns; mounting this tool package alone does not create them.
+- **Prompt registration is independent of filtering** — a scope may hide the tools while retaining their guidance unless the deployment scopes both registrations together.
+
+<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; it is explicitly non-authoritative. Open question: whether the goal-policy section should be independently scoped from the tool registrations, so a scope cannot hide the tools while keeping the guidance.
+
+</details>

package/README.zh.md

@@ -0,0 +1,162 @@
+---
+description: "面向选择、组合或排查 get_goal、create_goal 与 update_goal 的用户与维护者的模型侧 goal 工具说明。"
+kind: "package-reference"
+---
+
+# @deepseek-ai/dsh-tool-goal
+
+[English](README.md) | 中文
+
+## 概述
+
+`dsh-tool-goal` 让模型读取持久 goal，并根据人类直接请求推断和创建长期 goal。创建、编辑、暂停或恢复要求该直接请求出现在顶层 agent（智能体）轮次中；完成或阻塞也可以在自主 Goal Round 中执行。更新必须使用先前读取到的精确 goal id 和 revision。`resume` 会重新启用 active-but-disarmed 或 blocked 的 goal，而持久的 paused goal 由用户通过 Web 或 `/goal resume` 恢复。自主阻塞要求同一条件持续达到可配置阈值，默认是连续三个 Round。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
+
+当模型需要自行创建和更新持久 goal 时，把 `dsh-tool-goal` 挂在 goal 服务旁边。这些工具是 goal 表面面向模型的一半；`/goal` 命令是面向人类的一半，续行驱动器在自主 Round 结束时使用同一套工具完成或阻塞 goal。
+
+### 工具
+
+三个工具都返回相同的紧凑 JSON——没有当前 goal 时为 `{ goal: null }`，否则返回 goal 的 id、revision、目标、phase、已开始 Round、Round 上限、可选的 blocker reason 与续行是否已启用——与 Native 调用方已经渲染的内容一致。
+
+| 工具 | 作用 |
+|---|---|
+| `get_goal()` | 读取当前 goal；没有当前 goal 时返回 `null` |
+| `create_goal(objective, max_goal_rounds?)` | 根据人类直接发起的顶层轮次创建一个 goal |
+| `update_goal(goal_id, revision, action, objective?, max_goal_rounds?, blocked_reason?)` | 对精确 goal revision 执行 `edit`、`pause`、`resume`、`complete` 或 `blocked` |
+
+在 `update_goal` 之前调用 `get_goal`，并复制精确的 `goal_id` 与 `revision`；所有调用都互斥，因此模型排序的批次能观察到更早变更及其新 revision。替换值只属于 `edit`；`blocked_reason` 只有在 `blocked` 时才必填，并以稳定代码 `model-reported` 持久化。严格 schema 下的空字符串和零填充值视为省略，而有意义的值仍限定到各自 action。
+
+### 配置
+
+```yaml
+- id: tool-goal
+  name: '@deepseek-ai/dsh-tool-goal'
+  config:
+    blockedAfterConsecutiveRounds: 3
+```
+
+该值必须是正的安全整数。它既提供模型自行报告阻塞的硬下限，也决定模型指引中指明的数值。生成的[配置目录](../../../docs/config-catalog.zh.md#deepseek-aidsh-tool-goal)是每个受支持字段的穷尽式真源。
+
+### 权限规则
+
+工具只为活跃驱动器内、处于开放轮次中的精确活跃调用 agent 执行。`create`、`edit`、`pause` 和 `resume` 还要求运行时根 agent 的当前轮次中存在人类直接消息——subagent 或非人类生产方不能创建或编辑 goal。`resume` 会在 goal 服务执行前拒绝持久的 paused goal；该状态只属于面向用户的恢复路径。`complete` 和 `blocked` 还接受完全一致的当前 Goal Round：来源为 goal 的 Round 可以立即完成 goal，但 `blocked` 调用在达到配置的连续 Round 数量之前会被机械拒绝——模型判断同一条件是否确实持续，并必须在 `blocked_reason` 中说明。人类直接请求可以立即停止 goal。
+
+成功报告 `complete` 或 `blocked` 的自主 Round 还会在该步骤后结束物理轮次，模型会收到一条结束指令，要求向用户写出最终消息。人类直接变更绝不会触发这种停止：assistant 可以确认变更，循环仍可接收并发的人类 steering（中途引导）。
+
+-----
+
+<a id="understand-the-implementation"></a>
+## 理解实现
+
+<details>
+<summary>实现细节——点击展开</summary>
+
+本节解释工具如何强制执行权限并渲染输出；可观察约定已在[使用本包](#use-this-package)中说明。
+
+### 设计
+
+- **执行时权限。** 每次调用都解析精确活跃 agent、其继承的 `AgentRegistry` initiator、running 状态与开放轮次；`create`、`edit`、`pause` 和 `resume` 还要求运行时根 agent 的当前轮次中存在已接受的 `{ kind: 'user' }` 消息或 steering 事件。持久的 paused goal 会让 `resume` 以 `GOAL_TOOL_RESUME_PAUSED` 失败；面向用户的命令或 Web 控件拥有该转换。持久 fork 谱系不会降低已恢复根 agent 的等级；活跃 subagent 所有权会降低。
+- **人类输入的宿主证明。** `Agent.followup()` 与 `steer()` 会在调用方省略 source 时分配 `{ kind: 'user' }`，因此插件、调度器与其他非人类生产方必须传入自己的 source，不能继承人类权限。
+- **带配置阈值的系统提示词指引。** 本包注册一个 `tool:goal` 系统提示词章节，其固定文本插入 `blockedAfterConsecutiveRounds`；同一数值就是执行时强制执行的硬下限。
+- **终局 Round 的结束上下文。** 成功的自主 `complete` 或 `blocked` 会延后一条 `<goal_complete>` 或 `<goal_blocked>` 结束指令，让模型在轮次结束前向用户做一次交代；人类直接变更绝不会延后该上下文。
+
+### 源码地图
+
+| 文件 | 职责 |
+|---|---|
+| [`src/index.ts`](src/index.ts) | 插件入口：工具注册、配置、系统提示词章节、结果渲染 |
+| [`src/authority.ts`](src/authority.ts) | 执行时权限检查与 Goal Round 接受 |
+| [`src/wrapup.ts`](src/wrapup.ts) | 终局自主更新的结束消息指令 |
+
+### 工具输出
+
+三个工具共用一种规范输出：紧凑 JSON `{ goal: null }`，或 `{ goal: { id, revision, objective, phase, roundsStarted, maxGoalRounds, blockedReason? }, activation }`。结果中的 `activation` 是实时观察值，绝不会成为回放权限依据。UI 客户端收到纯通用卡片——`get_goal` 为 read，变更使用 other。
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+这些工具是 goal 表面面向模型的一半；如需了解它们变更的状态及其所遵循的策略，请阅读以下页面。
+
+- [goal 服务](../goal/README.zh.md)——工具变更的 goal 状态与生命周期。
+- [goal 组地图](../README.zh.md)——goal 各包及其组合方式。
+- [生成的工具目录](../../../docs/tool-catalog.zh.md#deepseek-aidsh-tool-goal)——模型接收的精确 schema。
+- [goal 工具 Agent Note](../../../.agents/notes/implemented/feature/2026-07-19-model-facing-goal-tools.zh.md)——权限拆分与 UX 决策。
+
+-----
+
+<a id="model-experience"></a>
+## 模型体验
+
+### 系统提示词
+
+#### 模型看到的内容
+
+固定 goal 策略允许以任意语言推断 goal 意图，解释会话 resume／fork 后如何重新启用续行，并限制完成／阻塞声明；创建范围和更新前读取 ref 由工具定义说明。持久 paused 的 resume 会在执行时以 `GOAL_TOOL_RESUME_PAUSED` 拒绝；面向用户的 goal 控件拥有该转换。配置的阈值会插入该指引。
+
+##### Goal 策略
+
+```markdown
+create_goal may infer goal intent from a direct human request in any language. After session resume or fork, an active goal is disarmed: when a human asks to continue or resume in any wording or language, use update_goal action resume to rearm it. Mark complete only when the objective is actually achieved. Mark blocked only after the same blocking condition persists for at least 3 consecutive goal rounds, and report that concrete condition in blocked_reason; difficulty, uncertainty, or useful remaining work is not blocked.
+```
+
+#### Token 影响
+
+此插件的提示词注册位于请求范围内时，每次请求都会产生少量固定输入成本。
+
+#### KV Cache 影响
+
+插件范围、配置阈值和指引文本不变时，前缀保持稳定。启用、dispose（资源释放）或配置变更可能使此提示词章节的复用失效。
+
+### 工具 schema 与结果
+
+#### 模型看到的内容
+
+生成的 [`get_goal`、`create_goal` 和 `update_goal` schema](../../../docs/tool-catalog.zh.md#deepseek-aidsh-tool-goal)。成功结果是紧凑 JSON。变更会追加 goal 领域的持久 `goal/change` 事件，而不会将模型上下文加入队列。结果中的 `activation` 是实时观察值，绝不会成为回放权限依据。
+
+#### Token 影响
+
+固定 schema 成本，加上每次调用的一条紧凑结果。持久变更不会增加单独的模型可见上下文。
+
+#### KV Cache 影响
+
+schema 的定义与可见性不变时，前缀保持稳定。调用和结果会追加到可复用请求前缀之后，不会使更早条目失效。
+
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+这些限制说明 goal 工具何时不合适或需要特别注意。它们是当前包约束，不是任务积压。
+
+- **语义意图仍由模型判断**——执行只能证明当前轮次包含一条人类直接发送的消息，无法证明请求是否足够重大而值得创建 goal。
+- **阻塞条件是否相同仍由模型判断**——运行时强制统计互不重复的已准入 Goal Round，而不判断障碍在语义上是否等价；独立评估器的实现暂缓。
+- **不负责调度或直接面向人类呈现**——这些工具只变更状态；同会话驱动器与 `dsh-command-goal` 是同一领域的独立消费方。
+- **Goal Round 权限需要驱动器**——除非续行驱动器准入 goal 来源的用户轮次，否则自主 `complete`／`blocked` 路径不会启用；只挂载这个包不会创建这些轮次。
+- **提示词注册与过滤相互独立**——某个范围可能隐藏工具，却保留指引，除非部署将两项注册限定在同一范围。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+
+本开发备注是维护者的工作上下文，明确不具权威性。开放问题：goal 策略章节是否应与工具注册独立限定范围，避免某个范围隐藏工具却保留指引。
+
+</details>

package/lib/index.js

@@ -0,0 +1,379 @@
+import z from "@deepseek-ai/schemastery";
+import { GoalId } from "@qlzt/dsh-goal";
+import { HarnessError, boundContextSummary, createUserMessage } from "@qlzt/dsh-llm";
+import { defineTool } from "@qlzt/dsh-tools";
+//#region lib/types/authority.js
+/** Execution-time authority checks for the model-facing goal tools. */
+/** Throw one structured tool-policy failure. */
+function reject(message, code = "GOAL_TOOL_AUTHORITY_REQUIRED") {
+	throw new HarnessError(message, code);
+}
+/** Resolve the immutable event cut and open-turn boundary without copying the turn suffix. */
+function openTurnEvents(ctx, agent) {
+	const events = agent.session.snapshotEvents();
+	const boundary = ctx.sessionProjections.stateOf(agent.session, "turnBoundary");
+	if (boundary === void 0 || boundary.openTurnStartSeq === null) reject("goal tools require an open model turn", "GOAL_TOOL_DRIVER_REQUIRED");
+	return {
+		events,
+		openTurnStartSeq: boundary.openTurnStartSeq
+	};
+}
+/**
+* Resolve and authenticate the calling agent and its driver boundary.
+* @param ctx - Context carrying the live agent registry.
+* @param exec - Tool execution metadata supplied by the registry.
+* @returns The authenticated agent, immutable event cut, and open-turn boundary.
+*/
+function goalToolExecution(ctx, exec) {
+	const agent = exec.agent;
+	if (agent === void 0) return reject("goal tools require a calling agent", "GOAL_TOOL_AGENT_REQUIRED");
+	if (ctx.agents.get(agent.id) !== agent || agent.status !== "running" || ctx.agents.currentInitiator() !== agent) return reject("goal tools require the exact live calling agent inside its active driver", "GOAL_TOOL_DRIVER_REQUIRED");
+	return {
+		agent,
+		...openTurnEvents(ctx, agent)
+	};
+}
+/** Whether the captured open turn contains an event accepted by `predicate`. */
+function someOpenTurnEvent(execution, predicate) {
+	for (let seq = execution.openTurnStartSeq + 1; seq < execution.events.length; seq += 1) {
+		const event = execution.events[seq];
+		if (event !== void 0 && predicate(event)) return true;
+	}
+	return false;
+}
+/**
+* Whether host-attested human input appears in the current root-agent turn.
+* An omitted `Agent.followup()` / `steer()` source resolves to `user`, so non-human
+* producers must supply their own source rather than inheriting this authority.
+*/
+function hasDirectHumanInput(ctx, execution) {
+	if (!ctx.agents.roots().includes(execution.agent)) return false;
+	return someOpenTurnEvent(execution, (event) => event.type === "user/message" && event.data.source.kind === "user");
+}
+/** Whether this turn is the current goal's exact admitted round. */
+function isMatchingGoalRound(execution, goal) {
+	return someOpenTurnEvent(execution, (event) => event.type === "user/message" && event.data.source.kind === "goal" && event.data.source.goalId === goal.id && event.data.source.revision === goal.revision && event.data.source.round === goal.roundsStarted);
+}
+/**
+* Require authority originating in a human message accepted by a runtime root.
+* @param ctx - Context carrying the live agent graph.
+* @param execution - Authenticated current tool execution.
+*/
+function requireDirectHuman(ctx, execution) {
+	if (hasDirectHumanInput(ctx, execution)) return;
+	reject("this goal operation requires a direct human turn on a top-level agent");
+}
+/**
+* Resolve completion authority from either direct human input or the exact goal round.
+* @param ctx - Context carrying live agents and goal state.
+* @param execution - Authenticated current tool execution.
+* @returns The direct-human or exact-goal-round authority grant.
+*/
+function completionAuthority(ctx, execution) {
+	if (hasDirectHumanInput(ctx, execution)) return { kind: "direct-human" };
+	const goal = ctx.goals.get(execution.agent);
+	if (goal !== void 0 && isMatchingGoalRound(execution, goal)) return {
+		kind: "goal-round",
+		goal
+	};
+	return reject("complete and blocked require a direct human turn or the current goal round");
+}
+//#endregion
+//#region lib/types/wrapup.js
+/**
+* Render the closing-message instruction injected after an autonomous goal
+* round reports `complete` or `blocked`, replacing the former hard turn stop
+* so the model still addresses the user once before the turn ends.
+* @param objective - the terminal goal's objective, echoed for grounding.
+* @param blockedReason - the validated report for `blocked`; omitted for `complete`.
+* @returns a fresh one-block context for `ToolRunContext.deferContext()`.
+*/
+function renderWrapupContext(objective, blockedReason) {
+	const heading = `Objective: ${JSON.stringify(objective)}\n`;
+	return [{
+		type: "text",
+		text: blockedReason === void 0 ? "<goal_complete>\n" + heading + "The goal is marked complete and this autonomous run is ending. Write the closing message to the user now: state the outcome, summarize what was done and how it was verified, and point to the concrete results (files, commits, or other artifacts). Report only what earlier rounds and tool results in this session actually establish; when a detail is not in the session, say so instead of inventing it. Note anything the user should review or do next. Address the user directly. Do not call any more tools in this run; further work waits for the user's next instruction.\n</goal_complete>" : "<goal_blocked>\n" + heading + `Blocked: ${JSON.stringify(blockedReason)}\nThe goal is marked blocked and this autonomous run is ending. Write the closing message to the user now: state what has been completed so far, describe the concrete blocking condition and what you tried, and say exactly what you need from the user to continue. Report only what earlier rounds and tool results in this session actually establish; when a detail is not in the session, say so instead of inventing it. Address the user directly. Do not call any more tools in this run; further work waits for the user's next instruction.
+</goal_blocked>`
+	}];
+}
+//#endregion
+//#region lib/types/index.js
+/**
+* Model-facing `get_goal`, `create_goal`, and `update_goal` tools over the
+* persisted same-session goal domain.
+* @module @qlzt/dsh-tool-goal
+*/
+const name = "tool-goal";
+const inject = [
+	"agents",
+	"goals",
+	"tools",
+	"systemPrompt",
+	"sessionProjections"
+];
+/** Schemastery config for the goal-tool policy. */
+const Config = z.object({ blockedAfterConsecutiveRounds: z.number().step(1).min(1).default(3) });
+const UPDATE_ACTIONS = [
+	"edit",
+	"pause",
+	"resume",
+	"complete",
+	"blocked"
+];
+const CREATE_DESCRIPTION = "Create a persisted goal that keeps this session working across automatic continuation rounds. Use it when the direct human request is a long-running objective, even if the user did not say \"goal\"; not for single-turn work.";
+const GET_DESCRIPTION = "Read the current session goal, including the id and revision that update_goal requires.";
+const GOAL_VALUE_SCHEMA = { oneOf: [{
+	type: "object",
+	additionalProperties: false,
+	properties: { goal: {
+		type: "null",
+		required: true
+	} }
+}, {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		goal: {
+			type: "object",
+			additionalProperties: false,
+			required: true,
+			properties: {
+				id: {
+					type: "string",
+					required: true
+				},
+				revision: {
+					type: "integer",
+					required: true
+				},
+				objective: {
+					type: "string",
+					required: true
+				},
+				phase: {
+					type: "string",
+					required: true,
+					enum: [
+						"active",
+						"paused",
+						"blocked",
+						"complete"
+					]
+				},
+				roundsStarted: {
+					type: "integer",
+					required: true
+				},
+				maxGoalRounds: {
+					type: "integer",
+					required: true
+				},
+				blockedReason: {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						code: {
+							type: "string",
+							required: true
+						},
+						message: {
+							type: "string",
+							required: true
+						}
+					}
+				}
+			}
+		},
+		activation: {
+			type: "string",
+			required: true,
+			enum: ["armed", "disarmed"]
+		}
+	}
+}] };
+/** Render policy guidance with its deployment-selected blocked threshold. */
+function guidance(blockedAfter) {
+	return `create_goal may infer goal intent from a direct human request in any language. After session resume or fork, an active goal is disarmed: when a human asks to continue or resume in any wording or language, use update_goal action resume to rearm it. Mark complete only when the objective is actually achieved. Mark blocked only after the same blocking condition persists for at least ${blockedAfter} consecutive goal rounds, and report that concrete condition in blocked_reason; difficulty, uncertainty, or useful remaining work is not blocked.`;
+}
+/** Validate config even when apply is called directly outside Loader normalization. */
+function resolveConfig(config) {
+	const blockedAfter = config.blockedAfterConsecutiveRounds ?? 3;
+	if (!Number.isSafeInteger(blockedAfter) || blockedAfter < 1) throw new TypeError("blockedAfterConsecutiveRounds must be a positive safe integer");
+	return { blockedAfterConsecutiveRounds: blockedAfter };
+}
+/** Whether optional text is meaningful rather than a strict-schema empty filler. */
+function hasText(value) {
+	return value !== void 0 && value !== "";
+}
+/** Whether an optional round cap is meaningful rather than a strict-schema zero filler. */
+function hasRoundCap(value) {
+	return value !== void 0 && value !== 0;
+}
+/** Build the exact compare-and-set ref from model arguments. */
+function goalRef(goalId, revision) {
+	if (goalId.length === 0 || goalId !== goalId.trim() || !Number.isSafeInteger(revision) || revision < 1) throw new HarnessError("goal_id must be non-empty and revision must be a positive safe integer", "GOAL_TOOL_INVALID_UPDATE");
+	return {
+		id: GoalId(goalId),
+		revision
+	};
+}
+/** Stable compact model result; activation is an observation, not replay state. */
+function goalValue(goal) {
+	if (goal === void 0) return { goal: null };
+	return {
+		goal: {
+			id: goal.id,
+			revision: goal.revision,
+			objective: goal.objective,
+			phase: goal.phase,
+			roundsStarted: goal.roundsStarted,
+			maxGoalRounds: goal.maxGoalRounds,
+			...goal.blockedReason === void 0 ? {} : { blockedReason: {
+				code: goal.blockedReason.code,
+				message: goal.blockedReason.message
+			} }
+		},
+		activation: goal.activation
+	};
+}
+/** Reusable canonical output declaration for all three goal controls. */
+const GOAL_OUTPUT = {
+	schema: GOAL_VALUE_SCHEMA,
+	render: (_args, value) => [{
+		type: "text",
+		text: JSON.stringify(value)
+	}]
+};
+/** Generic, args-only pending presentation shared by the goal tools. */
+function present(title, kind, rawInput) {
+	return {
+		card: "generic",
+		title,
+		kind,
+		...rawInput === void 0 ? {} : { rawInput }
+	};
+}
+/** Register the three Codex-shaped goal tools and their shared policy section. */
+function apply(ctx, config) {
+	const resolved = resolveConfig(config);
+	ctx.systemPrompt.section({
+		name: "tool:goal",
+		order: ctx.systemPrompt.getSectionOrder("TOOL_GOAL"),
+		text: guidance(resolved.blockedAfterConsecutiveRounds)
+	});
+	ctx.tools.register(defineTool({
+		name: "get_goal",
+		description: GET_DESCRIPTION,
+		parameters: {},
+		output: GOAL_OUTPUT,
+		execute(_args, exec) {
+			const execution = goalToolExecution(ctx, exec);
+			return Promise.resolve(goalValue(ctx.goals.get(execution.agent)));
+		},
+		presentCall: () => present("Read current goal", "read")
+	}));
+	ctx.tools.register(defineTool({
+		name: "create_goal",
+		description: CREATE_DESCRIPTION,
+		parameters: {
+			objective: {
+				type: "string",
+				required: true,
+				description: "The concrete completion objective inferred from the direct human request."
+			},
+			max_goal_rounds: {
+				type: "number",
+				description: "Optional positive safe-integer limit on automatic continuation rounds."
+			}
+		},
+		output: GOAL_OUTPUT,
+		execute(args, exec) {
+			const execution = goalToolExecution(ctx, exec);
+			requireDirectHuman(ctx, execution);
+			const goal = ctx.goals.create(execution.agent, {
+				objective: args.objective,
+				...args.max_goal_rounds === void 0 ? {} : { maxGoalRounds: args.max_goal_rounds }
+			});
+			return Promise.resolve(goalValue(goal));
+		},
+		presentCall: (args) => present("Create goal", "other", args.objective)
+	}));
+	ctx.tools.register(defineTool({
+		name: "update_goal",
+		description: "Update the current goal.",
+		parameters: {
+			goal_id: {
+				type: "string",
+				required: true,
+				description: "Exact id returned by get_goal."
+			},
+			revision: {
+				type: "number",
+				required: true,
+				description: "Exact positive revision returned by get_goal."
+			},
+			action: {
+				type: "string",
+				required: true,
+				enum: UPDATE_ACTIONS,
+				description: "edit, pause, and resume require a direct top-level human request. complete and blocked are also allowed during an automatic continuation of this goal; blocked is rejected before the configured minimum round count."
+			},
+			objective: {
+				type: "string",
+				description: "Replacement objective; valid only with action edit."
+			},
+			max_goal_rounds: {
+				type: "number",
+				description: "Replacement cap; valid only with action edit."
+			},
+			blocked_reason: {
+				type: "string",
+				description: "Required only with action blocked: the concrete condition that persisted across rounds and blocks progress."
+			}
+		},
+		output: GOAL_OUTPUT,
+		execute(args, exec) {
+			const execution = goalToolExecution(ctx, exec);
+			const ref = goalRef(args.goal_id, args.revision);
+			const replacements = {
+				...hasText(args.objective) ? { objective: args.objective } : {},
+				...hasRoundCap(args.max_goal_rounds) ? { maxGoalRounds: args.max_goal_rounds } : {}
+			};
+			if (args.action === "edit") {
+				requireDirectHuman(ctx, execution);
+				if (hasText(args.blocked_reason)) throw new HarnessError("blocked_reason is valid only with action blocked", "GOAL_TOOL_INVALID_UPDATE");
+				const goal = ctx.goals.edit(execution.agent, ref, replacements);
+				return Promise.resolve(goalValue(goal));
+			}
+			if (args.action === "pause" || args.action === "resume") {
+				requireDirectHuman(ctx, execution);
+				if (hasText(args.objective) || hasRoundCap(args.max_goal_rounds) || hasText(args.blocked_reason)) throw new HarnessError("objective and max_goal_rounds are valid only with action edit; blocked_reason is valid only with action blocked", "GOAL_TOOL_INVALID_UPDATE");
+				const current = ctx.goals.get(execution.agent);
+				if (args.action === "resume" && current?.id === ref.id && current.revision === ref.revision && current.phase === "paused") throw new HarnessError("the model cannot resume a paused goal; the user must resume it", "GOAL_TOOL_RESUME_PAUSED");
+				const goal = args.action === "pause" ? ctx.goals.pause(execution.agent, ref) : ctx.goals.resume(execution.agent, ref);
+				return Promise.resolve(goalValue(goal));
+			}
+			const authority = completionAuthority(ctx, execution);
+			if (hasText(args.objective) || hasRoundCap(args.max_goal_rounds)) throw new HarnessError("objective and max_goal_rounds are valid only with action edit", "GOAL_TOOL_INVALID_UPDATE");
+			if (args.action === "complete" && hasText(args.blocked_reason)) throw new HarnessError("blocked_reason is valid only with action blocked", "GOAL_TOOL_INVALID_UPDATE");
+			if (args.action === "blocked" && (args.blocked_reason === void 0 || args.blocked_reason.trim().length === 0)) throw new HarnessError("blocked_reason is required with action blocked", "GOAL_TOOL_INVALID_UPDATE");
+			if (args.action === "blocked" && authority.kind === "goal-round" && authority.goal.roundsStarted < resolved.blockedAfterConsecutiveRounds) throw new HarnessError(`blocked requires at least ${resolved.blockedAfterConsecutiveRounds} consecutive goal rounds; current round is ${authority.goal.roundsStarted}`, "GOAL_TOOL_BLOCK_THRESHOLD");
+			const goal = args.action === "complete" ? ctx.goals.complete(execution.agent, ref) : ctx.goals.block(execution.agent, ref, {
+				code: "model-reported",
+				message: args.blocked_reason
+			});
+			if (authority.kind === "goal-round") exec.deferContext(createUserMessage({
+				content: args.action === "complete" ? renderWrapupContext(goal.objective) : renderWrapupContext(goal.objective, args.blocked_reason),
+				source: {
+					kind: "tool-goal",
+					form: "notice",
+					summary: boundContextSummary(`${args.action}: ${goal.objective}`)
+				}
+			}));
+			return Promise.resolve(goalValue(goal));
+		},
+		presentCall: (args) => present(`${args.action === "blocked" ? "Mark" : args.action.charAt(0).toUpperCase() + args.action.slice(1)} goal`, "other", hasText(args.blocked_reason) ? args.blocked_reason : hasText(args.objective) ? args.objective : hasRoundCap(args.max_goal_rounds) ? args.max_goal_rounds : args.goal_id)
+	}));
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/types/authority.d.ts

@@ -0,0 +1,40 @@
+/** Execution-time authority checks for the model-facing goal tools. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@qlzt/dsh-agent';
+import type { GoalView } from '@qlzt/dsh-goal';
+import type { SessionEvent, SessionSeq } from '@qlzt/dsh-session';
+import type { ToolRunContext } from '@qlzt/dsh-tools';
+/** The calling agent plus the immutable event cut and open-turn start seq used for authority checks. */
+export interface GoalToolExecution {
+    readonly agent: Agent;
+    readonly events: readonly SessionEvent[];
+    readonly openTurnStartSeq: SessionSeq;
+}
+/** Hard authority granted to one state-changing call. */
+export type GoalToolAuthority = {
+    readonly kind: 'direct-human';
+} | {
+    readonly kind: 'goal-round';
+    readonly goal: GoalView;
+};
+/**
+ * Resolve and authenticate the calling agent and its driver boundary.
+ * @param ctx - Context carrying the live agent registry.
+ * @param exec - Tool execution metadata supplied by the registry.
+ * @returns The authenticated agent, immutable event cut, and open-turn boundary.
+ */
+export declare function goalToolExecution(ctx: Context, exec: ToolRunContext): GoalToolExecution;
+/**
+ * Require authority originating in a human message accepted by a runtime root.
+ * @param ctx - Context carrying the live agent graph.
+ * @param execution - Authenticated current tool execution.
+ */
+export declare function requireDirectHuman(ctx: Context, execution: GoalToolExecution): void;
+/**
+ * Resolve completion authority from either direct human input or the exact goal round.
+ * @param ctx - Context carrying live agents and goal state.
+ * @param execution - Authenticated current tool execution.
+ * @returns The direct-human or exact-goal-round authority grant.
+ */
+export declare function completionAuthority(ctx: Context, execution: GoalToolExecution): GoalToolAuthority;
+//# sourceMappingURL=authority.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Model-facing `get_goal`, `create_goal`, and `update_goal` tools over the
+ * persisted same-session goal domain.
+ * @module @qlzt/dsh-tool-goal
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { ContextFormed } from '@qlzt/dsh-llm';
+declare module '@qlzt/dsh-llm' {
+    interface MessageSourceMap {
+        'tool-goal': {
+            kind: 'tool-goal';
+        } & ContextFormed;
+    }
+}
+export declare const name = "tool-goal";
+export declare const inject: string[];
+/** Model policy and hard lower bounds for goal-state updates. */
+export interface Config {
+    /** Minimum admitted goal rounds before the model may self-report `blocked`. */
+    blockedAfterConsecutiveRounds?: number;
+}
+/** Schemastery config for the goal-tool policy. */
+export declare const Config: z<Config>;
+/** Register the three Codex-shaped goal tools and their shared policy section. */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/wrapup.d.ts

@@ -0,0 +1,12 @@
+/** Model-visible wrap-up instruction for a terminal autonomous goal update. */
+import type { ContentBlock } from '@qlzt/dsh-llm';
+/**
+ * Render the closing-message instruction injected after an autonomous goal
+ * round reports `complete` or `blocked`, replacing the former hard turn stop
+ * so the model still addresses the user once before the turn ends.
+ * @param objective - the terminal goal's objective, echoed for grounding.
+ * @param blockedReason - the validated report for `blocked`; omitted for `complete`.
+ * @returns a fresh one-block context for `ToolRunContext.deferContext()`.
+ */
+export declare function renderWrapupContext(objective: string, blockedReason?: string): ContentBlock[];
+//# sourceMappingURL=wrapup.d.ts.map

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "@qlzt/dsh-tool-goal",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "Model-facing same-session goal tools with execution-time authority checks",
+  "version": "0.2.1-alpha.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/zsping1989/deepseek-harness.git",
+    "directory": "packages/goal/tool-goal"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@qlzt/dsh-agent": "0.2.1-alpha.2",
+    "@qlzt/dsh-goal": "0.2.1-alpha.2",
+    "@qlzt/dsh-llm": "0.2.1-alpha.2",
+    "@qlzt/dsh-session": "0.2.1-alpha.2",
+    "@qlzt/dsh-system-prompt": "0.2.1-alpha.2",
+    "@qlzt/dsh-tools": "0.2.1-alpha.2",
+    "@deepseek-ai/cordis": "~4.0.5-alpha.1",
+    "@qlzt/dsh-session-projection": "0.2.1-alpha.2"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "~3.18.5-alpha.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis-plugin-loader": "~1.0.6-alpha.1",
+    "@deepseek-ai/dsh-agent": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-agent-loop-testkit": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-agent-loop": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-goal": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-llm": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-session": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-system-prompt": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-tools": "0.2.1-alpha.2",
+    "@deepseek-ai/cordis": "~4.0.5-alpha.1",
+    "@deepseek-ai/dsh-session-projection": "0.2.1-alpha.2"
+  },
+  "dsh": {}
+}