@x1a0f3n9/dsh-tool-skill 0.1.5-rc.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,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/skill/tool-skill/README.md
+README.md: eeee637c25bc38138deaf907e6bf73202f408b96
+README.zh.md: f2c1adf49a838e84fd488f0cb803d3aa30f8b8ca

package/README.md

@@ -0,0 +1,258 @@
+---
+description: "The model-facing skill catalog and loader tool for users and maintainers understanding what agents see, or configuring the session skill catalog."
+kind: "package-reference"
+---
+
+# @x1a0f3n9/dsh-tool-skill
+
+English | [中文](README.zh.md)
+
+## Summary
+
+Agents can discover and load skills during a session. Before the first request, when model-invocable skills exist and the `skill` tool is visible, they receive a durable catalog of available skill names and capped descriptions, and can use the `skill` tool to load full instructions. Users can invoke a user-invocable skill with `/name`, which injects the same instructions into that step. Catalog changes append a complete replacement, including an empty catalog that retires old names; configure `catalogDescriptionMaxLength` to limit each description.
+
+## 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 the plugin alongside the skill registry to give agents a session skill catalog and the `skill` loader tool. It requires `ctx.agents`, `ctx.tools`, and `ctx.skills`.
+
+### When to choose it
+
+Use it when agents should discover and load skills during a session. Skip it when skill loading is handled by another consumer or not needed at all — without it, providers and the registry still work, but nothing renders a catalog or a tool for the model.
+
+### Mount and configure
+
+Load the plugin together with the skill registry and at least one provider. The only configuration caps the normalized description length rendered in the catalog.
+
+```yaml
+- name: '@x1a0f3n9/dsh-skill'
+- name: '@x1a0f3n9/dsh-skill-filesystem'
+- name: '@x1a0f3n9/dsh-tool-skill'
+```
+
+| Field | Default | Meaning |
+|---|---|---|
+| `catalogDescriptionMaxLength` | `500` | Maximum normalized description length rendered in the session catalog; minimum 3 |
+
+The generated [configuration catalog](../../../docs/config-catalog.md#deepseek-aidsh-tool-skill) is the exhaustive source for every accepted field.
+
+### What the model gets
+
+- **A session catalog.** When model-invocable skills exist and the `skill` tool is visible, the agent receives a durable user-role message before its first request, listing each skill's name and a capped description; the message tells the model to load a skill with the tool before acting on it, and never to infer instructions from the summary alone.
+- **A loader tool.** The model calls `skill` with the exact skill name and receives the full instruction body plus resource guidance in a canonical `<skill_content>` block; the result is retained as ordinary tool history.
+- **Explicit user invocation.** A `/name` token in direct user input that names a user-invocable skill injects that skill's instructions into the step, without the model having to load it.
+- **Live catalog updates.** Later membership, description, or visibility changes append a complete replacement catalog; removing every skill appends an empty catalog that retires older names.
+
+### Observable success and failures
+
+Loading a listed skill returns its full instructions; the model sees one canonical shape whether the load came from the tool or from a user's explicit invocation. An invalid name reports `Error: invalid skill name "<name>"`, an unknown name reports the skill is unknown or no longer available, and a skill disabled for model invocation reports it is not available for model invocation. The catalog is omitted entirely when no catalog was ever published and either no model-invocable skills exist or the `skill` tool is hidden or shadowed; after a catalog has been published, either visibility loss — the `skill` tool hidden or shadowed by a same-name scoped tool — or removal of every skill instead appends an empty catalog that retires older names.
+
+-----
+
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+
+<details>
+<summary>Implementation internals — click to expand</summary>
+
+This section explains how the catalog and the invocation boundary are built; the observable behavior is fully covered in [Use this package](#use-this-package) and the Model Experience section below.
+
+### Design concept
+
+The package is built on two ideas. First, the catalog is a durable projection, diffed by a digest over the published entries rather than the rendered prose, so the `<system-reminder>` framing can never force a republish and consumers never re-parse the `<available_skills>` block. Second, one canonical rendering serves both load paths — the tool result and the user-explicit injection — through `renderSkillContent` shared from `dsh-skill`, so the model sees the same `<skill_content>` shape regardless of who initiated the load.
+
+### Source map
+
+| File | Role |
+|---|---|
+| [`src/index.ts`](src/index.ts) | Plugin entry: tool registration, catalog and gesture pre-step listeners, rendering and digest |
+| — | No runtime invariant companion is published; this model-facing adapter has no independent lifecycle stream; execution relations are owned by the capability seam it calls. |
+
+### Catalog lifecycle
+
+At each eligible `agent/pre-step`, the plugin snapshots the calling session's skill catalog, applies exact `skill` tool visibility, filters to model-invocable skills, and compares a digest of the entries against the newest visible `skill-catalog` message in the session log. When the digest changed, it hands the `enter` decision a durable user-role message containing the complete replacement catalog; an empty replacement explicitly retires earlier names. An incomplete provider snapshot emits nothing and preserves the last-good view for the next pre-step. The visibility check compares against the exact tool definition this plugin registered, so a scoped same-name shadow removes both the schema and its guidance; the plugin works mounted globally or inside one agent's composition.
+
+### Invocation boundary
+
+The `/name` gesture listener scans only claimed user messages: a whitespace-bounded token naming a user-invocable skill in the workspace catalog injects the same `<skill_content>` rendering as a `user`-role instructions context appended after every other injection. Unknown names and user-disabled skills stay ordinary prose. This is the only entry point for `disable-model-invocation` skills, which the catalog and the `skill` tool never expose.
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+Read these pages when the package-level contract is not enough. They move from the registry vocabulary behind the catalog to the exact tool schema and the design rationale.
+
+- [Skill subsystem reference](../../../docs/subsystems/skills.md) — the registry and provider vocabulary behind the catalog.
+- [skill package](../skill/README.md) — the registry and the shared `renderSkillContent` rendering.
+- [Generated tool catalog](../../../docs/tool-catalog.md#deepseek-aidsh-tool-skill) — the exact `skill` schema the model receives.
+- [User-explicit skill invocation Agent Note](../../../.agents/notes/archived/feature/2026-08-08-user-explicit-skill-invocation.md) — the `/name` gesture design.
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+### Session catalog
+
+#### What the model sees
+
+If model-invocable skills exist and this exact `skill` tool is visible, the agent receives the catalog template below as a durable user-role message before the first request, with one data-dependent entry per sorted skill. Later membership, description, or visibility changes append a complete replacement using the same `<available_skills>` envelope; deleting every skill appends an empty envelope with an explicit instruction not to use older names. The template's closing sentence is the rule against double-loading: the user-explicit gesture boundary (the pre-step listener below) injects the same `renderSkillContent` output (shared from `@x1a0f3n9/dsh-skill`) inline, and the catalog tells the model to follow that block instead of re-loading the skill through the tool; the replacement-catalog template carries the same anti-double-loading rule in both arms, including the emptied catalog.
+
+##### Skill catalog template
+
+```markdown
+<system-reminder>
+A skill is a reusable set of task-specific instructions. The following skills are available in this session:
+
+<available_skills>
+- `<name>`: <normalized-and-capped-description>
+</available_skills>
+
+If the user names a skill, or the task clearly matches a skill's description, call the `skill` tool with the exact skill name before taking task actions. Load all applicable skills, then follow their full instructions. This catalog contains summaries only; do not infer or follow a skill's instructions until it has been loaded.
+A user may also invoke a skill directly; its <skill_content> block then appears in this conversation. Follow it, and do not call the `skill` tool again for that skill.
+</system-reminder>
+```
+
+#### Token effect
+
+Repeated input cost scales with skill count and `catalogDescriptionMaxLength`; no initial catalog tokens are sent when the list is empty or the tool is hidden or shadowed. Each actual catalog change adds one retained complete replacement message.
+
+#### KV Cache effect
+
+The initial durable catalog is appended after the existing reusable prefix. Dynamic changes are append-only history after that catalog, so earlier reusable tokens stay intact while each newly appended catalog and later turns form a new suffix. A new or resumed instance with a changed digest may affect cache reuse from the newly appended catalog position.
+
+### Tool schema
+
+#### What the model sees
+
+The model sees the generated [`skill` schema](../../../docs/tool-catalog.md#deepseek-aidsh-tool-skill).
+
+#### Token effect
+
+Fixed schema cost per request where the tool is visible.
+
+#### KV Cache effect
+
+Prefix-stable while the tool definition and visibility are unchanged. Shadowing, restrictions, or plugin lifecycle changes may invalidate reuse from this schema.
+
+### Tool result
+
+#### What the model sees
+
+A successful call uses the result template and the provider-managed, directory, URL, or opaque resource guidance below.
+
+##### Skill result template
+
+```markdown
+<skill_content name="<escaped-name>">
+<skill_resources>
+<resource-guidance>
+</skill_resources>
+
+<skill_instructions>
+<provider-owned-instruction-body>
+</skill_instructions>
+</skill_content>
+```
+
+##### Provider-managed resource guidance
+
+```markdown
+Resources for this skill are managed by provider "<provider>".
+Load referenced resources only as needed.
+```
+
+##### Directory resource guidance
+
+```markdown
+Base directory for this skill: <path>
+Resolve relative paths mentioned by this skill against the base directory before using them. Load referenced resources only as needed.
+```
+
+##### URL resource guidance
+
+```markdown
+Base URL for this skill: <url>
+Resolve relative URLs mentioned by this skill against the base URL before using them. Load referenced resources only as needed.
+```
+
+##### Opaque resource guidance
+
+```markdown
+Resources for this skill: <description>
+Load referenced resources only as needed.
+```
+
+#### Token effect
+
+Loaded instructions are data-dependent tool-result tokens, resent on later steps until compaction; no duplicate `agent.inject()` copy is made.
+
+#### KV Cache effect
+
+Append-only; newly visible content follows the reusable request prefix and does not invalidate existing KV-cache entries.
+
+### Tool errors
+
+#### What the model sees
+
+Invalid or stale selections return exactly `Error: invalid skill name "<name>"`, `Error: skill "<name>" is unknown or no longer available`, or `Error: skill "<name>" is not available for model invocation`. Provider-thrown lookup text is data-dependent and receives the same `Error: <message>` wrapper.
+
+#### Token effect
+
+Only a failing call adds these retained tokens.
+
+#### KV Cache effect
+
+Append-only; newly visible content follows the reusable request prefix and does not invalidate existing KV-cache entries.
+
+### User-explicit invocation injection
+
+#### What the model sees
+
+A whitespace-bounded `/name` token anywhere in a claimed user message, naming a user-invocable skill in the workspace catalog, injects that skill's full `<skill_content>` rendering (the exact result-template shape above) as a `user`-role instructions context appended after every other injection of that step — background first, the material to act on last. Only direct user input is scanned, the check runs on the loaded definition, and unknown or user-disabled names stay ordinary prose. This is the sole entry point for `disable-model-invocation` skills, which the catalog and the `skill` tool never expose; the catalog's closing sentence tells the model to follow the injected block instead of re-loading it.
+
+#### Token effect
+
+Each gesture adds one rendered skill body to that turn as injected context — the same size as the tool result for the same skill, paid deterministically at the user's request instead of at the model's discretion. Repeated gestures for one skill within one step inject once.
+
+#### KV Cache effect
+
+Append-only; the injection lands after the reusable request prefix inside the step's message batch 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 catalog or the loader is a poor fit. They are current package constraints, not a task backlog.
+
+- **The catalog omits `whenToUse`, source, and provider metadata** — routing is based only on name and a capped description; `whenToUse` remains provider metadata and is not rendered by the loaded wrapper either.
+- **Loaded instruction bodies have no size cap** — a provider can return a skill large enough to consume substantial next-step context; only catalog descriptions are truncated.
+- **Resources are guidance, not attachments** — the tool reports a base directory/URL/opaque hint but neither enumerates nor fetches referenced files for the model.
+- **Loading is one-shot text** — there is no partial, streaming, or cached-content handle when a remote provider is slow or a skill body is large.
+- **Catalog replacement is whole-list** — one changed name or description appends every visible summary; this keeps stale-name retirement explicit but costs tokens proportional to the catalog.
+- **Bodies are not versioned** — body-only edits do not change the catalog digest or notify the model; a later tool call reads the current provider content while earlier tool results remain historical facts.
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -0,0 +1,258 @@
+---
+description: "面向模型的 skill（技能）目录与加载工具，供希望了解 agent（智能体）看到的内容或配置会话 skill 目录的用户与维护者阅读。"
+kind: "package-reference"
+---
+
+# @x1a0f3n9/dsh-tool-skill
+
+[English](README.md) | 中文
+
+## 概述
+
+agent 可以在会话期间发现并加载 skill。在首次请求前，如果存在模型可调用 skill 且 `skill` 工具可见，agent 会收到一份持久目录，列出可用 skill 的名称与有长度上限的描述，并可用 `skill` 工具加载完整指令。用户可以用 `/name` 调用某个用户可调用的 skill，把相同的指令注入该步骤。目录变更会追加一份完整替换，其中空目录会停用旧名称；可配置 `catalogDescriptionMaxLength` 来限制每条描述的长度。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
+
+与 skill 注册表一起挂载该插件，即可让 agent 拥有会话 skill 目录和 `skill` 加载工具。它需要 `ctx.agents`、`ctx.tools` 与 `ctx.skills`。
+
+### 何时选择
+
+当 agent 应在会话期间发现并加载 skill 时使用它。当 skill 加载由其他消费方处理或完全不需要时，请跳过——没有它，提供方与注册表仍可工作，但不会有任何东西为模型渲染目录或工具。
+
+### 挂载与配置
+
+与 skill 注册表和至少一个提供方一起加载该插件。唯一配置项限制目录中渲染的规范化描述长度。
+
+```yaml
+- name: '@x1a0f3n9/dsh-skill'
+- name: '@x1a0f3n9/dsh-skill-filesystem'
+- name: '@x1a0f3n9/dsh-tool-skill'
+```
+
+| 字段 | 默认值 | 含义 |
+|---|---|---|
+| `catalogDescriptionMaxLength` | `500` | 会话目录中渲染的规范化描述最大长度；最小为 3 |
+
+生成的[配置目录](../../../docs/config-catalog.zh.md#deepseek-aidsh-tool-skill)是每个受支持字段的穷尽式真源。
+
+### 模型得到什么
+
+- **会话目录。** 当存在模型可调用 skill 且 `skill` 工具可见时，agent 会在首次请求前收到一条持久的用户角色消息，列出每个 skill 的名称与有长度上限的描述；该消息告诉模型在着手任务前先用工具加载 skill，且绝不能仅凭摘要推断指令。
+- **加载工具。** 模型以精确的 skill 名称调用 `skill`，并收到完整指令正文以及规范的 `<skill_content>` 块中的资源指引；该结果作为普通工具历史保留。
+- **用户显式调用。** 直接用户输入中的 `/name` token 若指名某个用户可调用 skill，会把该 skill 的指令注入该步骤，而无需模型自行加载。
+- **实时目录更新。** 后续成员关系、描述或可见性变化会追加完整的替换目录；删除全部 skill 时会追加空目录，停用较早的名称。
+
+### 可观察的成功与失败
+
+加载列出的 skill 会返回其完整指令；无论加载来自工具还是用户的显式调用，模型看到的都是同一种规范形态。无效名称会报告 `Error: invalid skill name "<name>"`，未知名称会报告该 skill 未知或已不可用，被禁用模型调用的 skill 会报告其不可用于模型调用。如果从未发布过目录，并且不存在模型可调用 skill，或 `skill` 工具被隐藏或遮蔽，则会整体省略目录；目录发布后，无论可见性丧失——`skill` 工具被隐藏或被同名作用域工具遮蔽——还是删除全部 skill，都会改为追加空目录来停用旧名称。
+
+-----
+
+<a id="understand-the-implementation"></a>
+## 理解实现
+
+<details>
+<summary>实现细节——点击展开</summary>
+
+本节解释目录与调用边界如何构建；可观察行为已在[使用本包](#use-this-package)和下方模型体验章节中完整说明。
+
+### 设计理念
+
+本包建立在两个想法之上。第一，目录是一种持久投影，按已发布条目的 digest 而非渲染后的正文做差异比较，因此 `<system-reminder>` 包装永远不会强制重新发布，消费方也不需要重新解析 `<available_skills>` 块。第二，一条规范渲染服务两条加载路径——工具结果与用户显式注入——经由共享自 `dsh-skill` 的 `renderSkillContent`，因此无论加载由谁发起，模型看到的都是同一种 `<skill_content>` 形态。
+
+### 源码地图
+
+| 文件 | 职责 |
+|---|---|
+| [`src/index.ts`](src/index.ts) | 插件入口：工具注册、目录与手势 pre-step 监听器、渲染与 digest |
+| — | 不发布运行时不变式伴生入口；这个面向模型的适配器没有独立的生命周期流；执行关系由它调用的能力 seam 负责。 |
+
+### 目录生命周期
+
+在每次符合条件的 `agent/pre-step`，插件都会快照调用会话的 skill 目录，应用 `skill` 工具的精确可见性，过滤出模型可调用的 skill，并把条目 digest 与会话日志中最新可见的 `skill-catalog` 消息做比较。digest 变化时，它把包含完整替换目录的持久用户角色消息交给 `enter` 决策；空替换会显式停用较早的名称。提供方快照不完整时不发送任何内容，并为下一次 pre-step 保留最后一份可用视图。可见性检查针对本插件所注册的精确工具定义，因此作用域内同名的遮蔽项会同时移除 schema 及其指引；该插件既可全局挂载，也可挂在单个 agent 的组合内。
+
+### 调用边界
+
+`/name` 手势监听器只扫描已认领的用户消息：若某个以空白为界、指名工作区目录中用户可调用 skill 的 token 出现，则把同一份 `<skill_content>` 渲染作为 `user` 角色的指令上下文注入，追加在该步骤所有其他注入之后。未知名称与用户不可调用的名称保持为普通行文。这是 `disable-model-invocation` skill 唯一的入口，目录与 `skill` 工具永不暴露这类 skill。
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+当包级约定不够用时阅读以下页面。它们从目录背后的注册表词汇逐步进入精确工具 schema 与设计依据。
+
+- [skill 子系统参考](../../../docs/subsystems/skills.zh.md)——目录背后的注册表与提供方词汇。
+- [skill 包](../skill/README.zh.md)——注册表与共享的 `renderSkillContent` 渲染。
+- [生成工具目录](../../../docs/tool-catalog.zh.md#deepseek-aidsh-tool-skill)——模型接收的精确 `skill` schema。
+- [用户显式 skill 调用 Agent Note](../../../.agents/notes/archived/feature/2026-08-08-user-explicit-skill-invocation.md)——`/name` 手势设计。
+
+-----
+
+<a id="model-experience"></a>
+## 模型体验
+
+### 会话目录
+
+#### 模型看到什么
+
+如果存在模型可调用 skill，且可见的正是这个 `skill` 工具，agent 会在第一个请求之前收到下方目录模板，其中包含每个已排序 skill 的一条随数据而定的条目。该目录是一条持久的用户角色消息。后续成员关系、描述或可见性的变化会使用同一个 `<available_skills>` 信封追加完整替换；删除所有 skill 时，会追加一个空信封，并明确指示不得使用旧名称。模板的结尾一句是防止双重加载的规则：用户显式的手势边界（下文的 pre-step 监听器）会把同一份 `renderSkillContent` 输出（共享自 `@x1a0f3n9/dsh-skill`）内联注入，目录则告诉模型遵循该块，而不是再经工具重新加载该 skill；替换目录模板的两个分支——包括清空后的目录——都携带同一条防双重加载规则。
+
+##### Skill 目录模板
+
+```markdown
+<system-reminder>
+A skill is a reusable set of task-specific instructions. The following skills are available in this session:
+
+<available_skills>
+- `<name>`: <normalized-and-capped-description>
+</available_skills>
+
+If the user names a skill, or the task clearly matches a skill's description, call the `skill` tool with the exact skill name before taking task actions. Load all applicable skills, then follow their full instructions. This catalog contains summaries only; do not infer or follow a skill's instructions until it has been loaded.
+A user may also invoke a skill directly; its <skill_content> block then appears in this conversation. Follow it, and do not call the `skill` tool again for that skill.
+</system-reminder>
+```
+
+#### Token 影响
+
+重复输入成本随 skill 数量和 `catalogDescriptionMaxLength` 增长；当列表为空或工具被隐藏或遮蔽时，不会发送初始目录 token。每次实际目录变更都会添加一条保留的完整替换消息。
+
+#### KV Cache 影响
+
+初始持久目录追加在现有可重用前缀之后。动态变更作为该目录之后的仅追加历史，因此较早的可重用 token 保持不变，每条新追加的目录和后续轮次都会形成新的后缀。新建或恢复的实例如果 digest 发生变化，可能会从新追加的目录位置起影响缓存重用。
+
+### 工具 schema
+
+#### 模型看到什么
+
+模型会看到生成的 [`skill` schema](../../../docs/tool-catalog.zh.md#deepseek-aidsh-tool-skill)。
+
+#### Token 影响
+
+工具可见时，每次请求都有固定的 schema token 开销。
+
+#### KV Cache 影响
+
+工具定义和可见性不变时，前缀稳定。遮蔽、限制或插件生命周期变更可能从该 schema 起使重用失效。
+
+### 工具结果
+
+#### 模型看到什么
+
+成功调用使用下方结果模板，以及提供方管理的资源指引、目录资源指引、URL 资源指引或不透明资源指引。
+
+##### Skill 结果模板
+
+```markdown
+<skill_content name="<escaped-name>">
+<skill_resources>
+<resource-guidance>
+</skill_resources>
+
+<skill_instructions>
+<provider-owned-instruction-body>
+</skill_instructions>
+</skill_content>
+```
+
+##### 提供方管理的资源指引
+
+```markdown
+Resources for this skill are managed by provider "<provider>".
+Load referenced resources only as needed.
+```
+
+##### 目录资源指引
+
+```markdown
+Base directory for this skill: <path>
+Resolve relative paths mentioned by this skill against the base directory before using them. Load referenced resources only as needed.
+```
+
+##### URL 资源指引
+
+```markdown
+Base URL for this skill: <url>
+Resolve relative URLs mentioned by this skill against the base URL before using them. Load referenced resources only as needed.
+```
+
+##### 不透明资源指引
+
+```markdown
+Resources for this skill: <description>
+Load referenced resources only as needed.
+```
+
+#### Token 影响
+
+已加载指令是取决于数据的工具结果 token，并在后续步骤中重新发送，直到压缩；不会制作重复的 `agent.inject()` 副本。
+
+#### KV Cache 影响
+
+仅追加；新可见内容位于可重用请求前缀之后，不会使现有 KV Cache 条目失效。
+
+### 工具错误
+
+#### 模型看到什么
+
+无效或陈旧选择会精确返回 `Error: invalid skill name "<name>"`、`Error: skill "<name>" is unknown or no longer available` 或 `Error: skill "<name>" is not available for model invocation`。提供方抛出的查找文本取决于数据，并套用同一个 `Error: <message>` 包装层。
+
+#### Token 影响
+
+只有失败调用会添加这些已保留 token。
+
+#### KV Cache 影响
+
+仅追加；新可见内容位于可重用请求前缀之后，不会使现有 KV Cache 条目失效。
+
+### 用户显式调用注入
+
+#### 模型看到什么
+
+已认领用户消息中任意位置、以空白为界、指名工作区目录中某个用户可调用 skill 的 `/name` token，会把该 skill 的完整 `<skill_content>` 渲染（与上文结果模板完全相同的形态）作为 `user` 角色的指令上下文注入，追加在该步骤所有其他注入之后——背景在前，模型要着手处理的材料在最后。只扫描直接的用户输入，检查在已加载定义上进行，未知名称和用户不可调用的名称保持为普通行文。这是 `disable-model-invocation` skill 唯一的入口，目录和 `skill` 工具永不暴露这类 skill；目录的结尾一句会告诉模型遵循注入块，而不是重新加载它。
+
+#### Token 影响
+
+每次手势会把一份渲染后的 skill 正文作为注入上下文加进该轮次——尺寸与同一 skill 的工具结果相同，该成本会随用户请求必然产生，而非由模型自行决定。同一步骤内对同一 skill 的重复手势只注入一次。
+
+#### KV Cache 影响
+
+仅追加；注入落在该步骤的消息批次中、可重用请求前缀之后，不会使现有 KV Cache 条目失效。
+
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+这些限制说明目录或加载器何时不合适。它们是当前包约束，不是任务积压。
+
+- **目录省略 `whenToUse`、来源和提供方元数据**——路由只基于名称和有长度上限的描述；`whenToUse` 仍是提供方元数据，加载后的包装层也不渲染它。
+- **已加载指令正文没有大小上限**——提供方可返回足以占用大量下一步上下文的 skill；只有目录描述会被截断。
+- **资源是指引，而非附件**——工具报告基础目录/URL/不透明提示，但既不列举也不为模型获取引用文件。
+- **加载是一次性文本**——远程提供方缓慢或 skill 正文很大时，不提供部分内容、流式输出或缓存内容句柄。
+- **目录替换采用全量列表**——一个名称或描述发生变化，就会追加所有可见摘要；这样能显式停用陈旧名称，但 token 成本与目录大小成正比。
+- **正文不做版本化**——仅修改正文不会改变目录 digest，也不会通知模型；后续工具调用会读取提供方的当前内容，而先前工具结果仍是历史事实。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/index.js

@@ -0,0 +1,396 @@
+import { createHash } from "node:crypto";
+import z from "@deepseek-ai/schemastery";
+import { defineTool } from "@x1a0f3n9/dsh-tools";
+import { createUserMessage } from "@x1a0f3n9/dsh-llm";
+import "@deepseek-ai/cordis";
+import { escapeText, isModelInvocable, isSkillName, isUserInvocable, renderSkillContent } from "@x1a0f3n9/dsh-skill";
+//#region ../../util/brand/src/index.ts
+/**
+* Apply a compile-time number brand without changing the value.
+* @param value - number admitted by the domain that owns the target brand.
+* @returns the same number with the requested compile-time brand.
+*/
+function brandNumber(value) {
+	return value;
+}
+//#endregion
+//#region ../../core/session/src/types.ts
+/**
+* Admit a numeric value as an existing Session event position.
+* @param value - non-negative safe integer admitted by the owning log operation.
+* @returns the same number with the Session-sequence brand.
+*/
+function SessionSeq(value) {
+	if (!Number.isSafeInteger(value) || value < 0 || Object.is(value, -0)) throw new TypeError(`SessionSeq must be a non-negative safe integer, got ${String(value)}`);
+	return brandNumber(value);
+}
+//#endregion
+//#region lib/types/index.js
+/**
+* Durable session skill catalog and model-facing `skill` loader tool.
+*
+* @module @x1a0f3n9/dsh-tool-skill
+*/
+const name = "tool-skill";
+const inject = [
+	"agents",
+	"tools",
+	"skills"
+];
+const DEFAULT_CATALOG_DESCRIPTION_MAX_LENGTH = 500;
+/** Durable entry list mirroring the rendered catalog lines, for non-model consumers. */
+function catalogSourceEntries(skills, descriptionMaxLength) {
+	return skills.map((skill) => ({
+		name: skill.name,
+		description: catalogDescription(skill.description, descriptionMaxLength)
+	}));
+}
+/** Validate and default the model-facing skill catalog configuration. */
+const Config = z.object({ catalogDescriptionMaxLength: z.number().default(DEFAULT_CATALOG_DESCRIPTION_MAX_LENGTH) });
+/**
+* Register the model-facing skill loader and its visibility-matched
+* durable session catalog. The catalog is emitted only when the calling agent
+* resolves this plugin's exact tool registration; a restriction or scoped
+* same-name shadow therefore removes both the schema and its call guidance.
+*/
+function apply(ctx, config = {}) {
+	const catalogDescriptionMaxLength = config.catalogDescriptionMaxLength ?? DEFAULT_CATALOG_DESCRIPTION_MAX_LENGTH;
+	assertPositiveInteger("catalogDescriptionMaxLength", catalogDescriptionMaxLength, 3);
+	const skillTool = defineTool({
+		name: "skill",
+		description: "Load the full instructions for an available skill. Call this with the exact skill name from the session skill catalog before acting on a task that names or clearly matches that skill.",
+		parameters: { name: {
+			type: "string",
+			required: true,
+			description: "The exact skill name from the available skills list."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					name: {
+						type: "string",
+						required: true
+					},
+					provider: {
+						type: "string",
+						required: true
+					},
+					resourceBase: { oneOf: [
+						{
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								kind: {
+									type: "string",
+									required: true,
+									const: "directory"
+								},
+								path: {
+									type: "string",
+									required: true
+								}
+							}
+						},
+						{
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								kind: {
+									type: "string",
+									required: true,
+									const: "url"
+								},
+								url: {
+									type: "string",
+									required: true
+								}
+							}
+						},
+						{
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								kind: {
+									type: "string",
+									required: true,
+									const: "opaque"
+								},
+								description: {
+									type: "string",
+									required: true
+								}
+							}
+						}
+					] },
+					content: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: renderSkillContent(value)
+			}]
+		},
+		async execute(args, exec) {
+			if (!isSkillName(args.name)) throw new Error(`invalid skill name "${args.name}"`);
+			const lookup = {
+				cwd: exec.agent?.session.header.cwd,
+				signal: exec.signal,
+				scope: exec.agent
+			};
+			const summary = (await ctx.skills.list(lookup)).find((skill) => skill.name === args.name);
+			if (!summary) throw new Error(`skill "${args.name}" is unknown or no longer available`);
+			if (!isModelInvocable(summary)) throw new Error(`skill "${args.name}" is not available for model invocation`);
+			const skill = await ctx.skills.get(args.name, lookup);
+			if (!skill) throw new Error(`skill "${args.name}" is unknown or no longer available`);
+			if (!isModelInvocable(skill)) throw new Error(`skill "${args.name}" is not available for model invocation`);
+			return {
+				name: skill.name,
+				provider: skill.provider,
+				...skill.resourceBase !== void 0 ? { resourceBase: { ...skill.resourceBase } } : {},
+				content: skill.content
+			};
+		},
+		presentCall(args) {
+			return {
+				card: "generic",
+				title: `Load skill ${args.name}`,
+				kind: "read",
+				rawInput: args.name
+			};
+		}
+	});
+	ctx.tools.register(skillTool);
+	ctx.on("agent/pre-step", async ({ agent, messages, signal }, next) => {
+		const decision = await next();
+		if (decision.kind === "reject") return decision;
+		const names = invokedSkillNames(messages);
+		if (names.length === 0) return decision;
+		signal.throwIfAborted();
+		const lookup = {
+			cwd: agent.session.header.cwd,
+			signal,
+			scope: agent
+		};
+		const injections = [];
+		for (const name of names) {
+			const skill = await ctx.skills.get(name, lookup);
+			signal.throwIfAborted();
+			if (skill === void 0 || !isUserInvocable(skill)) continue;
+			const source = {
+				kind: "skill-invocation",
+				name,
+				form: "instructions"
+			};
+			injections.push(createUserMessage({
+				content: [{
+					type: "text",
+					text: renderSkillContent(skill)
+				}],
+				source
+			}));
+		}
+		if (injections.length === 0) return decision;
+		return {
+			...decision,
+			messages: [...decision.messages, ...injections]
+		};
+	});
+	ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
+		const decision = await next();
+		if (decision.kind === "reject") return decision;
+		signal.throwIfAborted();
+		const snapshot = ctx.tools.get(skillTool.name, agent) === skillTool ? await ctx.skills.snapshot({
+			cwd: agent.session.header.cwd,
+			signal,
+			scope: agent
+		}) : {
+			skills: [],
+			complete: true
+		};
+		signal.throwIfAborted();
+		if (!snapshot.complete) return decision;
+		const skills = snapshot.skills.filter(isModelInvocable);
+		const entries = catalogSourceEntries(skills, catalogDescriptionMaxLength);
+		const digest = digestCatalogEntries(entries);
+		const history = catalogHistory(agent);
+		const existing = catalogMessage(decision.messages);
+		if (history.visibleDigest === digest) return existing === void 0 ? decision : {
+			...decision,
+			messages: decision.messages.filter((message) => message.id !== existing.message.id)
+		};
+		if (existing !== void 0 && digestCatalogEntries(existing.entries) === digest) return decision;
+		if (!history.published && skills.length === 0) return existing === void 0 ? decision : {
+			...decision,
+			messages: decision.messages.filter((message) => message.id !== existing.message.id)
+		};
+		const catalog = history.published ? renderCatalogUpdate(entries) : renderCatalogMessage(entries);
+		return {
+			...decision,
+			messages: existing === void 0 ? [...decision.messages, catalog] : decision.messages.map((message) => message.id === existing.message.id ? catalog : message)
+		};
+	});
+}
+function renderCatalogMessage(entries) {
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text: [
+				"<system-reminder>",
+				"A skill is a reusable set of task-specific instructions. The following skills are available in this session:",
+				"",
+				"<available_skills>",
+				...renderCatalogEntries(entries),
+				"</available_skills>",
+				"",
+				"If the user names a skill, or the task clearly matches a skill's description, call the `skill` tool with the exact skill name before taking task actions. Load all applicable skills, then follow their full instructions. This catalog contains summaries only; do not infer or follow a skill's instructions until it has been loaded.",
+				"A user may also invoke a skill directly; its <skill_content> block then appears in this conversation. Follow it, and do not call the `skill` tool again for that skill.",
+				"</system-reminder>"
+			].join("\n")
+		}],
+		source: {
+			kind: "skill-catalog",
+			form: "catalog",
+			entries
+		}
+	});
+}
+function renderCatalogUpdate(entries) {
+	const availability = entries.length === 0 ? ["No skills are currently available through the `skill` tool. Do not use names from earlier skill catalogs.", "A user may still invoke a skill directly; its <skill_content> block then appears in this conversation. Follow it, and do not call the `skill` tool for it."] : ["Use only names in this replacement catalog. If the user names a listed skill, or the task clearly matches its description, call the `skill` tool with the exact name before acting.", "A user may also invoke a skill directly; its <skill_content> block then appears in this conversation. Follow it, and do not call the `skill` tool again for that skill."];
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text: [
+				"<system-reminder>",
+				"The available skill catalog changed. This complete catalog replaces every earlier available-skills list in this session:",
+				"",
+				"<available_skills>",
+				...renderCatalogEntries(entries),
+				"</available_skills>",
+				"",
+				...availability,
+				"</system-reminder>"
+			].join("\n")
+		}],
+		source: {
+			kind: "skill-catalog",
+			form: "catalog",
+			update: true,
+			entries
+		}
+	});
+}
+/**
+* Model-facing catalog lines, projected from the same entries the source records.
+* The pseudo-XML escaping belongs to this frame, not to the published fact, so it
+* is applied here and never stored. Names are `isSkillName`-validated and carry
+* no escapable character.
+*/
+function renderCatalogEntries(entries) {
+	return entries.map((entry) => `- \`${entry.name}\`: ${escapeText(entry.description)}`);
+}
+/**
+* Catalog identity over the durable entry list rather than the rendered prose.
+* The entries are what changes; the surrounding `<system-reminder>` framing is
+* written for the model and must not decide whether a republish is needed.
+*/
+function digestCatalogEntries(entries) {
+	const canonical = entries.map((entry) => JSON.stringify([entry.name, entry.description])).join("\n");
+	return createHash("sha256").update(canonical).digest("hex");
+}
+/**
+* Entries of one durable catalog message, or undefined when the record is not a
+* usable catalog.
+*
+* `agent.session.snapshotEvents()` may contain a resumed, forked, or externally written seed,
+* and seed validation only guarantees a source object with a non-empty `kind`;
+* no per-kind field is checked there. An unreadable record is therefore treated
+* as "not this plugin's catalog" — the posture the replaced content digest had —
+* rather than throwing inside the step listener, which would fail every
+* subsequent turn of that session.
+*/
+function readCatalogEntries(source) {
+	const entries = source.entries;
+	if (!Array.isArray(entries)) return void 0;
+	const readable = [];
+	for (const entry of entries) {
+		if (typeof entry !== "object" || entry === null) return void 0;
+		const { name, description } = entry;
+		if (typeof name !== "string" || name === "" || typeof description !== "string") return void 0;
+		readable.push({
+			name,
+			description
+		});
+	}
+	return readable;
+}
+function catalogHistory(agent) {
+	const visible = new Set(agent.session.surface.nodes);
+	let published = false;
+	for (let index = agent.session.seq - 1; index >= 0; index -= 1) {
+		const event = agent.session.eventAt(SessionSeq(index));
+		if (event === void 0) throw new Error(`skill catalog cannot read seq ${String(index)} below the current Session length`);
+		if (event.type !== "user/message" || event.data.source.kind !== "skill-catalog") continue;
+		const entries = readCatalogEntries(event.data.source);
+		if (entries === void 0) continue;
+		const digest = digestCatalogEntries(entries);
+		published = true;
+		if (visible.has(event.seq)) return {
+			visibleDigest: digest,
+			published
+		};
+	}
+	return { published };
+}
+function catalogMessage(messages) {
+	for (const message of messages) {
+		if (message.source.kind !== "skill-catalog") continue;
+		const entries = readCatalogEntries(message.source);
+		if (entries !== void 0) return {
+			message,
+			entries
+		};
+	}
+}
+function catalogDescription(value, maxLength) {
+	const normalized = value.replaceAll(/\s+/g, " ").trim();
+	return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 3)}...`;
+}
+function assertPositiveInteger(name, value, minimum = 1) {
+	if (!Number.isInteger(value) || value < minimum) throw new Error(`tool-skill: ${name} must be an integer greater than or equal to ${minimum}`);
+}
+/**
+* A whitespace-bounded `/name` token (the public skill-name grammar) anywhere
+* in the text — the same word-boundary shape the transcript chip decoration
+* uses, so a gesture reads as one wherever it sits in the sentence. A second
+* `/` or any non-boundary character breaks the match, which keeps file paths
+* (`/usr/bin`) and fractions (`5/8`) out.
+*/
+const SKILL_GESTURE = /(^|\s)\/([a-z0-9]+(?:-[a-z0-9]+)*)(?=\s|$)/g;
+/**
+* `/name` gesture tokens from the claimed user messages, deduplicated in
+* first-seen order. Every text block of direct user input is scanned; no
+* other source can forge a gesture.
+* @param messages - the step's claimed batch.
+* @returns candidate skill names, unvalidated against the registry.
+*/
+function invokedSkillNames(messages) {
+	const names = [];
+	for (const message of messages) {
+		if (message.source.kind !== "user") continue;
+		for (const block of message.content) {
+			if (block.type !== "text") continue;
+			for (const match of block.text.matchAll(SKILL_GESTURE)) {
+				const name = match[2];
+				if (name !== void 0 && !names.includes(name)) names.push(name);
+			}
+		}
+	}
+	return names;
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Durable session skill catalog and model-facing `skill` loader tool.
+ *
+ * @module @x1a0f3n9/dsh-tool-skill
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export declare const name = "tool-skill";
+export declare const inject: string[];
+/**
+ * Durable provider and item records for one published session skill catalog. The catalog is a
+ * `catalog`-form context, so it records the entries it published beside the
+ * model-facing prose: a consumer presenting the list must not re-parse the
+ * `<available_skills>` block, whose framing exists for the model.
+ */
+export interface SkillCatalogSource {
+    readonly kind: 'skill-catalog';
+    readonly form: 'catalog';
+    /** Marks a replacement catalog rather than this session's first publication. */
+    readonly update?: true;
+    /** Exactly the entries this message published, in catalog order. */
+    readonly entries: readonly {
+        readonly name: string;
+        readonly description: string;
+    }[];
+}
+declare module '@x1a0f3n9/dsh-llm' {
+    interface MessageSourceMap {
+        'skill-catalog': SkillCatalogSource;
+    }
+}
+/** Model-facing skill catalog configuration. */
+export interface Config {
+    /** Maximum normalized description length rendered in the session catalog; minimum 3. */
+    catalogDescriptionMaxLength?: number;
+}
+/** Validate and default the model-facing skill catalog configuration. */
+export declare const Config: z<Config>;
+/**
+ * Register the model-facing skill loader and its visibility-matched
+ * durable session catalog. The catalog is emitted only when the calling agent
+ * resolves this plugin's exact tool registration; a restriction or scoped
+ * same-name shadow therefore removes both the schema and its call guidance.
+ */
+export declare function apply(ctx: Context, config?: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@x1a0f3n9/dsh-tool-skill",
+  "description": "Model-facing skill loading tool for the DeepSeek Harness",
+  "version": "0.1.5-rc.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/skill/tool-skill"
+  },
+  "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": {
+    "@x1a0f3n9/dsh-agent": "^0.1.5-rc.2",
+    "@x1a0f3n9/dsh-skill": "^0.1.5-rc.2",
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@x1a0f3n9/dsh-llm": "^0.1.5-rc.2",
+    "@x1a0f3n9/dsh-tools": "^0.1.5-rc.2"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.2"
+  },
+  "devDependencies": {
+    "@x1a0f3n9/dsh-session": "^0.1.5-rc.2",
+    "@x1a0f3n9/dsh-llm": "^0.1.5-rc.2",
+    "@x1a0f3n9/dsh-agent-loop-testkit": "^0.1.5-rc.2",
+    "@x1a0f3n9/dsh-skill": "^0.1.5-rc.2",
+    "@x1a0f3n9/dsh-agent": "^0.1.5-rc.2",
+    "@x1a0f3n9/dsh-scope": "^0.1.5-rc.2",
+    "@x1a0f3n9/dsh-tools": "^0.1.5-rc.2",
+    "@x1a0f3n9/dsh-skill-filesystem": "^0.1.5-rc.2",
+    "@deepseek-ai/cordis": "^4.0.2"
+  }
+}