@wowyuarm/dsh-agent-team 0.1.8 → 0.1.10

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

@@ -1,7 +1,81 @@
 import { AgentTeamDmDeliveryError, markAgentTeamPreset } from '@wowyuarm/dsh-agent-team/host';
+import { formatTeamTimestamp } from '@wowyuarm/dsh-agent-team/time-format';
+import { registerContextTools } from "./context-tools.js";
 import { defineTool } from '@deepseek-ai/dsh-tools';
 export const name = 'wowyuarm-agent-team-tools';
 export const inject = ['tools'];
+/** One shared bound for every bounded anchor subject a render shows. */
+const SUBJECT_BOUND = 80;
+function claimView(claim) {
+    return { claimRef: claim.claimRef, direction: claim.direction, state: claim.state, owner: claim.owner };
+}
+function activityFactView(sequence, activity, markers, occurredAt) {
+    return {
+        sequence, kind: 'activity', activity: activity.kind, actor: activity.actor, taskRef: activity.taskRef,
+        ...(occurredAt === undefined ? {} : { occurredAt }),
+        ...(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,
+    };
+}
+/**
+ * The one deterministic bounded subject, shared by directory rows and Thread
+ * orientation: whitespace collapses to one line, then one bounded cut with an
+ * explicit truncation mark. Directory, read, and history orientation must
+ * never disagree about what a Thread is about.
+ */
+function boundedSubject(body) {
+    const collapsed = body.replaceAll(/\s+/gu, ' ').trim();
+    return collapsed.length <= SUBJECT_BOUND ? collapsed : `${collapsed.slice(0, SUBJECT_BOUND - 1)}…`;
+}
+/** Unread/direct markers sit on the fact line itself; a fact carrying neither renders neither. */
+function factMarkers(fact) {
+    if (fact.unread === undefined)
+        return '';
+    if (fact.direct === true)
+        return ' [direct]';
+    if (fact.unread === true)
+        return ' [unread]';
+    return '';
+}
+/** 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(' ');
+}
+/** The one hand-off line a fully drained read or a committed public mutation may render. */
+function nextWriteLine(revision) {
+    return `Next write — baseRevision: ${revision} (copy exactly; never derive or cite).`;
+}
+/** Task standing inline on a Thread identity line; absent on taskless Threads. */
+function taskStanding(value) {
+    if (value.taskRef === undefined)
+        return '';
+    return `${value.taskRef}${value.taskNumber === undefined ? '' : ` (#${value.taskNumber})`}${value.status === undefined ? '' : `, ${value.status}${value.resolution === undefined ? '' : `/${value.resolution}`}`}`;
+}
 function service(agent) {
     const host = agent.ctx.get('agentTeam');
     if (host === undefined)
@@ -17,9 +91,41 @@ function member(agent) {
 function requestId(agentId, callId) {
     return `agent-team:tool:${agentId}:${callId}`;
 }
+/**
+ * One typed-rejection renderer parameterized by the mutation noun, shared by
+ * team_message and team_claim. Outcome first, action-local recovery facts,
+ * then the single recovery route: read the named Thread and reconsider — a
+ * rejection carries no changed facts, so it never renders a numeric revision
+ * or a next-write token.
+ */
+function rejectionLines(noun, value) {
+    const identity = [
+        value.threadRef === undefined ? '' : value.threadRef,
+        value.taskRef === undefined ? '' : value.taskRef,
+    ].filter(part => part !== '').join(' · ');
+    if (value.kind === 'unread_required') {
+        return [
+            'Not committed — unread_required.',
+            `${identity}${identity === '' ? '' : ' · '}${value.unreadCount ?? 0} unread, ${value.directCount ?? 0} direct`,
+            `Read the pending updates with team_thread read before reconsidering this ${noun}.`,
+        ];
+    }
+    if (value.kind === 'stale_revision') {
+        return [
+            'Not committed — the Thread changed after your last read (stale_revision).',
+            identity,
+            `Read the Thread, reconsider the new facts, then retry this ${noun} with the token that read returns.`,
+        ];
+    }
+    return [
+        'Not committed — member_not_following.',
+        `${(value.memberIds ?? []).join(', ')} not following${value.threadRef === undefined ? '' : ` ${value.threadRef}`}${value.taskRef === undefined ? '' : ` (${value.taskRef})`}; no message was added.`,
+        'Only a Human can invite an unfollowed Agent — retry without mentioning them, or ask the Human.',
+    ];
+}
 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.',
+    description: 'List your bounded Team Inbox for triage: unread Thread summaries with counts, without message bodies and without marking anything read. Read a selected Thread with team_thread read; the inbox itself authorizes no mutation.',
     parameters: { limit: { type: 'number' } },
     output: {
         schema: { type: 'object', additionalProperties: false, properties: {
@@ -27,11 +133,27 @@ const teamInbox = defineTool({
                 items: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
                             threadRef: { type: 'string', required: true }, channelRef: { type: 'string', required: true },
                             taskRef: { type: 'string' }, status: { type: 'string' }, revision: { type: 'number', required: true }, unreadCount: { type: 'number', required: true }, directCount: { type: 'number', required: true },
-                            taskNumber: { type: 'number' },
+                            taskNumber: { type: 'number' }, newestOccurredAt: { type: 'string' },
                         } } },
             } },
-        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') }],
+        // Triage surface only: totals plus both counters per row (direct renders
+        // even when zero), a bounded-list conclusion so truncation can never read
+        // as drained, and one route to the tool that can actually acknowledge the
+        // work. No subject, no body, no revision label, no write token: the inbox
+        // routes to a required current read, which supplies the write basis.
+        render: (_args, value) => {
+            if (value.items.length === 0) {
+                return [{ type: 'text', text: value.totalUnreadCount > 0
+                            ? `Inbox — ${value.totalUnreadCount} unread update(s) on Threads beyond this bounded list — call again with a larger limit.`
+                            : 'Inbox empty — no unread Team work.' }];
+            }
+            const shown = value.items.reduce((sum, item) => sum + item.unreadCount, 0);
+            return [{ type: 'text', text: [
+                        `Inbox — ${value.totalUnreadCount} unread update(s) total, ${value.totalDirectCount} direct, across ${value.items.length} Thread(s) shown${value.totalUnreadCount > shown ? `; ${value.totalUnreadCount - shown} more on Threads beyond this bounded list — call again with a larger limit.` : '.'}`,
+                        ...value.items.map(item => `${item.threadRef}${item.channelRef === undefined ? '' : ` · ${item.channelRef}`}${item.taskRef === undefined ? '' : ` · ${taskStanding(item)}`} · ${item.unreadCount} unread, ${item.directCount} direct${item.newestOccurredAt === undefined ? '' : ` · newest ${formatTeamTimestamp(item.newestOccurredAt)}`}`),
+                        'Read a selected Thread with team_thread read. Listing changes no read state and supplies no write token.',
+                    ].join('\n') }];
+        },
     },
     async execute(args, exec) {
         const agent = exec.agent;
@@ -40,7 +162,7 @@ const teamInbox = defineTool({
         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 })
+        const taskNumbers = new Map(host.viewForAgent(agent, { workspaceId: current.workspaceId, topLevelOnly: true, includeActivities: false, direction: 'before' })
             .taskNumbers.map(entry => [entry.taskRef, entry.taskNumber]));
         return {
             totalUnreadCount: inbox.totalUnreadCount, totalDirectCount: inbox.totalDirectCount,
@@ -48,7 +170,7 @@ const teamInbox = defineTool({
                 const taskNumber = item.task === undefined ? undefined : taskNumbers.get(item.task.taskRef);
                 return { threadRef: item.thread.threadRef, channelRef: item.channelRef,
                     ...(item.task === undefined ? {} : { taskRef: item.task.taskRef, status: item.task.status }),
-                    revision: item.thread.revision, unreadCount: item.unreadCount, directCount: item.directCount,
+                    revision: item.thread.revision, unreadCount: item.unreadCount, directCount: item.directCount, newestOccurredAt: item.newestOccurredAt,
                     ...(taskNumber === undefined ? {} : { taskNumber }) };
             }),
         };
@@ -56,7 +178,7 @@ const teamInbox = defineTool({
 });
 const teamThread = defineTool({
     name: 'team_thread',
-    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.',
+    description: 'Read or manage your Attention on one Thread. read acknowledges one chronological batch of unread facts and is the only read-side source of a next-write token — and only once no unread remains; your own committed public mutations hand off the token as well. history pages older facts without changing read state; status, follow, and unfollow change or report Attention only and render no Thread timeline. 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. An unambiguous abbreviation of the first 6+ UUID hex characters also resolves." },
@@ -66,23 +188,94 @@ const teamThread = defineTool({
     output: {
         schema: { type: 'object', additionalProperties: false, properties: {
                 kind: { type: 'string', required: true }, threadRef: { type: 'string', required: true }, taskRef: { type: 'string' },
-                revision: { type: 'number', required: true }, status: { type: 'string' }, resolution: { type: 'string' },
+                revision: { type: 'number', required: true }, status: { type: 'string' }, resolution: { type: 'string' }, taskNumber: { type: 'number' },
                 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 },
+                        messageRef: { type: 'string', required: true }, sender: { type: 'string', required: true }, body: { type: 'string', required: true }, sequence: { type: 'number', required: true }, occurredAt: { type: 'string' },
                     } },
                 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' },
+                            sequence: { type: 'number', required: true }, kind: { type: 'string', required: true }, body: { type: 'string' }, sender: { type: 'string' }, occurredAt: { 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.
+        // status/follow/unfollow answer only the Attention question. read renders
+        // outcome → context → orientation → active collision surface → facts →
+        // watermark/advice, and hands off the opaque next-write token only when
+        // no unread remains. history renders deep orientation and never the
+        // current collision surface or any write token.
+        render: (args, value) => {
+            const standing = taskStanding(value);
+            if (value.kind === 'status') {
+                return [{ type: 'text', text: `Attention status — ${value.following ? 'following' : 'not following'} ${value.threadRef}${standing === '' ? '' : ` · ${standing}`}.` }];
+            }
+            if (value.kind === 'follow' || value.kind === 'unfollow') {
+                return [{ type: 'text', text: `Attention changed — ${value.following ? 'now following' : 'no longer following'} ${value.threadRef}${standing === '' ? '' : ` · ${standing}`}.` }];
+            }
+            if (value.kind === 'history') {
+                const facts = value.facts;
+                const lines = [`History for ${value.threadRef}${standing === '' ? '' : ` · ${standing}`}`];
+                // First page (no beforeSequence supplied) orients on the full
+                // anchor; a continuation orients on the shared bounded subject. An
+                // anchor already selected as a fact never repeats.
+                if (!facts.some(fact => fact.sequence === value.anchor.sequence)) {
+                    if (args.beforeSequence === undefined)
+                        lines.push('', `Anchor ${value.anchor.sequence}${value.anchor.occurredAt === undefined ? '' : ` ${formatTeamTimestamp(value.anchor.occurredAt)}`} [${value.anchor.sender}]`, value.anchor.body);
+                    else
+                        lines.push(`  — ${boundedSubject(value.anchor.body)}`);
+                }
+                lines.push('', 'Facts');
+                if (facts.length === 0)
+                    lines.push('No facts before this cursor.');
+                else
+                    lines.push(...facts.map(fact => factLine(fact)));
+                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.'}`);
+                return [{ type: 'text', text: lines.join('\n') }];
+            }
+            // kind === 'read': outcome → context → orientation → collision
+            // surface → facts → watermark → token (iff nothing unread remains).
+            const facts = value.facts;
+            const acknowledged = facts.filter(fact => fact.unread === true).length;
+            const remaining = value.remainingUnreadCount ?? 0;
+            const lines = [
+                `Read committed — ${acknowledged === 0 ? `no unread updates on ${value.threadRef}; nothing remains` : `acknowledged ${acknowledged} unread update(s) on ${value.threadRef}; ${remaining} remain`}.`,
+                `${value.threadRef}${standing === '' ? '' : ` · ${standing}`} · ${value.following ? 'following' : 'not following'}`,
+            ];
+            // Orientation: A the anchor is one of the returned facts (renders as
+            // that fact once, no separate anchor); B any Host-supplied background
+            // fact carries positive `unread === false`, so the full anchor renders
+            // before the facts; C otherwise (continuation or unfollowed ad-hoc
+            // read) the shared bounded subject — never the full anchor.
+            const anchorInFacts = facts.some(fact => fact.sequence === value.anchor.sequence);
+            const hasBackground = facts.some(fact => fact.unread === false);
+            if (!anchorInFacts && hasBackground)
+                lines.push('', `Anchor ${value.anchor.sequence}${value.anchor.occurredAt === undefined ? '' : ` ${formatTeamTimestamp(value.anchor.occurredAt)}`} [${value.anchor.sender}]`, value.anchor.body);
+            if (!anchorInFacts && !hasBackground)
+                lines.push(`  — ${boundedSubject(value.anchor.body)}`);
+            const activeClaims = value.claims.filter(claim => claim.state === 'active');
+            if (activeClaims.length > 0) {
+                lines.push('', 'Active Claims');
+                for (const claim of activeClaims)
+                    lines.push(claimLine(claim));
+            }
+            lines.push('', 'Facts');
+            if (facts.length === 0)
+                lines.push('No new facts to acknowledge.');
+            else
+                lines.push(...facts.map(fact => factLine(fact)));
+            lines.push('', `Read through sequence ${value.readThroughSequence}; ${remaining} unread update(s) remaining${remaining > 0 ? ' — call team_thread read again.' : '.'}`);
+            if (value.contextAdvice !== undefined)
+                lines.push('', ...adviceLines(value.contextAdvice));
+            if (remaining === 0)
+                lines.push('', nextWriteLine(value.revision));
+            return [{ type: 'text', text: lines.join('\n') }];
+        },
     },
     async execute(args, exec) {
         const agent = exec.agent;
@@ -93,50 +286,76 @@ const teamThread = defineTool({
         if (args.threadRef === undefined && args.taskRef === undefined)
             throw new Error('team_thread requires threadRef');
         const base = { workspaceId: current.workspaceId, ...(args.threadRef === undefined ? {} : { threadRef: args.threadRef }), ...(args.taskRef === undefined ? {} : { taskRef: args.taskRef }) };
+        const taskNumberOf = (task) => {
+            if (task === undefined)
+                return {};
+            const resolved = host.resolveTaskRefs({ workspaceId: current.workspaceId, taskRefs: [task.taskRef] }).resolved[0];
+            return resolved === undefined ? {} : { taskNumber: resolved.taskNumber };
+        };
         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, []);
+            return threadResult('status', snapshot, status.attention, [], taskNumberOf(snapshot.task));
         }
         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, []);
+            return threadResult(args.action, snapshot, result.attention, [], taskNumberOf(snapshot.task));
         }
         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 });
+                ? { sequence: fact.sequence, kind: 'message', body: fact.message.body, sender: fact.message.sender, mentions: [...fact.mentions], occurredAt: fact.occurredAt }
+                : activityFactView(fact.sequence, fact.activity, undefined, fact.occurredAt)), { cursor: history.cursor, hasMore: history.hasMore, ...taskNumberOf(history.task) });
         }
         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 });
+            ? { 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, occurredAt: entry.fact.occurredAt }
+            : activityFactView(entry.fact.sequence, entry.fact.activity, { unread: entry.unread, direct: entry.direct }, entry.fact.occurredAt)), { readThroughSequence: read.readThroughSequence, remainingUnreadCount: read.remainingUnreadCount, ...(read.contextAdvice === undefined ? {} : { contextAdvice: adviceView(read.contextAdvice) }), ...taskNumberOf(read.task) });
     },
 });
+/** One rendered fact line; markers are inline, never a separate ellipsis line. */
+function factLine(fact) {
+    const at = fact.occurredAt === undefined ? '' : ` ${formatTeamTimestamp(fact.occurredAt)}`;
+    return fact.kind === 'message'
+        ? `${fact.sequence}${at} [${fact.sender ?? 'unknown sender'}]${factMarkers(fact)} ${fact.body}`
+        : `${activityLine(fact)}${at}${factMarkers(fact)}`;
+}
+/** One collision-surface Claim line, shared by read and history-free listing. */
+function claimLine(claim) {
+    return `${claim.claimRef} — ${claim.owner}: ${claim.direction}`;
+}
 function threadResult(kind, snapshot, attention, facts, extra = {}) {
     return {
         kind, threadRef: snapshot.thread.threadRef, revision: snapshot.thread.revision,
         ...(snapshot.task === undefined ? {} : { taskRef: snapshot.task.taskRef, status: snapshot.task.status, resolution: snapshot.task.resolution }),
+        ...(extra.taskNumber === undefined ? {} : { taskNumber: extra.taskNumber }),
         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 })),
+        anchor: { messageRef: snapshot.anchor.messageRef, sender: snapshot.anchor.sender, body: snapshot.anchor.body, sequence: snapshot.anchor.sequence, occurredAt: snapshot.anchor.occurredAt },
+        claims: snapshot.claims.map(claimView),
         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.',
+    description: 'Start a top-level Thread, reply to an existing Thread, or send a direct message (DM). Read the Thread first: a reply needs the current next-write token from a fully drained team_thread read (or your own last committed mutation), and unread work rejects before staleness is even checked. start defaults to a taskless Thread; pass asTask true to create a Task in the same send. 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. An unambiguous abbreviation of the first 6+ UUID hex characters also resolves." },
@@ -144,19 +363,43 @@ const teamMessage = markAgentTeamPreset(defineTool({
         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. 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." },
+        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: "The next-write token from your latest fully drained team_thread read (or your own last committed mutation) on this Thread. Copy the explicitly rendered value verbatim; never increment, derive, compare, or cite it — it is an opaque concurrency token, not a fact about the Thread." },
         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.' },
     },
     output: {
         schema: { type: 'object', additionalProperties: false, properties: {
-                kind: { type: 'string', required: true }, taskRef: { type: 'string' }, threadRef: { type: 'string' }, revision: { type: 'number' },
+                kind: { type: 'string', required: true }, action: { type: 'string' }, 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' },
-                recipientMemberId: { type: 'string' }, recipientHandle: { type: 'string' }, delivered: { type: 'boolean' }, deliveryNote: { type: 'string' },
+                recipientMemberId: { type: 'string' }, recipientHandle: { type: 'string' }, delivered: { type: 'boolean' }, deliveryNote: { type: 'string' }, occurredAt: { 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 ?? ''}`}` }],
+        render: (_args, value) => {
+            if (value.kind === 'dm-sent') {
+                if (value.delivered === false)
+                    return [{ type: 'text', text: [
+                                `Recorded, not delivered — DM to @${value.recipientHandle} (${value.recipientMemberId}).`,
+                                'No automatic redelivery will occur; do not blindly send a duplicate.',
+                                `Reason: ${value.deliveryNote ?? 'the recipient session could not be woken'}`,
+                            ].join('\n') }];
+                return [{ type: 'text', text: `Delivered — DM to @${value.recipientHandle} (${value.recipientMemberId})${value.occurredAt === undefined ? '' : ` at ${formatTeamTimestamp(value.occurredAt)}`}.` }];
+            }
+            if (value.kind === 'committed' && value.messageRef !== undefined && value.threadRef !== undefined && value.revision !== undefined) {
+                return [{ type: 'text', text: [
+                            value.action === 'start' ? 'Committed — Thread created.' : 'Committed — reply added.',
+                            [value.messageRef, value.threadRef, ...(value.taskRef === undefined ? [] : [value.taskRef])].join(' · '),
+                            ...(value.occurredAt === undefined ? [] : [`Committed at ${formatTeamTimestamp(value.occurredAt)}`]),
+                            nextWriteLine(value.revision),
+                        ].join('\n') }];
+            }
+            return [{ type: 'text', text: rejectionLines('message', value).join('\n') }];
+        },
+        // 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;
@@ -173,7 +416,7 @@ const teamMessage = markAgentTeamPreset(defineTool({
                 throw new Error('start requires channelRef and does not accept threadRef, taskRef, or baseRevision');
             const result = await host.sendMessageForAgent(agent, { requestId: requestId(agent.id, exec.callId), workspaceId: current.workspaceId,
                 channelRef: args.channelRef, body: args.body, asTask: args.asTask === true, ...(mentions === undefined ? {} : { recipients: mentions }), ...paths });
-            return messageOutcome(result);
+            return messageOutcome(result, 'start');
         }
         if (args.action === 'dm') {
             if (args.memberRef === undefined || args.channelRef !== undefined || args.threadRef !== undefined || args.taskRef !== undefined
@@ -183,7 +426,7 @@ const teamMessage = markAgentTeamPreset(defineTool({
             try {
                 const result = await host.dmForAgent(agent, { requestId: requestId(agent.id, exec.callId), workspaceId: current.workspaceId,
                     recipientMemberId: args.memberRef, body: args.body });
-                return { kind: 'dm-sent', recipientMemberId: result.recipient.memberId, recipientHandle: result.recipient.handle, delivered: true };
+                return { kind: 'dm-sent', recipientMemberId: result.recipient.memberId, recipientHandle: result.recipient.handle, delivered: true, occurredAt: result.receipt.occurredAt };
             }
             catch (error) {
                 if (error instanceof AgentTeamDmDeliveryError) {
@@ -194,21 +437,21 @@ const teamMessage = markAgentTeamPreset(defineTool({
         }
         const baseRevision = args.baseRevision;
         if ((args.threadRef === undefined && args.taskRef === undefined) || args.channelRef !== undefined || args.asTask !== undefined || typeof baseRevision !== 'number' || !Number.isSafeInteger(baseRevision) || baseRevision < 1) {
-            throw new Error("reply requires threadRef and a positive baseRevision, and does not accept channelRef; use the current Thread 'revision' returned by team_inbox or team_thread");
+            throw new Error('reply requires threadRef and a positive baseRevision; drain the Thread with team_thread read and copy the token it renders, or reuse the one your own last committed mutation rendered');
         }
         const result = await host.replyForAgent(agent, { requestId: requestId(agent.id, exec.callId), workspaceId: current.workspaceId,
             ...(args.threadRef === undefined ? {} : { threadRef: args.threadRef }),
             ...(args.taskRef === undefined ? {} : { taskRef: args.taskRef }),
             body: args.body, baseRevision,
             ...(mentions === undefined ? {} : { recipients: mentions }), ...paths });
-        return messageOutcome(result);
+        return messageOutcome(result, 'reply');
     },
 }));
-function messageOutcome(result) {
+function messageOutcome(result, action) {
     if (result.kind === 'committed')
-        return { kind: result.kind, threadRef: result.thread.threadRef,
+        return { kind: result.kind, action, threadRef: result.thread.threadRef,
             ...(result.task === undefined ? {} : { taskRef: result.task.taskRef }),
-            revision: result.thread.revision, messageRef: result.message.messageRef };
+            revision: result.thread.revision, messageRef: result.message.messageRef, occurredAt: result.receipt.occurredAt };
     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 }) };
@@ -222,22 +465,48 @@ function messageOutcome(result) {
 }
 const teamClaim = defineTool({
     name: 'team_claim',
-    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.',
+    description: 'List or mutate your Direction Claims. 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. Mutations require the current next-write token from a fully drained team_thread read (or your own last committed mutation); list refreshes the collision surface only and authorizes no mutation.',
     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. 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' },
+        baseRevision: { type: 'number', description: "The next-write token from your latest fully drained team_thread read (or your own last committed mutation) on this Task's Thread. Copy the explicitly rendered value verbatim; never increment, derive, compare, or cite it — it is an opaque concurrency token, not a fact about the Task." }, direction: { type: 'string' },
         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: {
-                kind: { type: 'string', required: true }, taskRef: { type: 'string', required: true }, threadRef: { type: 'string', required: true },
+                kind: { type: 'string', required: true }, action: { type: 'string' }, 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' },
+                unreadCount: { type: 'number' }, directCount: { type: 'number' }, occurredAt: { type: 'string' },
+                claim: { 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 },
+                    } },
                 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') }],
+        // A committed mutation renders the authoritative affected Claim first —
+        // the Host result carries it; the full archive is never appended. list
+        // renders the active collision surface and no write token: a current
+        // Thread read remains the required mutation basis. Rejections share the
+        // outcome-first recovery form and never a numeric revision.
+        render: (_args, value) => {
+            if (value.kind === 'listed') {
+                const active = value.claims.filter(claim => claim.state === 'active');
+                return [{ type: 'text', text: [
+                            `Claims for ${value.taskRef} · ${value.threadRef} · ${value.status}`,
+                            'Active Claims',
+                            ...(active.length === 0 ? ['No active Claims.'] : active.map(claim => claimLine(claim))),
+                        ].join('\n') }];
+            }
+            if (value.kind === 'committed' && value.claim !== undefined) {
+                return [{ type: 'text', text: [
+                            `Committed — Claim ${value.action === 'claim' ? 'created' : value.action === 'done' ? 'completed' : 'released'}.`,
+                            `${value.claim.claimRef} · ${value.claim.state} — ${value.claim.owner}: ${value.claim.direction}`,
+                            `${value.threadRef} · ${value.taskRef} · ${value.status}`,
+                            ...(value.occurredAt === undefined ? [] : [`Committed at ${formatTeamTimestamp(value.occurredAt)}`]),
+                            nextWriteLine(value.revision),
+                        ].join('\n') }];
+            }
+            return [{ type: 'text', text: rejectionLines('Claim mutation', value).join('\n') }];
+        },
     },
     async execute(args, exec) {
         const agent = exec.agent;
@@ -251,22 +520,25 @@ const teamClaim = defineTool({
                 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 })) };
+                claims: listed.claims.map(claimView) };
         }
         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");
+            throw new Error('claim mutation requires a positive baseRevision; drain the Thread with team_thread read and copy the token it renders, or reuse the one your own last committed mutation rendered');
         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 }) });
+        // Structured compatibility: every mutation outcome re-reads the real
+        // Claim archive and Task status, exactly as the parent version did —
+        // the render layer is what omits the archive, never the structured value.
         const listed = host.listClaimsForAgent(agent, base);
-        const claims = listed.claims.map(claim => ({ claimRef: claim.claimRef, owner: claim.owner, direction: claim.direction, state: claim.state }));
+        const claims = listed.claims.map(claimView);
         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 };
+            return { kind: result.kind, action: args.action, taskRef: result.task.taskRef, threadRef: result.thread.threadRef,
+                revision: result.thread.revision, status: result.task.status, claim: claimView(result.claim), claims, occurredAt: result.receipt.occurredAt };
         if (result.kind === 'unread_required')
             return { kind: result.kind, taskRef: listed.task.taskRef, threadRef: result.threadRef,
                 revision: result.revision, status: listed.task.status, unreadCount: result.unreadCount, directCount: result.directCount, claims };
@@ -276,7 +548,7 @@ 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 your authorized Team addresses: current Channels, a newest-first page of top-level Threads (each with its bounded anchor subject; Task standing inline on taskful rows), and current Members. This is an address book, not a work queue — unread work lives in team_inbox, and a Thread is read with team_thread read. The cursor pages Thread rows only.',
     parameters: {
         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' },
@@ -287,16 +559,46 @@ 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 }, subject: { type: 'string', required: true },
+                            taskRef: { type: 'string' }, status: { type: 'string' }, taskNumber: { type: 'number' }, lastActivityAt: { type: 'string' },
+                        } } },
                 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 },
+                cursor: { type: 'number', required: true }, hasMore: { type: 'boolean', required: true }, page: { type: 'string' },
             } },
-        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') }],
+        // Address book, newest Thread first: labelled sections, one bounded
+        // anchor subject per Thread row, Task standing inline on its Thread (no
+        // second Task index), and a footer that calls the value a Thread cursor.
+        // Continuation pages repeat only Threads — Channels and Members are
+        // current address context, not members of the Thread page. No message
+        // count and no revision label: neither changes the next legal action,
+        // which is reading, never writing from a directory snapshot.
+        render: (_args, value) => {
+            const continuation = value.page === 'threads';
+            const lines = [];
+            if (!continuation) {
+                lines.push('Team directory', '', 'Channels — current');
+                if (value.channels.length === 0)
+                    lines.push('No authorized Channels.');
+                else
+                    lines.push(...value.channels.map(channel => `${channel.channelRef} · ${channel.name}`));
+                lines.push('');
+            }
+            lines.push('Threads');
+            if (value.threads.length === 0)
+                lines.push(`No top-level Threads${!continuation && value.channels.length === 1 ? ` in ${value.channels[0].channelRef}` : ''} at this cursor.`);
+            else
+                lines.push(...value.threads.map(thread => `${thread.threadRef} · ${thread.channelRef}${thread.taskRef === undefined ? ' · taskless' : ` · ${taskStanding(thread)}`} — ${thread.subject}${thread.lastActivityAt === undefined ? '' : ` · last activity ${formatTeamTimestamp(thread.lastActivityAt)}`}`));
+            lines.push(`Thread cursor ${value.cursor}; hasMore=${value.hasMore ? 'true' : 'false'}${value.hasMore ? ' — older Thread anchors exist; page again with this cursor.' : ' — no older Threads remain.'}`);
+            if (!continuation) {
+                lines.push('', 'Members — current');
+                if (value.members.length === 0)
+                    lines.push('No visible Members.');
+                else
+                    lines.push(...value.members.map(m => `${m.memberId} · @${m.handle} (${m.kind}, ${m.presence})${m.description === '' ? '' : ` — ${m.description}`}`));
+            }
+            return [{ type: 'text', text: lines.join('\n') }];
+        },
     },
     async execute(args, exec) {
         const agent = exec.agent;
@@ -304,7 +606,7 @@ const teamView = defineTool({
             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 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, direction: 'before' });
         const visibleMemberIds = new Set(view.members.map(membership => membership.memberId));
         return {
             channels: view.channels.map(channel => ({ channelRef: channel.channelRef, name: channel.name })),
@@ -313,9 +615,17 @@ 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,
+                    subject: boundedSubject(item.message.body), lastActivityAt: item.lastActivityAt,
+                    ...(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,
+            ...(args.cursor === undefined ? {} : { page: 'threads' }),
         };
     },
 });
@@ -325,4 +635,5 @@ export function apply(ctx) {
     ctx.tools.register(teamMessage);
     ctx.tools.register(teamClaim);
     ctx.tools.register(teamView);
+    registerContextTools(ctx);
 }