@wowyuarm/dsh-agent-team 0.1.0

package/packages/client-agent-team/lib/types/client/timeline-scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeline-scroll.d.ts","sourceRoot":"","sources":["../../../src/client/timeline-scroll.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,CAAA;IAC1C,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,gFAAgF;IAChF,QAAQ,EAAE,MAAM,OAAO,CAAA;IACvB,qEAAqE;IACrE,cAAc,EAAE,MAAM,IAAI,CAAA;IAC1B,0DAA0D;IAC1D,YAAY,EAAE,MAAM,IAAI,CAAA;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,CA+CpE"}

package/packages/client-agent-team/lib/types/client/timeline-scroll.js

@@ -0,0 +1,54 @@
+import { useCallback, useEffect, useRef } from 'react';
+const BOTTOM_MARGIN_PX = 48;
+const BOUNDARY_OFFSET_PX = 12;
+/**
+ * Chat-timeline scroll policy shared by the Channel and Thread pages: follow
+ * new facts only while the reader stays pinned to the bottom, keep prepended
+ * history visually stable, and honor explicit jump requests exactly once per
+ * content commit. The content key must change whenever rendered facts change.
+ */
+export function useTimelineScroll(contentKey) {
+    const ref = useRef(null);
+    const pinnedRef = useRef(true);
+    const heightRef = useRef(0);
+    const jumpRef = useRef();
+    const onScroll = useCallback(() => {
+        const element = ref.current;
+        if (element === null)
+            return;
+        pinnedRef.current = element.scrollHeight - element.scrollTop - element.clientHeight < BOTTOM_MARGIN_PX;
+    }, []);
+    const jumpToBoundary = useCallback(() => {
+        jumpRef.current = 'boundary';
+        pinnedRef.current = false;
+    }, []);
+    const jumpToLatest = useCallback(() => {
+        jumpRef.current = 'latest';
+        pinnedRef.current = true;
+    }, []);
+    useEffect(() => {
+        const element = ref.current;
+        if (element === null)
+            return;
+        const previousHeight = heightRef.current;
+        heightRef.current = element.scrollHeight;
+        const jump = jumpRef.current;
+        jumpRef.current = undefined;
+        if (jump === 'boundary') {
+            const marker = element.querySelector('[data-thread-boundary]');
+            if (marker !== null) {
+                element.scrollTop += marker.getBoundingClientRect().top - element.getBoundingClientRect().top - BOUNDARY_OFFSET_PX;
+                return;
+            }
+        }
+        if (jump === 'latest' || pinnedRef.current) {
+            element.scrollTop = element.scrollHeight;
+            return;
+        }
+        // Prepended older history must not shift the content the reader is on.
+        if (previousHeight > 0 && element.scrollHeight > previousHeight) {
+            element.scrollTop += element.scrollHeight - previousHeight;
+        }
+    }, [contentKey]);
+    return { ref, onScroll, isPinned: () => pinnedRef.current, jumpToBoundary, jumpToLatest };
+}

package/packages/client-agent-team/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+/** Host half: the Team UI has no Node-side behavior. */
+export declare function apply(): void;
+//# sourceMappingURL=index.d.ts.map

package/packages/client-agent-team/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,wBAAgB,KAAK,IAAI,IAAI,CAAG"}

package/packages/client-agent-team/lib/types/index.js

@@ -0,0 +1,2 @@
+/** Host half: the Team UI has no Node-side behavior. */
+export function apply() { }

package/packages/tool-agent-team/README.md

@@ -0,0 +1,23 @@
+# @wowyuarm/dsh-agent-team/tools
+
+English | [中文](README.zh.md)
+
+Model-facing tools for Agent Team Members. The package registers tools in the calling Agent preset scope and does not provide or replace Host services.
+
+## Tools
+
+- `team_inbox` lists bounded unread Thread summaries for the calling Member, ordered by direct work and then recency.
+- `team_thread` reads a Thread, pages history, follows, or unfollows. `read` atomically returns the Task anchor, current Task and Claim snapshot, bounded orientation facts, and one contiguous unread batch while advancing the durable watermark; `history` never changes read state.
+- `team_message` starts a top-level Task or replies to an existing Thread. Replies require the exact `baseRevision` and reject unread work before checking revision freshness.
+- `team_claim` lists or mutates the calling Member's Direction Claims through `list`, `claim`, `done`, and `release`. Direction exclusion uses Unicode NFKC normalization, trim, whitespace compression, and deterministic case folding.
+- `team_view` discovers bounded, membership-authorized Channel, Task, and Member summaries. It does not return Thread messages or activities.
+
+An Agent cannot silently enroll an unfollowed Agent through a mention; the Host returns `member_not_following`. Human confirmation is a separate Host/Client flow. Closed Tasks reject replies, Claims, and new Attention until a Human reopens them.
+
+Canonical results expose stable refs, current Task status, Thread revision, Claim history, Attention, and unread facts. Typed `unread_required` and `stale_revision` results include the fields needed to reread and retry deliberately. Tool execution resolves the exact live `exec.agent`; arguments cannot select or impersonate the actor or Workspace. Write request identity derives from sessionId plus tool callId. Team tools return to the model loop and never conclude the turn.
+
+The complete implemented protocol is documented in [`../../docs/team-collaboration.md`](../../docs/team-collaboration.md).
+
+## Composition
+
+Mount this plugin inside a team-enabled Agent preset after `dsh-tools`. It statically injects only `tools`; execution resolves `agentTeam` from the live Agent context. This avoids a dependency cycle while the Host restores member sessions.

package/packages/tool-agent-team/README.zh.md

@@ -0,0 +1,23 @@
+# @wowyuarm/dsh-agent-team/tools
+
+[English](README.md) | 中文
+
+面向 Agent Team Member 的模型工具。本包在调用方 Agent preset scope 内注册工具，不提供或替换 Host service。
+
+## 工具
+
+- `team_inbox` 列出调用方 Member 的有界未读 Thread 摘要，先按 direct work、再按最近活动排序。
+- `team_thread` 读取 Thread、分页历史、follow 或 unfollow。`read` 原子返回 Task anchor、当前 Task 与 Claim 快照、有界背景和一批连续未读事实，并推进持久 watermark；`history` 不改变 read 状态。
+- `team_message` 创建顶层 Task，或回复已有 Thread。Reply 必须携带准确的 `baseRevision`，并在检查 revision 前先处理未读门禁。
+- `team_claim` 通过 `list`、`claim`、`done`、`release` 读取或修改调用方 Member 的 Direction Claim。Direction 互斥键执行 Unicode NFKC normalization、trim、空白压缩和确定性大小写折叠。
+- `team_view` 发现有界、按 membership 授权的 Channel、Task 和 Member 摘要，不返回 Thread Message 或 Activity。
+
+Agent 不能通过 mention 静默把另一个 unfollowed Agent 加入 Thread；Host 返回 `member_not_following`。Human confirmation 属于单独的 Host/Client 流程。Closed Task 在 Human reopen 前拒绝 reply、Claim 和新的 Attention。
+
+Canonical result 包含稳定 refs、当前 Task status、Thread revision、Claim history、Attention 和未读 facts。类型化的 `unread_required` 与 `stale_revision` 结果包含重新读取和审慎重试所需字段。工具执行通过准确的 live `exec.agent` 解析 actor；参数不能选择或冒充 actor 或 Workspace。写操作的 request identity 由 sessionId 与 tool callId 派生。Team tools 将结果返回模型循环，不主动结束 turn。
+
+完整的已实现协议见 [`../../docs/team-collaboration.md`](../../docs/team-collaboration.md)。
+
+## Composition
+
+在 team-enabled Agent preset 内、`dsh-tools` 之后挂载本插件。插件只静态 inject `tools`；执行时从 live Agent context 读取 `agentTeam`，避免 Host 恢复 Member session 时形成依赖环。

package/packages/tool-agent-team/lib/index.js

@@ -0,0 +1,294 @@
+import { markAgentTeamPreset } from '@wowyuarm/dsh-agent-team/host';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+export const name = 'wowyuarm-agent-team-tools';
+export const inject = ['tools'];
+function service(agent) {
+    const host = agent.ctx.get('agentTeam');
+    if (host === undefined)
+        throw new Error('Agent Team Host is unavailable');
+    return host;
+}
+function member(agent) {
+    const current = service(agent).memberForAgent(agent);
+    if (current === undefined)
+        throw new Error('team tool requires an active Team Member');
+    return current;
+}
+function requestId(agentId, callId) {
+    return `agent-team:tool:${agentId}:${callId}`;
+}
+const teamInbox = defineTool({
+    name: 'team_inbox',
+    description: 'List your bounded Team Inbox. It returns Thread summaries without message bodies and does not mark anything read.',
+    parameters: { limit: { type: 'number' } },
+    output: {
+        schema: { type: 'object', additionalProperties: false, properties: {
+                totalUnreadCount: { type: 'number', required: true }, totalDirectCount: { type: 'number', required: true },
+                items: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
+                            taskRef: { type: 'string', required: true }, threadRef: { type: 'string', required: true }, channelRef: { type: 'string', required: true },
+                            status: { type: 'string', required: true }, revision: { type: 'number', required: true }, unreadCount: { type: 'number', required: true }, directCount: { type: 'number', required: true },
+                            taskNumber: { type: 'number' },
+                        } } },
+            } },
+        render: (_args, value) => [{ type: 'text', text: value.items.length === 0 ? 'No unread Team work.'
+                    : value.items.map(item => `${item.taskRef}${item.taskNumber === undefined ? '' : ` (#${item.taskNumber})`} · ${item.directCount > 0 ? 'direct' : 'unread'}, ${item.unreadCount} update(s), revision ${item.revision}`).join('\n') }],
+    },
+    async execute(args, exec) {
+        const agent = exec.agent;
+        if (agent === undefined)
+            throw new Error('team_inbox requires an Agent session');
+        const current = member(agent);
+        const host = service(agent);
+        const inbox = host.inboxForAgent(agent, { workspaceId: current.workspaceId, ...(args.limit === undefined ? {} : { limit: args.limit }) });
+        const taskNumbers = new Map(host.viewForAgent(agent, { workspaceId: current.workspaceId, topLevelOnly: true, includeActivities: false })
+            .taskNumbers.map(entry => [entry.taskRef, entry.taskNumber]));
+        return {
+            totalUnreadCount: inbox.totalUnreadCount, totalDirectCount: inbox.totalDirectCount,
+            items: inbox.items.map(item => {
+                const taskNumber = taskNumbers.get(item.task.taskRef);
+                return { taskRef: item.task.taskRef, threadRef: item.thread.threadRef, channelRef: item.channelRef,
+                    status: item.task.status, revision: item.thread.revision, unreadCount: item.unreadCount, directCount: item.directCount,
+                    ...(taskNumber === undefined ? {} : { taskNumber }) };
+            }),
+        };
+    },
+});
+const teamThread = defineTool({
+    name: 'team_thread',
+    description: 'Read or manage your Attention on one Task Thread. read acknowledges one chronological batch; history does not change read state.',
+    parameters: {
+        action: { type: 'string', required: true, enum: ['status', 'follow', 'unfollow', 'read', 'history'] },
+        taskRef: { type: 'string', required: true, description: "Full branded Task ref exactly as returned by Team tools, including the 'task:' prefix." },
+        beforeSequence: { type: 'number' }, limit: { type: 'number' },
+    },
+    output: {
+        schema: { type: 'object', additionalProperties: false, properties: {
+                kind: { type: 'string', required: true }, taskRef: { type: 'string', required: true }, threadRef: { type: 'string', required: true },
+                revision: { type: 'number', required: true }, status: { type: 'string', required: true }, resolution: { type: 'string', required: true },
+                following: { type: 'boolean', required: true }, readThroughSequence: { type: 'number' }, remainingUnreadCount: { type: 'number' }, cursor: { type: 'number' }, hasMore: { type: 'boolean' },
+                anchor: { type: 'object', required: true, additionalProperties: false, properties: {
+                        messageRef: { type: 'string', required: true }, sender: { type: 'string', required: true }, body: { type: 'string', required: true }, sequence: { type: 'number', required: true },
+                    } },
+                claims: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
+                            claimRef: { type: 'string', required: true }, direction: { type: 'string', required: true }, state: { type: 'string', required: true }, owner: { type: 'string', required: true },
+                        } } },
+                facts: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
+                            sequence: { type: 'number', required: true }, kind: { type: 'string', required: true }, body: { type: 'string' }, sender: { type: 'string' }, mentions: { type: 'array', items: { type: 'string' } }, activity: { type: 'string' }, unread: { type: 'boolean' }, direct: { type: 'boolean' },
+                        } } },
+            } },
+        render: (_args, value) => [{ type: 'text', text: value.facts.length === 0
+                    ? `${value.threadRef} · revision ${value.revision}, following=${value.following}`
+                    : [`revision ${value.revision}`, ...value.facts.map(fact => fact.kind === 'message'
+                            ? `${fact.sequence} [${fact.sender ?? 'unknown sender'}] ${fact.body}`
+                            : `${fact.sequence} ${fact.activity}`)].join('\n') }],
+    },
+    async execute(args, exec) {
+        const agent = exec.agent;
+        if (agent === undefined)
+            throw new Error('team_thread requires an Agent session');
+        const current = member(agent);
+        const host = service(agent);
+        const base = { workspaceId: current.workspaceId, taskRef: args.taskRef };
+        if (args.action === 'status') {
+            if (args.beforeSequence !== undefined || args.limit !== undefined)
+                throw new Error('status does not accept history arguments');
+            const status = host.attentionStatusForAgent(agent, base);
+            const snapshot = host.threadHistoryForAgent(agent, { ...base, beforeSequence: 1, limit: 1 });
+            return threadResult('status', snapshot, status.attention, []);
+        }
+        if (args.action === 'follow' || args.action === 'unfollow') {
+            if (args.beforeSequence !== undefined || args.limit !== undefined)
+                throw new Error(`${args.action} does not accept history arguments`);
+            const result = await host.changeAttentionForAgent(agent, { requestId: requestId(agent.id, exec.callId), ...base, action: args.action });
+            const snapshot = host.threadHistoryForAgent(agent, { ...base, beforeSequence: 1, limit: 1 });
+            return threadResult(args.action, snapshot, result.attention, []);
+        }
+        if (args.action === 'history') {
+            const history = host.threadHistoryForAgent(agent, { ...base, ...(args.beforeSequence === undefined ? {} : { beforeSequence: args.beforeSequence }), ...(args.limit === undefined ? {} : { limit: args.limit }) });
+            const status = host.attentionStatusForAgent(agent, base);
+            return threadResult('history', history, status.attention, history.facts.map(fact => fact.kind === 'message'
+                ? { sequence: fact.sequence, kind: 'message', body: fact.message.body, sender: fact.message.sender, mentions: [...fact.mentions] }
+                : { sequence: fact.sequence, kind: 'activity', activity: fact.activity.kind }), { cursor: history.cursor, hasMore: history.hasMore });
+        }
+        if (args.beforeSequence !== undefined || args.limit !== undefined)
+            throw new Error('read does not accept history arguments');
+        const read = await host.readThreadForAgent(agent, { requestId: requestId(agent.id, exec.callId), ...base });
+        return threadResult('read', read, read.attention, read.facts.map(entry => entry.fact.kind === 'message'
+            ? { sequence: entry.fact.sequence, kind: 'message', body: entry.fact.message.body, sender: entry.fact.message.sender, mentions: [...entry.fact.mentions], unread: entry.unread, direct: entry.direct }
+            : { sequence: entry.fact.sequence, kind: 'activity', activity: entry.fact.activity.kind, unread: entry.unread, direct: entry.direct }), { readThroughSequence: read.readThroughSequence, remainingUnreadCount: read.remainingUnreadCount });
+    },
+});
+function threadResult(kind, snapshot, attention, facts, extra = {}) {
+    return {
+        kind, taskRef: snapshot.task.taskRef, threadRef: snapshot.thread.threadRef, revision: snapshot.thread.revision,
+        status: snapshot.task.status, resolution: snapshot.task.resolution, following: attention !== undefined,
+        ...extra,
+        ...(attention === undefined || extra.readThroughSequence !== undefined ? {} : { readThroughSequence: attention.readThroughSequence }),
+        anchor: { messageRef: snapshot.anchor.messageRef, sender: snapshot.anchor.sender, body: snapshot.anchor.body, sequence: snapshot.anchor.sequence },
+        claims: snapshot.claims.map(claim => ({ claimRef: claim.claimRef, direction: claim.direction, state: claim.state, owner: claim.owner })),
+        facts,
+    };
+}
+const teamMessage = markAgentTeamPreset(defineTool({
+    name: 'team_message',
+    description: 'Create a top-level Task or reply to one existing Task Thread. Read the Thread first; replies require its current revision. A top-level start may mention related Agents directly; in replies, only a Human can invite an unfollowed Agent. Pass Member refs in mentions and spell their handles inside the body; only mentioned Members render as mention chips.',
+    parameters: {
+        action: { type: 'string', required: true, enum: ['start', 'reply'] },
+        channelRef: { type: 'string', description: "Full branded Channel ref exactly as returned by Team tools, including the 'channel:' prefix." },
+        taskRef: { type: 'string', description: "Full branded Task ref exactly as returned by Team tools, including the 'task:' prefix." },
+        body: { type: 'string', required: true }, baseRevision: { type: 'number', description: "Positive integer; use the current Thread revision as shown by the latest team_inbox or team_thread result for this Task." },
+        mentions: { type: 'array', items: { type: 'string' }, description: 'Member refs to mention. Mentioned Agents receive the Message directly; write their handles in the body (any casing, optional @) so the mention renders inline.' },
+    },
+    output: {
+        schema: { type: 'object', additionalProperties: false, properties: {
+                kind: { type: 'string', required: true }, taskRef: { type: 'string' }, threadRef: { type: 'string' }, revision: { type: 'number' },
+                expectedRevision: { type: 'number' }, messageRef: { type: 'string' }, memberIds: { type: 'array', items: { type: 'string' } }, unreadCount: { type: 'number' }, directCount: { type: 'number' },
+            } },
+        render: (_args, value) => [{ type: 'text', text: value.kind === 'committed' ? `Message ${value.messageRef} committed at revision ${value.revision}.`
+                    : `${value.kind}: ${value.memberIds?.join(', ') ?? `Task ${value.taskRef ?? ''} revision ${value.revision ?? ''}`}` }],
+    },
+    async execute(args, exec) {
+        const agent = exec.agent;
+        if (agent === undefined)
+            throw new Error('team_message requires an Agent session');
+        const current = member(agent);
+        const host = service(agent);
+        const mentions = args.mentions;
+        if (args.action === 'start') {
+            if (args.channelRef === undefined || args.taskRef !== undefined || args.baseRevision !== undefined)
+                throw new Error('start requires channelRef and does not accept taskRef or baseRevision');
+            const result = await host.sendMessageForAgent(agent, { requestId: requestId(agent.id, exec.callId), workspaceId: current.workspaceId,
+                channelRef: args.channelRef, body: args.body, ...(mentions === undefined ? {} : { recipients: mentions }) });
+            return messageOutcome(result);
+        }
+        const baseRevision = args.baseRevision;
+        if (args.taskRef === undefined || args.channelRef !== undefined || typeof baseRevision !== 'number' || !Number.isSafeInteger(baseRevision) || baseRevision < 1) {
+            throw new Error("reply requires taskRef and a positive baseRevision, and does not accept channelRef; use the current Thread 'revision' returned by team_inbox or team_thread for this Task");
+        }
+        const result = await host.replyForAgent(agent, { requestId: requestId(agent.id, exec.callId), workspaceId: current.workspaceId,
+            taskRef: args.taskRef, body: args.body, baseRevision,
+            ...(mentions === undefined ? {} : { recipients: mentions }) });
+        return messageOutcome(result);
+    },
+}));
+function messageOutcome(result) {
+    if (result.kind === 'committed')
+        return { kind: result.kind, taskRef: result.task.taskRef, threadRef: result.thread.threadRef,
+            revision: result.thread.revision, messageRef: result.message.messageRef };
+    if (result.kind === 'member_not_following')
+        return { kind: result.kind, memberIds: [...result.memberIds],
+            ...(result.taskRef === undefined ? {} : { taskRef: result.taskRef }), ...(result.threadRef === undefined ? {} : { threadRef: result.threadRef, revision: result.revision }) };
+    if (result.kind === 'unread_required')
+        return { kind: result.kind, taskRef: result.taskRef, threadRef: result.threadRef,
+            revision: result.revision, unreadCount: result.unreadCount, directCount: result.directCount };
+    if (result.kind === 'stale_revision')
+        return { kind: result.kind, taskRef: result.taskRef, threadRef: result.threadRef,
+            expectedRevision: result.expectedRevision, revision: result.revision };
+    throw new Error('Agents cannot receive invitation confirmations');
+}
+const teamClaim = defineTool({
+    name: 'team_claim',
+    description: 'List or mutate your Direction Claims. Read the Thread first; every mutation uses the current Thread revision.',
+    parameters: {
+        action: { type: 'string', required: true, enum: ['list', 'claim', 'done', 'release'] },
+        taskRef: { type: 'string', required: true, description: "Full branded Task ref exactly as returned by Team tools, including the 'task:' prefix." },
+        baseRevision: { type: 'number', description: "Positive integer; use the current Thread revision as shown by the latest team_inbox or team_thread result for this Task." }, direction: { type: 'string' },
+        claimRef: { type: 'string', description: "Full branded Claim ref exactly as returned by team_claim, including the 'claim:' prefix." },
+    },
+    output: {
+        schema: { type: 'object', additionalProperties: false, properties: {
+                kind: { type: 'string', required: true }, taskRef: { type: 'string', required: true }, threadRef: { type: 'string', required: true },
+                revision: { type: 'number', required: true }, expectedRevision: { type: 'number' }, status: { type: 'string', required: true },
+                unreadCount: { type: 'number' }, directCount: { type: 'number' },
+                claims: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: { claimRef: { type: 'string', required: true }, direction: { type: 'string', required: true }, state: { type: 'string', required: true }, owner: { type: 'string', required: true } } } },
+            } },
+        render: (_args, value) => [{ type: 'text', text: [`${value.kind}: ${value.taskRef} · ${value.status}, revision ${value.revision}`,
+                    ...value.claims.map(claim => `${claim.claimRef} · ${claim.state} — ${claim.owner}: ${claim.direction}`)].join('\n') }],
+    },
+    async execute(args, exec) {
+        const agent = exec.agent;
+        if (agent === undefined)
+            throw new Error('team_claim requires an Agent session');
+        const current = member(agent);
+        const host = service(agent);
+        const base = { workspaceId: current.workspaceId, taskRef: args.taskRef };
+        if (args.action === 'list') {
+            if (args.baseRevision !== undefined || args.direction !== undefined || args.claimRef !== undefined)
+                throw new Error('list accepts only taskRef');
+            const listed = host.listClaimsForAgent(agent, base);
+            return { kind: 'listed', taskRef: listed.task.taskRef, threadRef: listed.thread.threadRef, revision: listed.thread.revision, status: listed.task.status,
+                claims: listed.claims.map(claim => ({ claimRef: claim.claimRef, owner: claim.owner, direction: claim.direction, state: claim.state })) };
+        }
+        const baseRevision = args.baseRevision;
+        if (typeof baseRevision !== 'number' || !Number.isSafeInteger(baseRevision) || baseRevision < 1)
+            throw new Error("claim mutation requires a positive baseRevision; use the current Thread 'revision' returned by team_inbox or team_thread for this Task");
+        if (args.action === 'claim' && (args.direction === undefined || args.claimRef !== undefined))
+            throw new Error('claim requires direction and does not accept claimRef');
+        if ((args.action === 'done' || args.action === 'release') && (args.claimRef === undefined || args.direction !== undefined))
+            throw new Error(`${args.action} requires claimRef and does not accept direction`);
+        const result = await host.changeClaimForAgent(agent, { requestId: requestId(agent.id, exec.callId), ...base, action: args.action,
+            baseRevision, ...(args.direction === undefined ? {} : { direction: args.direction }), ...(args.claimRef === undefined ? {} : { claimRef: args.claimRef }) });
+        const listed = host.listClaimsForAgent(agent, base);
+        const claims = listed.claims.map(claim => ({ claimRef: claim.claimRef, owner: claim.owner, direction: claim.direction, state: claim.state }));
+        if (result.kind === 'committed')
+            return { kind: result.kind, taskRef: result.task.taskRef, threadRef: result.thread.threadRef,
+                revision: result.thread.revision, status: result.task.status, claims };
+        if (result.kind === 'unread_required')
+            return { kind: result.kind, taskRef: result.taskRef, threadRef: result.threadRef,
+                revision: result.revision, status: listed.task.status, unreadCount: result.unreadCount, directCount: result.directCount, claims };
+        return { kind: result.kind, taskRef: result.taskRef, threadRef: result.threadRef, expectedRevision: result.expectedRevision,
+            revision: result.revision, status: listed.task.status, claims };
+    },
+});
+const teamView = defineTool({
+    name: 'team_view',
+    description: 'Discover authorized Team Channels, Tasks, and Members. It is not a substitute for team_thread reading.',
+    parameters: {
+        channelRef: { type: 'string', description: "Full branded Channel ref exactly as returned by Team tools, including the 'channel:' prefix." },
+        limit: { type: 'number' }, cursor: { type: 'number' },
+    },
+    output: {
+        schema: { type: 'object', additionalProperties: false, properties: {
+                channels: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: { channelRef: { type: 'string', required: true }, name: { type: 'string', required: true } } } },
+                members: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
+                            memberId: { type: 'string', required: true }, kind: { type: 'string', required: true }, handle: { type: 'string', required: true }, description: { type: 'string', required: true }, presence: { type: 'string', required: true },
+                        } } },
+                tasks: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: { taskRef: { type: 'string', required: true }, threadRef: { type: 'string', required: true }, channelRef: { type: 'string', required: true }, status: { type: 'string', required: true }, revision: { type: 'number', required: true } } } },
+                cursor: { type: 'number', required: true }, hasMore: { type: 'boolean', required: true },
+            } },
+        render: (_args, value) => [{ type: 'text', text: [
+                    ...value.channels.map(channel => `${channel.channelRef} · ${channel.name}`),
+                    ...value.members.map(m => `${m.memberId} · ${m.handle} (${m.kind}, ${m.presence})${m.description === '' ? '' : ` — ${m.description}`}`),
+                    ...(value.tasks.length > 0
+                        ? value.tasks.map(task => `${task.taskRef} · ${task.status}`)
+                        : ['No Team Tasks.']),
+                ].join('\n') }],
+    },
+    async execute(args, exec) {
+        const agent = exec.agent;
+        if (agent === undefined)
+            throw new Error('team_view requires an Agent session');
+        const current = member(agent);
+        const host = service(agent);
+        const view = host.viewForAgent(agent, { workspaceId: current.workspaceId, ...(args.channelRef === undefined ? {} : { channelRef: args.channelRef }), ...(args.limit === undefined ? {} : { limit: args.limit }), ...(args.cursor === undefined ? {} : { cursor: args.cursor }), topLevelOnly: true, includeActivities: false });
+        const visibleMemberIds = new Set(view.members.map(membership => membership.memberId));
+        return {
+            channels: view.channels.map(channel => ({ channelRef: channel.channelRef, name: channel.name })),
+            members: [
+                { memberId: view.humanMemberId, kind: 'human', handle: 'human', description: 'Human Team Member', presence: 'available' },
+                ...host.members().filter(status => visibleMemberIds.has(status.member.memberId)).map(status => ({ memberId: status.member.memberId,
+                    kind: 'agent', handle: status.member.handle, description: status.member.description, presence: status.presence })),
+            ],
+            tasks: view.tasks.map(task => ({ taskRef: task.taskRef, threadRef: task.threadRef, channelRef: task.channelRef,
+                status: task.status, revision: view.threads.find(thread => thread.threadRef === task.threadRef)?.revision ?? 0 })),
+            cursor: view.cursor, hasMore: view.hasMore,
+        };
+    },
+});
+export function apply(ctx) {
+    ctx.tools.register(teamInbox);
+    ctx.tools.register(teamThread);
+    ctx.tools.register(teamMessage);
+    ctx.tools.register(teamClaim);
+    ctx.tools.register(teamView);
+}

package/packages/tool-agent-team/lib/types/index.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "wowyuarm-agent-team-tools";
+export declare const inject: string[];
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/packages/tool-agent-team/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAUlD,eAAO,MAAM,IAAI,8BAA8B,CAAA;AAC/C,eAAO,MAAM,MAAM,UAAY,CAAA;AAwR/B,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAMxC"}