@wowyuarm/dsh-agent-team 0.1.7 → 0.1.9

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

@@ -1,7 +1,44 @@
 import { AgentTeamDmDeliveryError, markAgentTeamPreset } from '@wowyuarm/dsh-agent-team/host';
+import { registerContextTools } from "./context-tools.js";
 import { defineTool } from '@deepseek-ai/dsh-tools';
 export const name = 'wowyuarm-agent-team-tools';
 export const inject = ['tools'];
+function activityFactView(sequence, activity, markers) {
+    return {
+        sequence, kind: 'activity', activity: activity.kind, actor: activity.actor, taskRef: activity.taskRef,
+        ...(activity.claimRef === undefined ? {} : { claimRef: activity.claimRef }),
+        ...(activity.claimRefs === undefined || activity.claimRefs.length === 0 ? {} : { claimRefs: [...activity.claimRefs] }),
+        ...(activity.completedClaimRefs === undefined || activity.completedClaimRefs.length === 0 ? {} : { completedClaimRefs: [...activity.completedClaimRefs] }),
+        ...(activity.acceptedClaimRefs === undefined || activity.acceptedClaimRefs.length === 0 ? {} : { acceptedClaimRefs: [...activity.acceptedClaimRefs] }),
+        ...(activity.releasedClaimRefs === undefined || activity.releasedClaimRefs.length === 0 ? {} : { releasedClaimRefs: [...activity.releasedClaimRefs] }),
+        ...(markers === undefined ? {} : { unread: markers.unread, direct: markers.direct }),
+    };
+}
+function adviceView(advice) {
+    return {
+        ...(advice.usageTokens === undefined ? {} : { usageTokens: advice.usageTokens }),
+        ...(advice.taskBoundaryThreshold === undefined ? {} : { taskBoundaryThreshold: advice.taskBoundaryThreshold }),
+        ...(advice.handoffAt === undefined ? {} : { handoffAt: advice.handoffAt }),
+        ...(advice.hardLimit === undefined ? {} : { hardLimit: advice.hardLimit }),
+        action: advice.action, guidance: advice.guidance,
+    };
+}
+/** Render one structured activity fact as a self-describing decision-surface line. */
+function activityLine(fact) {
+    const segments = [`${fact.sequence}`, fact.actor, fact.activity];
+    segments.push(`Task ${fact.taskRef}`);
+    if (fact.claimRef !== undefined)
+        segments.push(`Claim ${fact.claimRef}`);
+    if (fact.claimRefs !== undefined)
+        segments.push(`claims released ${fact.claimRefs.join(', ')}`);
+    if (fact.completedClaimRefs !== undefined)
+        segments.push(`completed claims ${fact.completedClaimRefs.join(', ')}`);
+    if (fact.acceptedClaimRefs !== undefined)
+        segments.push(`accepted claims ${fact.acceptedClaimRefs.join(', ')}`);
+    if (fact.releasedClaimRefs !== undefined)
+        segments.push(`released claims ${fact.releasedClaimRefs.join(', ')}`);
+    return segments.join(' ');
+}
 function service(agent) {
     const host = agent.ctx.get('agentTeam');
     if (host === undefined)
@@ -30,8 +67,9 @@ const teamInbox = defineTool({
                             taskNumber: { type: 'number' },
                         } } },
             } },
-        render: (_args, value) => [{ type: 'text', text: value.items.length === 0 ? 'No unread Team work.'
-                    : value.items.map(item => `${item.threadRef}${item.taskRef === undefined ? '' : ` · ${item.taskRef}`}${item.taskNumber === undefined ? '' : ` (#${item.taskNumber})`} · ${item.directCount > 0 ? 'direct' : 'unread'}, ${item.unreadCount} update(s), revision ${item.revision}`).join('\n') }],
+        render: (_args, value) => [{ type: 'text', text: value.items.length === 0 ? `No unread Team work.${value.totalUnreadCount > 0 ? ` (${value.totalUnreadCount} unread on Threads beyond this bounded list — call again with a larger limit.)` : ''}`
+                    : [`${value.totalUnreadCount} unread update(s) total, ${value.totalDirectCount} direct, across ${value.items.length} Thread(s) shown${value.totalUnreadCount > value.items.reduce((sum, item) => sum + item.unreadCount, 0) ? ' — more exist beyond this bounded list' : ''}`,
+                        ...value.items.map(item => `${item.threadRef}${item.channelRef === undefined ? '' : ` · ${item.channelRef}`}${item.taskRef === undefined ? '' : ` · ${item.taskRef}`}${item.taskNumber === undefined ? '' : ` (#${item.taskNumber})`}${item.status === undefined ? '' : ` (${item.status})`} · ${item.unreadCount} unread, ${item.directCount} direct, revision ${item.revision}`)].join('\n') }],
     },
     async execute(args, exec) {
         const agent = exec.agent;
@@ -59,7 +97,7 @@ const teamThread = defineTool({
     description: 'Read or manage your Attention on one Thread. read acknowledges one chronological batch; history does not change read state. Prefer threadRef; taskRef is a compatibility alias when the Thread has a Task.',
     parameters: {
         action: { type: 'string', required: true, enum: ['status', 'follow', 'unfollow', 'read', 'history'] },
-        threadRef: { type: 'string', description: "Full branded Thread ref exactly as returned by Team tools, including the 'thread:' prefix." },
+        threadRef: { type: 'string', description: "Full branded Thread ref exactly as returned by Team tools, including the 'thread:' prefix. An unambiguous abbreviation of the first 6+ UUID hex characters also resolves." },
         taskRef: { type: 'string', description: "Optional Task ref alias for released clients. Prefer threadRef; if both are given they must identify the same Thread." },
         beforeSequence: { type: 'number' }, limit: { type: 'number' },
     },
@@ -75,14 +113,56 @@ const teamThread = defineTool({
                             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' },
+                            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' }, actor: { type: 'string' }, taskRef: { type: 'string' }, claimRef: { type: 'string' }, claimRefs: { type: 'array', items: { type: 'string' } }, completedClaimRefs: { type: 'array', items: { type: 'string' } }, acceptedClaimRefs: { type: 'array', items: { type: 'string' } }, releasedClaimRefs: { type: 'array', items: { type: 'string' } }, unread: { type: 'boolean' }, direct: { type: 'boolean' },
                         } } },
+                contextAdvice: { type: 'object', additionalProperties: false, properties: {
+                        usageTokens: { type: 'number' }, taskBoundaryThreshold: { type: 'number' }, handoffAt: { type: 'number' }, hardLimit: { type: 'number' },
+                        action: { type: 'string', required: true }, guidance: { type: 'string', required: true },
+                    } },
             } },
-        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') }],
+        // Renders are the only channel a tool result reaches the model through:
+        // the header states the Thread ref and the Task's standing, each activity
+        // line names the actor and every Claim the activity concluded, message
+        // facts carry their unread/direct markers so a bounded batch can be
+        // re-read discriminately, an acceptance the reader just acknowledged
+        // carries one context-guidance section, and read/history footers state
+        // what remains or whether older facts exist.
+        render: (_args, value) => {
+            // The header always identifies the Thread first — the ref the model
+            // must echo in its next team_message reply — then the Task's standing
+            // when the Thread is taskful. An empty-facts status/follow result
+            // still carries the same identifying surface.
+            const header = [
+                value.threadRef,
+                value.taskRef === undefined ? '' : `${value.taskRef} · ${value.status}${value.resolution === undefined ? '' : `/${value.resolution}`}`,
+                `revision ${value.revision}, following=${value.following}`,
+            ].filter(part => part !== '').join(' · ');
+            const lines = [header];
+            // The Claims snapshot is the collision surface: another Member's
+            // active Claim on this Task is invisible while facts alone render,
+            // yet exactly what the model must see before claiming its own angle.
+            for (const claim of value.claims)
+                lines.push(`Claim ${claim.claimRef} · ${claim.state} — ${claim.owner}: ${claim.direction}`);
+            // The anchor is the Thread's root task statement. Render it whenever
+            // it is not already among the facts, so a model reading a Thread for
+            // the first time never loses the original ask.
+            if (!value.facts.some(fact => fact.sequence === value.anchor.sequence))
+                lines.push(`Anchor ${value.anchor.sequence} [${value.anchor.sender}] ${value.anchor.body}`);
+            for (const fact of value.facts) {
+                lines.push(fact.kind === 'message'
+                    ? `${fact.sequence} [${fact.sender ?? 'unknown sender'}]${fact.unread === undefined ? '' : fact.direct === true ? ' [direct]' : fact.unread === true ? ' [unread]' : ''} ${fact.body}`
+                    : activityLine(fact));
+                if (fact.kind !== 'message' && fact.unread === true)
+                    lines.push(`${fact.sequence} … (unread activity)`);
+            }
+            if (value.kind === 'read')
+                lines.push(`Read through sequence ${value.readThroughSequence}; ${value.remainingUnreadCount ?? 0} unread update(s) remaining — call team_thread read again${(value.remainingUnreadCount ?? 0) > 0 ? '' : ' when new work arrives'}.`);
+            if (value.kind === 'history')
+                lines.push(`History cursor ${value.cursor}; hasMore=${value.hasMore ? 'true' : 'false'}${value.hasMore ? ' — older facts exist; page again with beforeSequence set to the cursor.' : ' — no older facts remain.'}`);
+            if (value.kind === 'read' && value.contextAdvice !== undefined)
+                lines.push(...adviceLines(value.contextAdvice));
+            return [{ type: 'text', text: lines.join('\n') }];
+        },
     },
     async execute(args, exec) {
         const agent = exec.agent;
@@ -112,14 +192,14 @@ const teamThread = defineTool({
             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 });
+                : activityFactView(fact.sequence, fact.activity)), { 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 });
+            : activityFactView(entry.fact.sequence, entry.fact.activity, { unread: entry.unread, direct: entry.direct })), { readThroughSequence: read.readThroughSequence, remainingUnreadCount: read.remainingUnreadCount, ...(read.contextAdvice === undefined ? {} : { contextAdvice: adviceView(read.contextAdvice) }) });
     },
 });
 function threadResult(kind, snapshot, attention, facts, extra = {}) {
@@ -134,17 +214,25 @@ function threadResult(kind, snapshot, attention, facts, extra = {}) {
         facts,
     };
 }
+/** Render one read-time acceptance advice; unavailable never prints a fabricated number. */
+function adviceLines(advice) {
+    const measured = advice.usageTokens !== undefined && advice.taskBoundaryThreshold !== undefined && advice.handoffAt !== undefined && advice.hardLimit !== undefined;
+    const summary = measured
+        ? `${advice.usageTokens.toLocaleString('en-US')} tokens used; Task-boundary threshold ${advice.taskBoundaryThreshold.toLocaleString('en-US')}; normal handoff at ${advice.handoffAt.toLocaleString('en-US')}; hard limit ${advice.hardLimit.toLocaleString('en-US')}.`
+        : 'Context usage could not be measured for this acceptance.';
+    return [`Context guidance — ${summary}`, `Action: ${advice.action}. ${advice.guidance}`];
+}
 const teamMessage = markAgentTeamPreset(defineTool({
     name: 'team_message',
     description: 'Start a top-level Thread, reply to an existing Thread, or send a direct message (DM). start defaults to a taskless Thread; pass asTask true to create a Task in the same send. Read the Thread first; replies require its current revision (an internal concurrency token carried by baseRevision, never quoted in bodies). 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. dm sends a private direct message to one enabled Agent Member in your Workspace: use it for quick clarifications and status syncs — never for task work, decisions, or anything that needs team visibility or traceability (use a Thread); if a DM exchange with the same Member exceeds about 3 exchanges, move it to a Thread, because every DM costs the recipient a full agent turn.',
     parameters: {
         action: { type: 'string', required: true, enum: ['start', 'reply', 'dm'] },
-        channelRef: { type: 'string', description: "Full branded Channel ref exactly as returned by Team tools, including the 'channel:' prefix." },
-        threadRef: { type: 'string', description: "Full branded Thread ref exactly as returned by Team tools, including the 'thread:' prefix." },
-        taskRef: { type: 'string', description: "Optional Task ref alias for reply on a Taskful Thread. Prefer threadRef." },
-        memberRef: { type: 'string', description: "Full branded Member ref exactly as returned by Team tools, including the 'member:' prefix. Required for dm; the Member must be an enabled Agent in your Workspace (the Human cannot be DMed)." },
+        channelRef: { type: 'string', description: "Full branded Channel ref exactly as returned by Team tools, including the 'channel:' prefix. An unambiguous abbreviation of the first 6+ UUID hex characters also resolves." },
+        threadRef: { type: 'string', description: "Full branded Thread ref exactly as returned by Team tools, including the 'thread:' prefix. An unambiguous abbreviation of the first 6+ UUID hex characters also resolves." },
+        taskRef: { type: 'string', description: "Optional Task ref alias for reply on a Taskful Thread. Prefer threadRef; an unambiguous abbreviation of the first 6+ UUID hex characters also resolves." },
+        memberRef: { type: 'string', description: "Full branded Member ref exactly as returned by Team tools, including the 'member:' prefix. An unambiguous abbreviation of the first 6+ UUID hex characters also resolves. Required for dm; the Member must be an enabled Agent in your Workspace (the Human cannot be DMed)." },
         asTask: { type: 'boolean', description: 'When true, start creates a Task with the Thread. Default false creates a taskless Thread.' },
-        body: { type: 'string', required: true, description: "Markdown body. Cite Team refs exactly as returned, as bare text with one colon (e.g. task:0f0a…) — never a double colon, never inside backticks or quotes. Spell each mentioned Member's handle in the prose so the mention renders inline." }, baseRevision: { type: 'number', description: "Positive integer; use the current Thread revision as shown by the latest team_inbox or team_thread result for this Thread. The revision is an internal concurrency token, not a citable fact." },
+        body: { type: 'string', required: true, description: "Markdown body. Cite Team refs exactly as returned, as bare text with one colon (e.g. task:0f0a…) — never a double colon, never inside backticks or quotes. Unambiguous UUID abbreviations (first 6+ hex chars) also resolve. Spell each mentioned Member's handle in the prose so the mention renders inline." }, baseRevision: { type: 'number', description: "Positive integer; use the current Thread revision as shown by the latest team_inbox or team_thread result for this Thread. The revision is an internal concurrency token, not a citable fact." },
         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.' },
         attachments: { type: 'array', items: { type: 'string' }, description: 'Absolute file paths to share, e.g. screenshots or generated artifacts; images render as thumbnails for recipients. The Host validates each path and copies the file into the attachment cache, and members also receive one cached path per attachment; if any path fails validation the whole send is rejected.' },
     },
@@ -155,8 +243,18 @@ const teamMessage = markAgentTeamPreset(defineTool({
                 recipientMemberId: { type: 'string' }, recipientHandle: { type: 'string' }, delivered: { type: 'boolean' }, deliveryNote: { type: 'string' },
             } },
         render: (_args, value) => [{ type: 'text', text: value.kind === 'dm-sent' ? `DM ${value.delivered === false ? 'recorded but not delivered' : 'delivered'} to @${value.recipientHandle} (${value.recipientMemberId})${value.deliveryNote === undefined ? '' : `: ${value.deliveryNote}`}`
-                    : value.kind === 'committed' ? `Message ${value.messageRef} committed at revision ${value.revision}.`
-                        : `${value.kind}: ${value.memberIds?.join(', ') ?? `${value.threadRef ?? ''}${value.taskRef === undefined ? '' : ` · Task ${value.taskRef}`} revision ${value.revision ?? ''}`}` }],
+                    : value.kind === 'committed' ? `Message ${value.messageRef} committed at revision ${value.revision} on ${value.threadRef}${value.taskRef === undefined ? '' : ` (${value.taskRef})`}.`
+                        : value.kind === 'unread_required' ? `unread_required: ${value.threadRef}${value.taskRef === undefined ? '' : ` (${value.taskRef})`} has ${value.unreadCount} unread update(s), ${value.directCount} direct at revision ${value.revision}. Read the pending updates (team_thread read) before retrying this send.`
+                            : value.kind === 'stale_revision' ? `stale_revision: your baseRevision ${value.expectedRevision} is obsolete; ${value.threadRef}${value.taskRef === undefined ? '' : ` (${value.taskRef})`} is now at revision ${value.revision}. Read the Thread, then retry with baseRevision ${value.revision}.`
+                                : value.kind === 'member_not_following' ? `member_not_following: ${(value.memberIds ?? []).join(', ')} not following; the message was not committed. Only a Human can invite an unfollowed Agent — retry without mentioning them, or ask the Human.`
+                                    : `${value.kind}: ${value.memberIds?.join(', ') ?? `${value.threadRef ?? ''}${value.taskRef === undefined ? '' : ` · Task ${value.taskRef}`} revision ${value.revision ?? ''}`}` }],
+        // Minimal durable projection for the Host's context timeline: the
+        // structured outcome identity (never the render text). The effect-anchor
+        // fold reads `kind === 'committed'` + threadRef from the persisted
+        // tool/result meta — a start's Thread is born here, in the result.
+        presentationMeta: (_args, value) => value.kind === 'committed' && value.threadRef !== undefined
+            ? { kind: value.kind, threadRef: value.threadRef, ...(value.taskRef === undefined ? {} : { taskRef: value.taskRef }) }
+            : { kind: value.kind },
     },
     async execute(args, exec) {
         const agent = exec.agent;
@@ -225,9 +323,9 @@ const teamClaim = defineTool({
     description: 'List or mutate your Direction Claims. Read the Thread first; every mutation uses the current Thread revision. A Claim is your one-sentence direction statement on a Task — "the angle I am taking" — so others can spot collisions and track progress: Tasks define scope (owned by Humans), Claims declare the angle (owned by you). Good direction: "Unify the four form dialogs on shared field components before wiring submits." Bad direction: a multi-paragraph plan with step order, file lists, or acceptance criteria — those belong in Thread messages, not the Claim.',
     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." },
+        taskRef: { type: 'string', required: true, description: "Full branded Task ref exactly as returned by Team tools, including the 'task:' prefix. An unambiguous abbreviation of the first 6+ UUID hex characters also resolves." },
         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. The revision is an internal concurrency token, not a citable fact." }, direction: { type: 'string' },
-        claimRef: { type: 'string', description: "Full branded Claim ref exactly as returned by team_claim, including the 'claim:' prefix." },
+        claimRef: { type: 'string', description: "Full branded Claim ref exactly as returned by team_claim, including the 'claim:' prefix. An unambiguous abbreviation of the first 6+ UUID hex characters also resolves." },
     },
     output: {
         schema: { type: 'object', additionalProperties: false, properties: {
@@ -236,8 +334,14 @@ const teamClaim = defineTool({
                 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') }],
+        render: (_args, value) => [{ type: 'text', text: [
+                    value.kind === 'unread_required'
+                        ? `unread_required: ${value.taskRef} (${value.threadRef}) has ${value.unreadCount} unread update(s), ${value.directCount} direct at revision ${value.revision}. Read the pending updates (team_thread read) before retrying this Claim mutation.`
+                        : value.kind === 'stale_revision'
+                            ? `stale_revision: your baseRevision ${value.expectedRevision} is obsolete; ${value.taskRef} (${value.threadRef}) is now at revision ${value.revision}. Read the Thread, then retry with baseRevision ${value.revision}.`
+                            : `${value.kind}: ${value.taskRef} (${value.threadRef}) · ${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;
@@ -276,9 +380,9 @@ const teamClaim = defineTool({
 });
 const teamView = defineTool({
     name: 'team_view',
-    description: 'Discover authorized Team Channels, Tasks, and Members. It is not a substitute for team_thread reading.',
+    description: 'Discover authorized Team Channels, top-level Threads, 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." },
+        channelRef: { type: 'string', description: "Full branded Channel ref exactly as returned by Team tools, including the 'channel:' prefix. An unambiguous abbreviation of the first 6+ UUID hex characters also resolves." },
         limit: { type: 'number' }, cursor: { type: 'number' },
     },
     output: {
@@ -287,15 +391,23 @@ const teamView = defineTool({
                 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 },
                         } } },
+                threads: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
+                            threadRef: { type: 'string', required: true }, channelRef: { type: 'string', required: true }, revision: { type: 'number', required: true }, messageCount: { type: 'number', required: true },
+                            taskRef: { type: 'string' }, status: { type: 'string' }, taskNumber: { type: 'number' },
+                        } } },
                 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.threads.length > 0
+                        ? value.threads.map(thread => `${thread.threadRef} · ${thread.channelRef}${thread.taskRef === undefined ? '' : ` · ${thread.taskRef}${thread.taskNumber === undefined ? '' : ` (#${thread.taskNumber})`} (${thread.status})`} · ${thread.messageCount} message(s), revision ${thread.revision}`)
+                        : ['No Team Threads.']),
                     ...(value.tasks.length > 0
-                        ? value.tasks.map(task => `${task.taskRef} · ${task.status}`)
+                        ? value.tasks.map(task => `${task.taskRef} · ${task.threadRef} · ${task.channelRef} · ${task.status}, revision ${task.revision}`)
                         : ['No Team Tasks.']),
+                    `cursor ${value.cursor}, hasMore=${value.hasMore ? 'true' : 'false'}${value.hasMore ? ' — more items exist; call team_view again with cursor set to this value.' : ' — no further pages.'}`,
                 ].join('\n') }],
     },
     async execute(args, exec) {
@@ -313,6 +425,12 @@ const teamView = defineTool({
                 ...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 })),
             ],
+            threads: view.items.map(item => {
+                const thread = item.thread;
+                const task = item.task;
+                return { threadRef: thread.threadRef, channelRef: item.message.channelRef, revision: thread.revision, messageCount: item.messageCount,
+                    ...(task === undefined ? {} : { taskRef: task.taskRef, status: task.status, ...(item.taskNumber === undefined ? {} : { taskNumber: item.taskNumber }) }) };
+            }),
             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,
@@ -325,4 +443,5 @@ export function apply(ctx) {
     ctx.tools.register(teamMessage);
     ctx.tools.register(teamClaim);
     ctx.tools.register(teamView);
+    registerContextTools(ctx);
 }

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

@@ -0,0 +1,16 @@
+/**
+ * Model-facing context-management tools for Team Members. Thin adapters
+ * only: validation runs in the Host adapter, the successful result is the
+ * durable intent, and every lifecycle side effect — generation swap, Session
+ * creation, inbox handling — happens in the Host coordinator after the
+ * result is durably appended. `concludeTurn()` rides the success result of
+ * `context_rollover` and `context_checkpoint`, so sibling calls settle in model
+ * order before the turn closes.
+ * @module @wowyuarm/dsh-agent-team/context-tools
+ */
+export declare function registerContextTools(ctx: {
+    readonly tools: {
+        register(tool: unknown): void;
+    };
+}): void;
+//# sourceMappingURL=context-tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context-tools.d.ts","sourceRoot":"","sources":["../../src/context-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAoKH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAA;KAAE,CAAA;CAAE,GAAG,IAAI,CAIrG"}

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

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

package/packages/agent-team/lib/auto-compaction.js

@@ -1,201 +0,0 @@
-import { ManualCompactionError } from '@deepseek-ai/dsh-compaction';
-/** Strict threshold: 200K exactly does not compact. */
-export const AUTO_COMPACTION_TOKEN_LIMIT = 200_000;
-/**
- * Suggested summary marker of the pre-compaction memory hint. Same shape as
- * the inbox and recovery notices so future turns can recognize it.
- */
-export const PRE_COMPACTION_NOTICE_SUMMARY = 'Compaction is imminent; consider persisting key conclusions.';
-/** Suggested pre-compaction hint body; writing is the Agent's own call. */
-export function preCompactionNoticeText() {
-    return 'This session is about to be compacted, which will summarize away the current conversation detail. If there are durable conclusions worth keeping — validated facts, decisions, or reusable details — consider writing them to your memory or notes now. This is only a reminder: decide yourself whether anything is worth persisting, and do nothing if not. Do not start new work because of this message.';
-}
-/** Claim owners of a durable Human acceptance, including early-completed ones. */
-export function acceptedTaskCompactionMembers(operation) {
-    if (operation.kind !== 'team/task-changed' || operation.actor.kind !== 'human' || operation.data.activity.kind !== 'accept')
-        return undefined;
-    return [...new Set(operation.data.claims.map(claim => claim.owner))];
-}
-/**
- * Small Host-side accepted-Task follow-up. This is deliberately not a generic
- * workflow/state-machine: a pending set deduplicates Members, an error map is
- * owned by the Host, and each worker is only whenIdle → measure → compactNow.
- */
-export class AutoCompactionCoordinator {
-    options;
-    pending = new Set();
-    workers = new Map();
-    controller = new AbortController();
-    constructor(options) {
-        this.options = options;
-    }
-    /** Queue all unique claim owners; unavailable Members stay pending. */
-    schedule(memberIds) {
-        for (const memberId of new Set(memberIds)) {
-            this.pending.add(memberId);
-            this.start(memberId);
-        }
-    }
-    /** Activation/recovery calls this after a live handle becomes available. */
-    activated(memberId) {
-        this.start(memberId);
-    }
-    async dispose() {
-        this.controller.abort();
-        await Promise.all([...this.workers.values()].map(worker => worker.catch(() => { })));
-        this.workers.clear();
-        this.pending.clear();
-    }
-    start(memberId) {
-        if (this.controller.signal.aborted || this.workers.has(memberId) || !this.pending.has(memberId))
-            return;
-        // No live handle is not a failure: member activation/recovery calls activated().
-        if (this.options.agentForMember(memberId) === undefined)
-            return;
-        const worker = this.work(memberId).finally(() => { this.workers.delete(memberId); });
-        this.workers.set(memberId, worker);
-    }
-    async work(memberId) {
-        let reactivated = false;
-        while (!this.controller.signal.aborted && this.pending.has(memberId)) {
-            const agent = this.options.agentForMember(memberId);
-            if (agent === undefined)
-                return;
-            try {
-                if (!(await waitForIdleOrAbort(agent, this.controller.signal)))
-                    return;
-            }
-            catch (error) {
-                this.fail(memberId, agent, `automatic compaction idle wait failed: ${describe(error)}`);
-                return;
-            }
-            // A restart can replace the handle while it waited; restart the turn on
-            // the current agent so measurement and compactNow share one scope.
-            if (this.options.agentForMember(memberId) !== agent)
-                continue;
-            const meter = agent.ctx.get('tokenMeter');
-            if (meter === undefined) {
-                this.fail(memberId, agent, 'automatic compaction failed: tokenMeter is unavailable in the Member scope');
-                return;
-            }
-            let before = meter.measure(agent.session).totalTokens;
-            if (before <= AUTO_COMPACTION_TOKEN_LIMIT) {
-                this.complete(memberId, agent);
-                return;
-            }
-            // The session is over the threshold and about to be compacted: steer one
-            // advisory hint so the Agent can persist its own key conclusions first.
-            // The hint turn itself is ordinary agent work — its failure is contained
-            // by the agent loop and never blocks compaction; only the fresh idle
-            // boundary is awaited before the final measurement and compactNow.
-            if (this.options.steerPreCompaction !== undefined) {
-                try {
-                    this.options.steerPreCompaction(agent);
-                }
-                catch (error) {
-                    this.options.log(`pre-compaction memory hint failed: ${describe(error)} (member ${memberId}, session ${agent.id})`);
-                }
-                try {
-                    if (!(await waitForIdleOrAbort(agent, this.controller.signal)))
-                        return;
-                }
-                catch (error) {
-                    this.options.log(`pre-compaction hint idle wait failed: ${describe(error)} (member ${memberId}, session ${agent.id})`);
-                }
-                if (this.controller.signal.aborted)
-                    return;
-                if (this.options.agentForMember(memberId) !== agent)
-                    continue;
-                before = meter.measure(agent.session).totalTokens;
-                if (before <= AUTO_COMPACTION_TOKEN_LIMIT) {
-                    this.complete(memberId, agent);
-                    return;
-                }
-            }
-            const engine = this.options.compactionForAgent(agent);
-            if (engine === undefined) {
-                // A roster-subtree teardown (bundle-row reload, config hot-apply)
-                // prunes the standing mount while this agent's scope binding still
-                // names the dead key, so resolution can never succeed again for this
-                // handle. One in-place re-activation rebuilds the binding from the
-                // live roster; a preset that mounts no compaction row keeps failing
-                // and lands in the terminal diagnostic below.
-                if (!reactivated && await this.tryReactivate(memberId)) {
-                    reactivated = true;
-                    continue;
-                }
-                this.fail(memberId, agent, 'automatic compaction failed: compaction is unavailable in the Member scope');
-                return;
-            }
-            try {
-                const result = await engine.compactNow(agent, this.controller.signal);
-                if (this.controller.signal.aborted)
-                    return;
-                if (result === null) {
-                    this.fail(memberId, agent, `automatic compaction returned no compactable range above ${AUTO_COMPACTION_TOKEN_LIMIT} tokens`);
-                    return;
-                }
-            }
-            catch (error) {
-                if (this.controller.signal.aborted)
-                    return;
-                if (error instanceof ManualCompactionError && error.code === 'busy')
-                    continue;
-                this.fail(memberId, agent, `automatic compaction failed: ${describe(error)}`);
-                return;
-            }
-            const after = meter.measure(agent.session).totalTokens;
-            if (after >= before) {
-                this.fail(memberId, agent, `automatic compaction did not reduce context (${before} → ${after} tokens)`);
-                return;
-            }
-            this.options.cleared(memberId, agent.id);
-            // Still over the strict threshold: next iteration waits at a fresh idle
-            // boundary before attempting another compactNow.
-        }
-    }
-    complete(memberId, agent) {
-        this.pending.delete(memberId);
-        this.options.cleared(memberId, agent.id);
-    }
-    tryReactivate(memberId) {
-        return this.options.reactivate(memberId).catch(error => {
-            this.options.log(`automatic compaction re-activation failed: ${describe(error)} (member ${memberId})`);
-            return false;
-        });
-    }
-    fail(memberId, agent, diagnostic) {
-        this.pending.delete(memberId);
-        this.options.log(`${diagnostic} (member ${memberId}, session ${agent.id})`);
-        this.options.failed(memberId, agent.id, diagnostic);
-    }
-}
-/** Abortable idle wait; the Agent owns its idle promise and is never cancelled. */
-function waitForIdleOrAbort(agent, signal) {
-    const idle = agent.whenIdle();
-    if (signal.aborted) {
-        // The agent may settle or reject after teardown; keep that late outcome
-        // observed without making it a coordinator failure.
-        void idle.catch(() => { });
-        return Promise.resolve(false);
-    }
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const finish = (outcome, error) => {
-            if (settled)
-                return;
-            settled = true;
-            signal.removeEventListener('abort', onAbort);
-            if (outcome === 'error')
-                reject(error);
-            else
-                resolve(outcome === 'idle');
-        };
-        const onAbort = () => { finish('aborted'); };
-        signal.addEventListener('abort', onAbort, { once: true });
-        idle.then(() => { finish('idle'); }, error => { finish('error', error); });
-    });
-}
-function describe(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/packages/agent-team/lib/types/auto-compaction.d.ts

@@ -1,47 +0,0 @@
-import type { Agent } from '@deepseek-ai/dsh-agent';
-import { type CompactionEngine } from '@deepseek-ai/dsh-compaction';
-import type { AgentTeamMemberId, AgentTeamOperation } from './types.ts';
-/** Strict threshold: 200K exactly does not compact. */
-export declare const AUTO_COMPACTION_TOKEN_LIMIT = 200000;
-/**
- * Suggested summary marker of the pre-compaction memory hint. Same shape as
- * the inbox and recovery notices so future turns can recognize it.
- */
-export declare const PRE_COMPACTION_NOTICE_SUMMARY = "Compaction is imminent; consider persisting key conclusions.";
-/** Suggested pre-compaction hint body; writing is the Agent's own call. */
-export declare function preCompactionNoticeText(): string;
-/** Claim owners of a durable Human acceptance, including early-completed ones. */
-export declare function acceptedTaskCompactionMembers(operation: AgentTeamOperation): readonly AgentTeamMemberId[] | undefined;
-/**
- * Small Host-side accepted-Task follow-up. This is deliberately not a generic
- * workflow/state-machine: a pending set deduplicates Members, an error map is
- * owned by the Host, and each worker is only whenIdle → measure → compactNow.
- */
-export declare class AutoCompactionCoordinator {
-    private readonly options;
-    private readonly pending;
-    private readonly workers;
-    private readonly controller;
-    constructor(options: {
-        readonly agentForMember: (memberId: AgentTeamMemberId) => Agent | undefined;
-        readonly compactionForAgent: (agent: Agent) => CompactionEngine | undefined;
-        /** Rebuild one enabled Member in place from its persisted Session; false when it stays unusable. */
-        readonly reactivate: (memberId: AgentTeamMemberId) => Promise<boolean>;
-        readonly failed: (memberId: AgentTeamMemberId, sessionId: Agent['id'], diagnostic: string) => void;
-        readonly cleared: (memberId: AgentTeamMemberId, sessionId: Agent['id']) => void;
-        readonly log: (message: string) => void;
-        /** Steer the pre-compaction memory hint; absent skips the hint entirely. */
-        readonly steerPreCompaction?: (agent: Agent) => void;
-    });
-    /** Queue all unique claim owners; unavailable Members stay pending. */
-    schedule(memberIds: readonly AgentTeamMemberId[]): void;
-    /** Activation/recovery calls this after a live handle becomes available. */
-    activated(memberId: AgentTeamMemberId): void;
-    dispose(): Promise<void>;
-    private start;
-    private work;
-    private complete;
-    private tryReactivate;
-    private fail;
-}
-//# sourceMappingURL=auto-compaction.d.ts.map

package/packages/agent-team/lib/types/auto-compaction.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auto-compaction.d.ts","sourceRoot":"","sources":["../../src/auto-compaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AACnD,OAAO,EAAyB,KAAK,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAG1F,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEvE,uDAAuD;AACvD,eAAO,MAAM,2BAA2B,SAAU,CAAA;AAElD;;;GAGG;AACH,eAAO,MAAM,6BAA6B,iEAAiE,CAAA;AAE3G,2EAA2E;AAC3E,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD;AAED,kFAAkF;AAClF,wBAAgB,6BAA6B,CAAC,SAAS,EAAE,kBAAkB,GAAG,SAAS,iBAAiB,EAAE,GAAG,SAAS,CAGrH;AAED;;;;GAIG;AACH,qBAAa,yBAAyB;IAKxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8C;IACtE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAwB;gBAEtB,OAAO,EAAE;QACpC,QAAQ,CAAC,cAAc,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,KAAK,GAAG,SAAS,CAAA;QAC3E,QAAQ,CAAC,kBAAkB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,gBAAgB,GAAG,SAAS,CAAA;QAC3E,oGAAoG;QACpG,QAAQ,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;QACtE,QAAQ,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,iBAAiB,EAAE,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAA;QAClG,QAAQ,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,iBAAiB,EAAE,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,IAAI,CAAA;QAC/E,QAAQ,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;QACvC,4EAA4E;QAC5E,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;KACrD;IAED,uEAAuE;IACvE,QAAQ,CAAC,SAAS,EAAE,SAAS,iBAAiB,EAAE,GAAG,IAAI;IAOvD,4EAA4E;IAC5E,SAAS,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAItC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAO9B,OAAO,CAAC,KAAK;YAQC,IAAI;IAuFlB,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,IAAI;CAKb"}

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

@@ -1,12 +0,0 @@
-import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
-/** Public input-dock slot currency for the Member Session strip. */
-export type TeamMemberDockProps = PropsRuntime<'conversation.input.dock'> & PropsLocale<'team'>;
-/**
- * Team-owned strip above the shipped composer while a Member Session is
- * embedded. The shipped InputBar keeps the whole input surface (draft,
- * trigger menus, submit); this dock only carries what the shipped bar cannot
- * know — the Member-Session vocabulary hint and the Member turn's prompt
- * error, read through the standard useSession hook.
- */
-export declare function TeamMemberDock({ t, useSession }: TeamMemberDockProps): import("react").JSX.Element;
-//# sourceMappingURL=TeamMemberDock.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"TeamMemberDock.d.ts","sourceRoot":"","sources":["../../../src/client/TeamMemberDock.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAGjF,oEAAoE;AACpE,MAAM,MAAM,mBAAmB,GAAG,YAAY,CAAC,yBAAyB,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,CAAA;AAE/F;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,mBAAmB,+BAQpE"}

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

@@ -1,13 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import css from './composer.module.css';
-/**
- * Team-owned strip above the shipped composer while a Member Session is
- * embedded. The shipped InputBar keeps the whole input surface (draft,
- * trigger menus, submit); this dock only carries what the shipped bar cannot
- * know — the Member-Session vocabulary hint and the Member turn's prompt
- * error, read through the standard useSession hook.
- */
-export function TeamMemberDock({ t, useSession }) {
-    const promptError = useSession(state => state.promptError ?? null);
-    return _jsxs("div", { className: css.memberSessionDock, "data-team-member-dock": "true", children: [_jsx("span", { className: css.memberSessionHint, children: t('memberSessionHint') }), promptError !== null && (_jsx("p", { className: css.memberSessionStatus, role: "alert", children: promptError.error.message }))] });
-}