@deepseek-ai/dsh-experimental-tool-agent-team 0.1.5-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,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/experimental/tool-agent-team/README.md
+README.md: 58e2853a863710ec094f61b0af04a0fe9b6bd4ce
+README.zh.md: 63b24c3772ea277a11b2bc4c456d56bbfaa0a772

package/README.md

@@ -0,0 +1,158 @@
+---
+description: "Nine tools that let the model create, message, and coordinate teammates, for compositions mounting the experimental Team plugins."
+kind: "package-reference"
+---
+
+# @deepseek-ai/dsh-experimental-tool-agent-team
+
+English | [中文](README.zh.md)
+
+## Summary
+
+This package lets the model create named teammates, send them messages, inspect availability, wait for progress, interrupt stuck work, and coordinate through a shared task board. Every team member receives the same nine tools and guidance for coordinating in a shared workspace. Choose it when the model should operate a team only after you explicitly request one. It replaces legacy subagent controls with the same tool names, so compositions that need both must disable the legacy definitions. The package is published under its experimental name and provides no stability guarantee.
+
+## 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
+
+Add this package on top of `@deepseek-ai/dsh-experimental-agent-team` when the model should run a team through tools. Once mounted, every team member — the Lead and each teammate — gets the same nine tools plus a policy paragraph that states its own role and name.
+
+### When to choose it
+
+Choose it when the model should create and coordinate teammates by itself rather than a human driving subagent controls. Avoid it when the legacy global subagent tools with the same names must stay available: the team tools replace them for team members, so a composition that wants both must disable the legacy definitions. The fixed policy creates teammates only when you explicitly ask for a team or teammates, so ordinary tasks never trigger delegation on their own.
+
+### Smallest working example
+
+The smallest addition to an existing composition is the two-package fragment from the [agent-team README](../agent-team/README.md#smallest-working-setup): durable session storage, the team domain package, and this package. The plugin itself takes two optional settings:
+
+```yaml
+- id: tool-agent-team
+  name: '@deepseek-ai/dsh-experimental-tool-agent-team'
+  config:
+    freshProvider: spawn
+    forkProvider: fork
+```
+
+| Field | Default | Meaning |
+|---|---|---|
+| `freshProvider` | `spawn` | Provider that starts fresh teammates |
+| `forkProvider` | `fork` | Provider that starts fork teammates |
+
+The generated [configuration catalog](../../../docs/config-catalog.md#deepseek-aidsh-experimental-tool-agent-team) is the exhaustive source for every accepted field and its JSDoc.
+
+Try it by asking the Lead model: "create a teammate named reviewer to check the diff, then send reviewer the change summary". The model calls the creation tool and then the messaging tool.
+
+### What the model can do
+
+The nine tools group into four capabilities:
+
+- **Create a teammate** — `spawn_teammate` takes a name, a description, and the initial task; only the Lead can call it.
+- **Send messages** — `send_message` steers a running member at its nearest step boundary, starts an idle member, and cold-resumes an inactive teammate.
+- **See and wait** — `list_agents` shows the roster with live status; `wait_agent` waits for the next team change; `interrupt_agent` stops a teammate's current turn (Lead only).
+- **Manage the task board** — `team_task_create`, `team_task_list`, `team_task_get`, and `team_task_update` add, browse, read, and update shared tasks.
+
+Any member can message any other member and use the task board; only the Lead creates and interrupts teammates. Task updates keep the domain's owner and revision checks, so an outdated edit is rejected instead of overwriting newer work.
+
+### What success and failure look like
+
+Sending a message succeeds as soon as it is safely stored: the result is `accepted` (delivered now) or `queued` (waiting), and a queued message must not be resent. `wait_agent` returns `noProgress` right away when no other member is running or provisioning, telling the caller to wake a teammate first; otherwise it waits for the next change and the caller re-reads state afterward. Task edits based on an outdated revision are rejected rather than overwriting newer work.
+
+-----
+
+<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 adapter and points at the code that realizes them; the observable behavior is fully covered in [Use this package](#use-this-package).
+
+### Design philosophy
+
+The adapter is built on three commitments:
+
+- **Scoped, not global.** Every registration lives on the member Agent's own `ctx`; nothing is installed for non-Team subagents or the host.
+- **Declared results, compact JSON.** Every tool declares its complete result schema and renders that value as compact JSON, so the compiler checks `execute` against what the model is promised and no result spends tokens on indentation.
+- **The domain owns authority.** Tools delegate to `ctx.agentTeams`, which enforces Lead authority and revision checks; the adapter adds no weaker path.
+
+The [Agent Teams Agent Note](../../../.agents/notes/implemented/feature/2026-08-05-agent-teams.md) owns the model-facing and scoping decisions.
+
+### Source map
+
+| File | Role |
+|---|---|
+| [`src/index.ts`](src/index.ts) | Plugin entry: config, the fixed policy text, and the nine scoped tool registrations |
+| — | No runtime invariant companion is published; the Team service owns durable and authorization relations. |
+
+### Policy and tools
+
+One `team:policy` section on the member scope teaches each member its role and the coordination rules; the fixed text and the nine tool registrations are declared in [`src/index.ts`](src/index.ts). The nine tool schemas appear only in Team member scopes, so non-Team subagents keep the default catalog. Scoped registrations with the same names as the legacy global continuable-subagent controls shadow those globals for team members only.
+
+### Scoped registration and teardown
+
+`maybeInstall` runs for every live Agent and subscribes to `agent/created`; it skips Agents without Team membership. Disposal of an Agent runs the installed disposer, and plugin HMR disposes every installed scope before reinstall. Each disposer unwinds registrations in reverse order, so a failed install cannot leave a partial scope.
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+Read these pages when the package-level contract is not enough. They move from the domain service to the exact schemas and the decisions behind the design.
+
+- [agent-team package](../agent-team/README.md) — the `ctx.agentTeams` domain service behind these tools.
+- [Agent Teams subsystem](../../../docs/subsystems/agent-team.md) — durable Team types and service API.
+- [Generated tool catalog](../../../docs/tool-catalog.md#deepseek-aidsh-experimental-tool-agent-team) — every tool schema the model receives.
+- [Agent Teams Agent Note](../../../.agents/notes/implemented/feature/2026-08-05-agent-teams.md) — model-facing, scoping, and isolation decisions.
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+### Team policy and tools
+
+#### What the model sees
+
+One stable policy section states the exact Team role/name/id, the explicit-delegation requirement, shared-cwd behavior, filesystem stale-version recovery, Bash/formatter/codegen risk, task and write-scope coordination, Steer delivery, the no-retry mailbox rule, and the Lead's duty to wait before answering. The nine Team schemas from `spawn_teammate` through `team_task_update` appear only in Team member scopes.
+
+#### Token effect
+
+Fixed policy and schema cost on every Team member request. Tool calls add compact JSON roster, task, wait, or receipt results. Peer content is retained by the Team domain in the target's history.
+
+#### KV Cache effect
+
+Prefix-stable while the Team plugin generation, configuration, member role/name, and schemas remain unchanged. The per-member identity line differs across Agents. Tool results and peer messages append after the reusable request prefix.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+These limits describe what the policy and tools cannot guarantee for a team. They are current package constraints, not a comparison with other collaboration surfaces.
+
+- **Prompt policy is coordination, not confinement** — it cannot stop Bash or external processes from writing overlapping files.
+- **No autonomous team creation** — ordinary tasks do not trigger delegation unless the user explicitly requests it.
+- **No Web controls** — browser roster and task-board presentation is outside this runtime package.
+- **Experimental prototype with no stability promise** — the package is public, but its schemas can change freely while it incubates.
+
+<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,158 @@
+---
+description: "九个让模型创建、发消息与协调 teammate 的工具，供组合实验性 Team 插件的部署方阅读。"
+kind: "package-reference"
+---
+
+# @deepseek-ai/dsh-experimental-tool-agent-team
+
+[English](README.md) | 中文
+
+## 概述
+
+本包让模型创建具名 teammate、向它们发送消息、查看可用状态、等待进展、中断卡住的工作，并通过共享任务板协调。每个团队成员都会获得相同的九个工具，以及在共享工作区协调的指引。当模型只应在你明确要求后运行团队时，选择本包。它会取代同名的旧版 subagent 控件，因此同时需要两者的组合必须禁用旧定义。本包以实验性名称公开发布，但不提供稳定性保证。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
+
+当模型应该通过工具运行一支团队时，在 `@deepseek-ai/dsh-experimental-agent-team` 之上挂载本包。挂载后，每个团队成员——Lead 与每个 teammate——都会获得相同的九个工具，外加一段说明自身角色与名字的策略段落。
+
+### 何时选择
+
+当模型应该自行创建与协调 teammate、而不是由人来操作 subagent 控件时，选择它。当同名的旧全局 subagent 工具必须继续可用时，请不要选择：团队工具会为团队成员取代它们，因此想同时使用两者的组合必须禁用旧定义。固定策略只在明确要求团队或 teammate 时创建成员，因此普通任务永远不会自行触发委派。
+
+### 最小工作示例
+
+对现有组合的最小增量是 [agent-team README](../agent-team/README.zh.md#smallest-working-setup) 中的两包片段：持久会话存储、团队领域包与本包。插件本身只有两个可选设置：
+
+```yaml
+- id: tool-agent-team
+  name: '@deepseek-ai/dsh-experimental-tool-agent-team'
+  config:
+    freshProvider: spawn
+    forkProvider: fork
+```
+
+| 字段 | 默认值 | 含义 |
+|---|---|---|
+| `freshProvider` | `spawn` | 启动 fresh teammate 的 provider |
+| `forkProvider` | `fork` | 启动 fork teammate 的 provider |
+
+生成的[配置目录](../../../docs/config-catalog.zh.md#deepseek-aidsh-experimental-tool-agent-team)是每个受支持字段及其 JSDoc 的穷尽式真源。
+
+试试这样要求 Lead 模型：「创建一个名为 reviewer 的 teammate 检查 diff，再把变更摘要发给 reviewer」。模型会调用创建工具，然后调用消息工具。
+
+### 模型能做什么
+
+九个工具分为四类能力：
+
+- **创建 teammate**——`spawn_teammate` 接收名字、描述与初始任务；只有 Lead 可以调用它。
+- **发送消息**——`send_message` 在最近的步骤边界 Steer running member、启动 idle member，并冷恢复 inactive teammate。
+- **查看与等待**——`list_agents` 显示带实时状态的 roster；`wait_agent` 等待下一次团队变化；`interrupt_agent` 停止 teammate 的当前轮次（仅限 Lead）。
+- **管理任务板**——`team_task_create`、`team_task_list`、`team_task_get` 与 `team_task_update` 添加、浏览、读取与更新共享任务。
+
+任何成员都可以给任何其他成员发消息并使用任务板；只有 Lead 可以创建与中断 teammate。任务更新保留领域的 owner 与 revision 校验，因此过期的编辑会被拒绝，而不是覆盖更新的成果。
+
+### 成功与失败的表现
+
+发送消息在安全存储后即成功：结果为 `accepted`（已送达）或 `queued`（等待中），排队的消息绝不能重发。当没有其他成员 running 或 provisioning 时，`wait_agent` 会立即返回 `noProgress`，提示调用方先唤醒 teammate；否则它会等待下一次变化，调用方随后重新读取状态。基于过期 revision 的任务编辑会被拒绝，而不是覆盖更新的成果。
+
+-----
+
+<a id="understand-the-implementation"></a>
+## 理解实现
+
+<details>
+<summary>实现细节——点击展开</summary>
+
+本节解释适配器背后的设计决策并指出实现它们的代码位置；可观察行为已在[使用本包](#use-this-package)中完整说明。
+
+### 设计理念
+
+适配器建立在三项承诺之上：
+
+- **按作用域，而非全局。** 每个注册都位于成员 Agent 自己的 `ctx` 上；非 Team subagent 或宿主不会安装任何内容。
+- **声明式结果，紧凑 JSON。** 每个工具都声明完整结果 schema，并把该值渲染为紧凑 JSON，因此编译器会对照模型被承诺的值检查 `execute`，任何结果都不会在缩进上消耗 token。
+- **领域拥有权限。** 工具委托给 `ctx.agentTeams`，后者强制执行 Lead 权限与 revision 校验；适配器不添加更弱的路径。
+
+[Agent Teams Agent Note](../../../.agents/notes/implemented/feature/2026-08-05-agent-teams.zh.md)负责模型侧与 scoping 决策。
+
+### 源码地图
+
+| 文件 | 职责 |
+|---|---|
+| [`src/index.ts`](src/index.ts) | 插件入口：配置、固定策略文本与九个 scoped 工具注册 |
+| — | 不发布运行时不变式伴生入口；Team 服务拥有持久化与授权关系。 |
+
+### 策略与工具
+
+member scope 上的一个 `team:policy` 段落教每个成员自己的角色与协作规则；固定文本与九个工具注册都声明在 [`src/index.ts`](src/index.ts)。九个工具 schema 只出现在 Team member scope 中，因此非 Team subagent 保持默认目录。与旧全局 continuable-subagent 控件同名的 scoped 注册只会为团队成员覆盖这些全局控件。
+
+### 按作用域注册与拆除
+
+`maybeInstall` 对每个 live Agent 运行，并订阅 `agent/created`；它跳过没有 Team 成员关系的 Agent。Agent dispose 会运行已安装的 disposer，插件 HMR 会在重新安装前处置每个已安装的 scope。每个 disposer 按逆序展开注册，因此失败的安装不会留下残缺 scope。
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+当包级约定不够用时阅读以下页面。它们从领域服务逐步进入精确 schema 与设计背后的决策。
+
+- [agent-team 包](../agent-team/README.zh.md)——这些工具背后的 `ctx.agentTeams` 领域服务。
+- [Agent Teams 子系统](../../../docs/subsystems/agent-team.zh.md)——持久 Team 类型与服务 API。
+- [生成的工具目录](../../../docs/tool-catalog.zh.md#deepseek-aidsh-experimental-tool-agent-team)——模型接收的每个工具 schema。
+- [Agent Teams Agent Note](../../../.agents/notes/implemented/feature/2026-08-05-agent-teams.zh.md)——模型侧、scoping 与隔离决策。
+
+-----
+
+<a id="model-experience"></a>
+## 模型体验
+
+### Team 策略与工具
+
+#### 模型看到什么
+
+一段稳定策略会说明确切 Team role／name／id、显式 delegation 要求、共享 cwd 行为、文件 stale-version 恢复、Bash／formatter／codegen 风险、task／write-scope 协调、Steer 投递、mailbox 不重试规则，以及 Lead 必须在回答前等待。`spawn_teammate` 到 `team_task_update` 的九个 Team schema 只出现在 Team member scope。
+
+#### Token 影响
+
+每次 Team member 请求都有固定策略与 schema 成本。工具调用会增加紧凑 JSON roster、task、wait 或 receipt 结果。Peer 内容由 Team 领域保留在 target 历史中。
+
+#### KV Cache 影响
+
+Team 插件 generation、配置、member role／name 与 schema 不变时，前缀保持稳定。每个成员的身份行不同。工具结果与 peer 消息追加在可复用请求前缀之后。
+
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+这些限制说明策略与工具无法为一支团队保证什么。它们是当前包约束，不是与其他协作表面的对比。
+
+- **提示词策略只负责协调，不负责 confinement**——它无法阻止 Bash 或外部进程写入重叠文件。
+- **不会自主创建 Team**——除非用户明确要求，普通任务不会触发 delegation。
+- **没有 Web 控制功能**——浏览器 roster 与任务板呈现不属于该运行时包。
+- **实验原型，无稳定性承诺**——本包公开发布，但孵化期间 schema 仍可自由变更。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/index.js

@@ -0,0 +1,550 @@
+import z from "@deepseek-ai/schemastery";
+import { TeamTaskId } from "@deepseek-ai/dsh-experimental-agent-team";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+//#region lib/types/index.js
+/** Scoped model-facing tools for the opt-in Agent Teams runtime. */
+/** Cordis plugin name. */
+const name = "tool-agent-team";
+/** Services required by the Team tool plugin. */
+const inject = [
+	"agents",
+	"agentTeams",
+	"tools",
+	"systemPrompt"
+];
+/** Loader schema for the opt-in Team tool plugin. */
+const Config = z.object({
+	freshProvider: z.string().default("spawn"),
+	forkProvider: z.string().default("fork")
+});
+/** Model-facing collaboration guidance shared by Lead and teammates. */
+const POLICY = `Agent Teams is available in this session, but create teammates only when the user explicitly asks to use Agent Teams or teammates.
+
+The Team Lead and all teammates share the same working directory and filesystem. Edits are immediately visible to every member. Split write work into disjoint scopes, record expected write scopes on shared tasks, and use task dependencies when work must be ordered. Write-scope overlap is advisory, not a lock.
+
+Prefer read/edit/write for file changes. If a file operation returns FS_STALE_VERSION, read the current file, rebase your intended change onto the new content, and retry. Bash, formatters, code generators, and scripts are not fully protected by the filesystem version guard; coordinate them explicitly and have the Lead review the final diff and run tests.
+
+send_message steers a running target at its nearest step boundary, starts an idle target, and cold-resumes an inactive teammate. A delivered peer item starts with its stable message id and sender name. A successful send is already durable even when its result says queued; do not resend it. Shared-task workflow is list, get, claim with the current revision, perform the work, then complete. Task readiness never starts an owner. Before wait_agent, use list_agents and make sure another required member is running or provisioning; use send_message first when the required member is inactive. wait_agent observes only changes after that call starts, never wakes a member, and returns noProgress immediately when no other member can produce a change. Re-list after wakeup or timeout. The Lead must wait for required teammates before giving the final answer.`;
+const ACTIVE_WAIT_STATUSES = new Set(["running", "provisioning"]);
+const NO_ACTIVE_PEER_MESSAGE = "No other Team member is running or provisioning. wait_agent cannot make progress or wake inactive teammates. Re-list with list_agents and team_task_list, then use send_message to wake each required inactive teammate before waiting again.";
+/**
+* One roster row, matching `TeamMemberView`. The Lead pseudo-row omits the
+* teammate-only provisioning fields, so only identity, role, status, and
+* diagnostics are required.
+*/
+const MEMBER_VIEW_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		id: {
+			type: "string",
+			required: true
+		},
+		name: {
+			type: "string",
+			required: true
+		},
+		role: {
+			type: "string",
+			required: true,
+			enum: ["lead", "teammate"]
+		},
+		status: {
+			type: "string",
+			required: true,
+			enum: [
+				"running",
+				"idle",
+				"inactive",
+				"provisioning",
+				"failed"
+			]
+		},
+		description: { type: "string" },
+		provider: { type: "string" },
+		context: {
+			type: "string",
+			enum: ["fresh", "fork"]
+		},
+		model: { type: "string" },
+		diagnostics: {
+			type: "array",
+			required: true,
+			items: { type: "string" }
+		}
+	}
+};
+/** One shared task, matching the public `TeamTaskView`. */
+const TASK_VIEW_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		id: {
+			type: "string",
+			required: true
+		},
+		revision: {
+			type: "integer",
+			required: true
+		},
+		subject: {
+			type: "string",
+			required: true
+		},
+		description: {
+			type: "string",
+			required: true
+		},
+		status: {
+			type: "string",
+			required: true,
+			enum: [
+				"pending",
+				"in_progress",
+				"completed",
+				"deleted"
+			]
+		},
+		ownerName: { type: "string" },
+		blockedBy: {
+			type: "array",
+			required: true,
+			items: { type: "string" }
+		},
+		writeScopes: {
+			type: "array",
+			required: true,
+			items: { type: "string" }
+		},
+		ready: {
+			type: "boolean",
+			required: true
+		},
+		writeScopeWarnings: {
+			type: "array",
+			required: true,
+			items: { type: "string" }
+		}
+	}
+};
+const SPAWN_VALUE_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: { member: {
+		...MEMBER_VIEW_SCHEMA,
+		required: true
+	} }
+};
+const MEMBER_LIST_VALUE_SCHEMA = {
+	type: "array",
+	items: MEMBER_VIEW_SCHEMA
+};
+const SEND_VALUE_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		messageId: {
+			type: "string",
+			required: true
+		},
+		status: {
+			type: "string",
+			required: true,
+			enum: ["accepted", "queued"]
+		}
+	}
+};
+/** `noProgress` is present only on the model-only shortcut that skips the wait. */
+const WAIT_VALUE_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		timedOut: {
+			type: "boolean",
+			required: true
+		},
+		noProgress: {
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				reason: {
+					type: "string",
+					required: true,
+					const: "no-active-peer"
+				},
+				message: {
+					type: "string",
+					required: true
+				}
+			}
+		}
+	}
+};
+const INTERRUPT_VALUE_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: { previousStatus: {
+		type: "string",
+		required: true,
+		enum: [
+			"running",
+			"idle",
+			"inactive"
+		]
+	} }
+};
+const TASK_LIST_VALUE_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		tasks: {
+			type: "array",
+			required: true,
+			items: TASK_VIEW_SCHEMA
+		},
+		nextCursor: { type: "integer" }
+	}
+};
+/**
+* Declare one canonical output schema with compact model-facing JSON. Every
+* Team result is a fixed record, so the declared schema is what makes the
+* compiler check `execute` against the value the model is promised.
+* @param schema - canonical value schema for one tool.
+* @returns the `output` declaration accepted by {@link defineTool}.
+*/
+function jsonOutput(schema) {
+	return {
+		schema,
+		render: (_args, value) => [{
+			type: "text",
+			text: JSON.stringify(value)
+		}]
+	};
+}
+/** Recover the exact caller guaranteed by Agent-scoped tool discovery. */
+function callingAgent(agent, toolName) {
+	/* v8 ignore next 2 -- Team tools are registered only in an exact Agent scope, so discovery supplies this carrier. */
+	if (agent === void 0) throw new Error(`${toolName} requires a calling Agent`);
+	return agent;
+}
+/** Register the complete Team tool set in one exact Agent scope. */
+function install(agent, ctx, config) {
+	const scoped = agent.ctx;
+	const disposers = [];
+	const register = (disposer) => {
+		disposers.push(disposer);
+	};
+	try {
+		register(scoped.systemPrompt.section({
+			name: "team:policy",
+			order: scoped.systemPrompt.getSectionOrder("TEAM_POLICY"),
+			text: () => {
+				const membership = ctx.agentTeams.membership(agent);
+				return `${POLICY}\n\nYour Team role is ${membership.role}; your Team name is ${membership.name}; Team id is ${membership.id}.`;
+			}
+		}));
+		register(scoped.tools.register(defineTool({
+			name: "spawn_teammate",
+			description: "Create one named, durable teammate. Only the Team Lead may call this tool.",
+			parameters: {
+				name: {
+					type: "string",
+					required: true,
+					description: "Unique lower-kebab-case teammate name."
+				},
+				description: {
+					type: "string",
+					required: true,
+					description: "Short description of the delegated responsibility."
+				},
+				prompt: {
+					type: "string",
+					required: true,
+					description: "Complete initial task for the teammate."
+				},
+				context: {
+					type: "string",
+					enum: ["fresh", "fork"],
+					description: "fresh starts without Lead history; fork inherits completed Lead turns. Defaults to fresh."
+				}
+			},
+			output: jsonOutput(SPAWN_VALUE_SCHEMA),
+			async execute(args, exec) {
+				const agent = callingAgent(exec.agent, "spawn_teammate");
+				const context = args.context ?? "fresh";
+				return await ctx.agentTeams.spawnTeammate(agent, {
+					name: args.name,
+					description: args.description,
+					prompt: [{
+						type: "text",
+						text: args.prompt
+					}],
+					context,
+					provider: context === "fork" ? config.forkProvider : config.freshProvider,
+					signal: exec.signal
+				});
+			}
+		})));
+		register(scoped.tools.register(defineTool({
+			name: "send_message",
+			description: "Send one durable message to another Team member. A running target receives it at the nearest step boundary; an idle target starts a turn; an inactive teammate cold-resumes.",
+			parameters: {
+				target: {
+					type: "string",
+					required: true,
+					description: "Team member name, or lead."
+				},
+				message: {
+					type: "string",
+					required: true,
+					description: "Self-contained message for the target."
+				}
+			},
+			output: jsonOutput(SEND_VALUE_SCHEMA),
+			execute(args, exec) {
+				return ctx.agentTeams.sendMessage(callingAgent(exec.agent, "send_message"), {
+					target: args.target,
+					content: [{
+						type: "text",
+						text: args.message
+					}],
+					signal: exec.signal
+				});
+			}
+		})));
+		register(scoped.tools.register(defineTool({
+			name: "list_agents",
+			description: "List the Lead and every durable teammate with current runtime status.",
+			parameters: {},
+			output: jsonOutput(MEMBER_LIST_VALUE_SCHEMA),
+			async execute(_args, exec) {
+				return Promise.resolve(ctx.agentTeams.listMembers(callingAgent(exec.agent, "list_agents")));
+			}
+		})));
+		register(scoped.tools.register(defineTool({
+			name: "wait_agent",
+			description: "Wait for the next teammate status, mailbox, or shared-task change after this call starts. This never wakes inactive members and returns noProgress immediately when no other member is running or provisioning. Re-list after wakeup or timeout instead of polling.",
+			parameters: { timeout_ms: {
+				type: "integer",
+				description: "Wait duration in milliseconds, from 10000 through 3600000. Defaults to 30000."
+			} },
+			output: jsonOutput(WAIT_VALUE_SCHEMA),
+			async execute(args, exec) {
+				const caller = callingAgent(exec.agent, "wait_agent");
+				const timeoutMs = args.timeout_ms ?? 3e4;
+				if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1e4 || timeoutMs > 36e5) return await ctx.agentTeams.waitForChange(caller, timeoutMs, exec.signal);
+				if (!ctx.agentTeams.listMembers(caller).some((member) => member.id !== caller.id && ACTIVE_WAIT_STATUSES.has(member.status))) return {
+					timedOut: false,
+					noProgress: {
+						reason: "no-active-peer",
+						message: NO_ACTIVE_PEER_MESSAGE
+					}
+				};
+				return await ctx.agentTeams.waitForChange(caller, timeoutMs, exec.signal);
+			}
+		})));
+		register(scoped.tools.register(defineTool({
+			name: "interrupt_agent",
+			description: "Interrupt one teammate's current turn while preserving its pending inbox. Team Lead only.",
+			parameters: { target: {
+				type: "string",
+				required: true,
+				description: "Teammate name."
+			} },
+			output: jsonOutput(INTERRUPT_VALUE_SCHEMA),
+			async execute(args, exec) {
+				return Promise.resolve(ctx.agentTeams.interrupt(callingAgent(exec.agent, "interrupt_agent"), args.target));
+			}
+		})));
+		register(scoped.tools.register(defineTool({
+			name: "team_task_create",
+			description: "Create one unowned pending task on the shared Team task board.",
+			parameters: {
+				subject: {
+					type: "string",
+					required: true,
+					description: "Concise task title."
+				},
+				description: {
+					type: "string",
+					required: true,
+					description: "Complete task details and acceptance criteria."
+				},
+				blocked_by: {
+					type: "array",
+					items: { type: "string" },
+					description: "Task ids that must complete first."
+				},
+				write_scopes: {
+					type: "array",
+					items: { type: "string" },
+					description: "Advisory workspace-relative file or directory prefixes this task expects to modify."
+				}
+			},
+			output: jsonOutput(TASK_VIEW_SCHEMA),
+			async execute(args, exec) {
+				return await ctx.agentTeams.createTask(callingAgent(exec.agent, "team_task_create"), {
+					subject: args.subject,
+					description: args.description,
+					...args.blocked_by === void 0 ? {} : { blockedBy: args.blocked_by.map(TeamTaskId) },
+					...args.write_scopes === void 0 ? {} : { writeScopes: args.write_scopes }
+				});
+			}
+		})));
+		register(scoped.tools.register(defineTool({
+			name: "team_task_list",
+			description: "List shared tasks, including readiness, owner, revision, blockers, and write-scope warnings.",
+			parameters: {
+				status: {
+					type: "string",
+					enum: [
+						"pending",
+						"in_progress",
+						"completed"
+					],
+					description: "Optional exact status filter."
+				},
+				owner: {
+					type: "string",
+					description: "Optional member-name filter; use unowned for tasks without an owner."
+				},
+				ready: {
+					type: "boolean",
+					description: "Optional readiness filter."
+				},
+				cursor: {
+					type: "integer",
+					description: "Zero-based result offset. Defaults to 0."
+				},
+				limit: {
+					type: "integer",
+					description: "Number of rows, 1 through 100. Defaults to 50."
+				}
+			},
+			output: jsonOutput(TASK_LIST_VALUE_SCHEMA),
+			execute(args, exec) {
+				const status = args.status;
+				const filtered = ctx.agentTeams.listTasks(callingAgent(exec.agent, "team_task_list")).filter((task) => (status === void 0 || task.status === status) && (args.owner === void 0 || (args.owner === "unowned" ? task.ownerName === void 0 : task.ownerName === args.owner)) && (args.ready === void 0 || task.ready === args.ready));
+				const cursor = args.cursor ?? 0;
+				const limit = args.limit ?? 50;
+				if (!Number.isSafeInteger(cursor) || cursor < 0) throw new Error("cursor must be a non-negative safe integer");
+				if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) throw new Error("limit must be an integer from 1 through 100");
+				return Promise.resolve({
+					tasks: filtered.slice(cursor, cursor + limit),
+					...cursor + limit < filtered.length ? { nextCursor: cursor + limit } : {}
+				});
+			}
+		})));
+		register(scoped.tools.register(defineTool({
+			name: "team_task_get",
+			description: "Read the complete latest value of one shared task before changing or executing it.",
+			parameters: { task_id: {
+				type: "string",
+				required: true,
+				description: "Shared task id."
+			} },
+			output: jsonOutput(TASK_VIEW_SCHEMA),
+			async execute(args, exec) {
+				return Promise.resolve(ctx.agentTeams.getTask(callingAgent(exec.agent, "team_task_get"), TeamTaskId(args.task_id)));
+			}
+		})));
+		register(scoped.tools.register(defineTool({
+			name: "team_task_update",
+			description: "Compare-and-set a shared task action using the latest revision from team_task_get or team_task_list.",
+			parameters: {
+				task_id: {
+					type: "string",
+					required: true,
+					description: "Shared task id."
+				},
+				expected_revision: {
+					type: "integer",
+					required: true,
+					description: "Current task revision used as the CAS precondition."
+				},
+				action: {
+					type: "string",
+					required: true,
+					enum: [
+						"claim",
+						"release",
+						"edit",
+						"set_dependencies",
+						"complete",
+						"reopen",
+						"reassign",
+						"delete"
+					],
+					description: "Task transition to apply."
+				},
+				subject: {
+					type: "string",
+					description: "Replacement title for edit."
+				},
+				description: {
+					type: "string",
+					description: "Replacement details for edit."
+				},
+				blocked_by: {
+					type: "array",
+					items: { type: "string" },
+					description: "Complete blocker list for set_dependencies."
+				},
+				write_scopes: {
+					type: "array",
+					items: { type: "string" },
+					description: "Replacement advisory write scopes for edit."
+				},
+				owner: {
+					type: "string",
+					description: "Member name for Lead-only reassign; omit to unassign."
+				}
+			},
+			output: jsonOutput(TASK_VIEW_SCHEMA),
+			async execute(args, exec) {
+				return await ctx.agentTeams.updateTask(callingAgent(exec.agent, "team_task_update"), {
+					taskId: TeamTaskId(args.task_id),
+					expectedRevision: args.expected_revision,
+					action: args.action,
+					...args.subject === void 0 ? {} : { subject: args.subject },
+					...args.description === void 0 ? {} : { description: args.description },
+					...args.blocked_by === void 0 ? {} : { blockedBy: args.blocked_by.map(TeamTaskId) },
+					...args.write_scopes === void 0 ? {} : { writeScopes: args.write_scopes },
+					...args.owner === void 0 ? {} : { owner: args.owner }
+				});
+			}
+		})));
+	} catch (error) {
+		for (const dispose of disposers.reverse()) dispose();
+		throw error;
+	}
+	return () => {
+		for (const dispose of disposers.reverse()) dispose();
+	};
+}
+/** Install Team tools in every live or subsequently published Team member scope. */
+function apply(ctx, config = {}) {
+	const resolved = {
+		freshProvider: config.freshProvider ?? "spawn",
+		forkProvider: config.forkProvider ?? "fork"
+	};
+	const installed = /* @__PURE__ */ new Map();
+	const maybeInstall = (agent) => {
+		if (installed.has(agent) || ctx.agentTeams.tryMembership(agent) === void 0) return;
+		installed.set(agent, install(agent, ctx, resolved));
+	};
+	for (const agent of ctx.agents.list()) maybeInstall(agent);
+	ctx.on("agent/created", ({ agent }) => {
+		maybeInstall(agent);
+	});
+	ctx.on("agent/disposed", ({ agent }) => {
+		installed.get(agent)?.();
+		installed.delete(agent);
+	});
+	ctx.effect(() => () => {
+		for (const dispose of installed.values()) dispose();
+		installed.clear();
+	}, "tool-team.scopedTools()");
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,19 @@
+/** Scoped model-facing tools for the opt-in Agent Teams runtime. */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+/** Cordis plugin name. */
+export declare const name = "tool-agent-team";
+/** Services required by the Team tool plugin. */
+export declare const inject: string[];
+/** Tool routing configuration. */
+export interface Config {
+    /** Continuable-subagent provider used for fresh teammates. */
+    readonly freshProvider?: string;
+    /** Continuable-subagent provider used for completed-prefix fork teammates. */
+    readonly forkProvider?: string;
+}
+/** Loader schema for the opt-in Team tool plugin. */
+export declare const Config: z<Config>;
+/** Install Team tools in every live or subsequently published Team member scope. */
+export declare function apply(ctx: Context, config?: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@deepseek-ai/dsh-experimental-tool-agent-team",
+  "description": "Scoped model-facing Agent Teams tools over ctx.agentTeams",
+  "version": "0.1.5-alpha.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/experimental/tool-agent-team"
+  },
+  "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",
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.2"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-agent": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-session": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-experimental-agent-team": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-tools": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.5-alpha.2",
+    "@deepseek-ai/cordis": "^4.0.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-agent": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-agent-loop": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-agent-loop-testkit": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-session": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-session-projection": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-subagent": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-session-query": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-scope": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-subagent-fork-in-process": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-tool-subagent-control": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-experimental-agent-team": "^0.1.5-alpha.2",
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-session-persistence-jsonl": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-tools": "^0.1.5-alpha.2",
+    "@deepseek-ai/dsh-subagent-spawn-in-process": "^0.1.5-alpha.2"
+  }
+}