@wowyuarm/dsh-agent-team 0.1.14 → 0.2.0

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

@@ -58,7 +58,7 @@ export type TeamSidebarProps = PropsRuntime<'sidebar.workspaces'> & PropsLocale<
     /**
      * Host clear-context remote kept as a hidden migration escape hatch.
      * The visible row action is retired: Members manage their own context
-     * through the context_rollover tool (see docs/architecture.md).
+     * through the context_rollover tool (see docs/architecture/README.md).
      */
     clearMemberContext: (request: AgentTeamClearMemberContextRequest) => Promise<RemoteResult<AgentTeamClearMemberContextResult>>;
     archiveMember: (request: AgentTeamArchiveMemberRequest) => Promise<RemoteResult<AgentTeamArchiveMemberResult>>;

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

@@ -21,7 +21,7 @@ Every agent-facing render carries absolute event instants in the fixed Team coor
 
 Canonical results expose stable refs, optional Task status, Thread revision, Claim history, Attention, and unread facts as structured fields. The model-visible renders follow the action decision surface: the write token appears only on a fully drained `team_thread read` and a committed public mutation; browsing results (`team_view`, `team_inbox`, status/follow/unfollow, `history`, `team_claim list`) and all typed rejections render no revision and no token. Typed `unread_required` and `stale_revision` results keep the structured fields needed to reread and retry deliberately. Tool execution resolves the exact live `exec.agent`; arguments cannot select or impersonate the actor, and the optional `workspace` selector can only pick among that actor's participated Workspaces. Write request identity derives from sessionId plus tool callId. `context_rollover` and `context_checkpoint` conclude the Agent turn (a rollover must not be followed by old-generation work, and a checkpoint resolves at its containing turn's end); every other Team tool returns to the model loop.
 
-The complete implemented protocol is documented in [`../../docs/team-collaboration.md`](../../docs/team-collaboration.md).
+The complete implemented protocol is documented in [`../../docs/team-collaboration/README.md`](../../docs/team-collaboration/README.md).
 
 ## Composition
 

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

@@ -21,7 +21,7 @@ mention 在 Message 正文里撰写，形如 `@Handle`（`@` 必需、大小写
 
 Canonical result 以结构化字段暴露稳定 refs、可选 Task status、Thread revision、Claim history、Attention 和未读 facts。模型可见的渲染遵循 action decision surface：写令牌只出现在未读清零的 `team_thread read` 与一次已提交的 public mutation 上；浏览类结果（`team_view`、`team_inbox`、status/follow/unfollow、`history`、`team_claim list`）与所有类型化拒绝都不渲染 revision 与令牌。类型化的 `unread_required` 与 `stale_revision` 结果保留重新读取和审慎重试所需的结构化字段。工具执行通过准确的 live `exec.agent` 解析 actor；参数不能选择或冒充 actor，可选的 `workspace` 选择器只能在该 actor 已参与的 Workspace 中选择。写操作的 request identity 由 sessionId 与 tool callId 派生。`context_rollover` 与 `context_checkpoint` 结束 Agent turn；其余 Team tools 将结果返回模型循环，不主动结束 turn。
 
-完整的已实现协议见 [`../../docs/team-collaboration.md`](../../docs/team-collaboration.md)。
+完整的已实现协议见 [`../../docs/team-collaboration/README.md`](../../docs/team-collaboration/README.md)。
 
 ## Composition
 

package/packages/tool-agent-team/lib/context-tools.js

@@ -1,18 +1,27 @@
 /**
- * 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.
+ * Model-facing context-management tools for Team Members.
+ *
+ * `context_rollover` and `context_checkpoint` are the published engine's tools,
+ * built by `createContinuityTools`: the engine owns their argument contract, the
+ * anti-forgery gate on a cited ref, the `concludeTurn()` timing, and the render
+ * shapes, while the Team supplies its own vocabulary (`TEAM_CONTINUITY_TEXT`)
+ * and the mechanism behind `ContinuityToolAdapter`. Hand-written copies of those
+ * two descriptions used to live here and drifted from the engine's defaults, so
+ * the Team's guidance now travels only through the engine's text seams.
+ *
+ * `context_timeline` deliberately stays Team-owned. Its render never prints a
+ * ref-shaped string for a non-restorable row — a short digest names the row
+ * instead, because a printed ref is exactly what a model copies into
+ * `checkpointRef` — and the engine's render has no switch for that. The
+ * adapter's own `timeline` member is still implemented: the engine's contract
+ * requires it, and the shape it returns is the one the engine's render reads.
  * @module @wowyuarm/dsh-agent-team/context-tools
  */
 import { createHash } from 'node:crypto';
+import { createContinuityTools, } from '@wowyuarm/dsh-context-continuity';
+import { MAX_TIMELINE_LIMIT } from '@wowyuarm/dsh-agent-team/host';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { member, service } from "./host-access.js";
-const MAX_HANDOFF_CHARS = 32 * 1024;
-const MAX_RELATED_FILES = 32;
 /**
  * Short stable identifier for one timeline row: a digest of the anchor's own
  * ref. Rows routinely share a label (`Team message` is a constant) and a price
@@ -24,100 +33,101 @@ const MAX_RELATED_FILES = 32;
 function anchorId(checkpointRef) {
     return createHash('sha256').update(checkpointRef).digest('hex').slice(0, 6);
 }
-const contextRollover = defineTool({
-    name: 'context_rollover',
-    description: 'context_rollover: end this context generation and continue as the same Team Member in a new one. Without checkpointRef the context starts fresh and empty, seeded only by your handoff — this is the default, cheapest path at context pressure, and the right choice for ordinary generation changes and pressure-driven handoffs. Omit checkpointRef unless you are deliberately returning to a restorable anchor you just selected from a context_timeline result: supply a checkpointRef only when that timeline listed it as restorable and you are citing its exact ref — never synthesize, guess, or reconstruct one; a fabricated ref rejects as a model-visible error. Write the handoff as one prose string covering: current objective and every active Thread/Claim; verified facts and evidence; inferences and unresolved conflicts; current external side effects and their verification state (files, git, jobs, browser state, remote calls); one explicit next step. A context change never rolls back any external effect — describe current state so the next generation can re-verify. Record anything worth keeping in your private memory/notes first. Collect or stop your background jobs before calling: a rollover is refused while jobs this Member owns are still running.',
-    parameters: {
-        handoff: { type: 'string', required: true, description: 'Prose handoff for the next context generation: objective, active Threads/Claims, verified facts, inferences, external side effects and their verification state, next step.' },
-        checkpointRef: { type: 'string', description: 'Optional. Omit for the default fresh rollover — ordinary generation changes and pressure-driven handoffs must not supply this. Provide it only to resume from a restorable anchor you just selected in a context_timeline result, citing that exact ref; never synthesize or guess a ref.' },
-        relatedFiles: { type: 'array', items: { type: 'object', additionalProperties: false, properties: { path: { type: 'string', required: true }, reason: { type: 'string', required: true } } }, description: 'Workspace paths the next generation should look at first, each with one reason.' },
-    },
-    output: {
-        schema: { type: 'object', additionalProperties: false, properties: {
-                mode: { type: 'string', required: true }, status: { type: 'string', required: true },
-            } },
-        render: (_args, value) => [{ type: 'text', text: `Context rollover scheduled (${value.mode}). Finish this turn; the Host switches you to the next context generation afterward.` }],
+/** The calling Agent, or a model-visible rejection — these tools only exist in a Member Session. */
+function agentOf(exec) {
+    const agent = exec.agent;
+    if (agent === undefined)
+        throw new Error('context tool requires an Agent session');
+    return agent;
+}
+/**
+ * Team's half of the engine's contract: resolve the calling execution to its
+ * Member and Host, answer the ref gate from the one policy that owns it, and run
+ * the effects. Every method resolves its own caller, because one adapter serves
+ * all three tools.
+ */
+const adapter = {
+    /**
+     * One policy, two readers: a ref is restorable exactly when the Team timeline
+     * — the same list the model picked from — offers it as such. The walk is asked
+     * for the widest window the timeline tool can show, so any ref a timeline read
+     * could have printed is answered here.
+     */
+    async isRestorableRef(checkpointRef, exec) {
+        const agent = agentOf(exec);
+        const current = member(agent);
+        const timeline = await service(agent).contextTimelineForAgent(agent, { memberId: current.memberId, limit: MAX_TIMELINE_LIMIT });
+        return timeline.items.some(item => item.checkpointRef === checkpointRef && item.restorable);
     },
-    async execute(args, exec) {
-        const agent = exec.agent;
-        if (agent === undefined)
-            throw new Error('context_rollover requires an Agent session');
+    async requestRollover(request, exec) {
+        const agent = agentOf(exec);
         const current = member(agent);
-        const host = service(agent);
-        const handoff = typeof args.handoff === 'string' ? args.handoff : '';
-        if (handoff.trim() === '')
-            throw new Error('context_rollover requires a non-empty handoff');
-        if (handoff.length > MAX_HANDOFF_CHARS)
-            throw new Error(`context_rollover handoff exceeds ${MAX_HANDOFF_CHARS} characters`);
-        const relatedFilesInput = Array.isArray(args.relatedFiles) ? args.relatedFiles : [];
-        if (relatedFilesInput.length > MAX_RELATED_FILES)
-            throw new Error(`context_rollover accepts at most ${MAX_RELATED_FILES} related files`);
-        // Tool argument validation is layered: the Harness schema (required and
-        // type checks) rejects at the execute boundary, and this body adds the
-        // checks the schema cannot express — each related file is validated
-        // here, so a blank path/reason rejects instead of seeding the handoff
-        // envelope with empty fields.
-        const relatedFiles = [];
-        for (const [index, entry] of relatedFilesInput.entries()) {
-            if (typeof entry !== 'object' || entry === null)
-                throw new Error(`context_rollover relatedFiles[${index}] must be an object with path and reason`);
-            const candidate = entry;
-            if (typeof candidate.path !== 'string' || candidate.path.trim() === '')
-                throw new Error(`context_rollover relatedFiles[${index}].path must be a non-empty string`);
-            if (typeof candidate.reason !== 'string' || candidate.reason.trim() === '')
-                throw new Error(`context_rollover relatedFiles[${index}].reason must be a non-empty string`);
-            relatedFiles.push({ path: candidate.path, reason: candidate.reason });
-        }
-        // Tool schemas are open at the root (Harness parameter specs set no
-        // `additionalProperties: false`), so an undeclared shape can still reach
-        // the body. Any supplied value that is not a non-empty string rejects
-        // here rather than being treated as absent — an absent ref means fresh,
-        // which is not what the model asked for.
-        const raw = args;
-        const suppliedRef = Object.hasOwn(raw, 'checkpointRef') ? raw.checkpointRef : undefined;
-        if (suppliedRef !== undefined && (typeof suppliedRef !== 'string' || suppliedRef.trim() === '')) {
-            throw new Error('context_rollover checkpointRef must be a non-empty string when supplied');
-        }
-        const checkpointRef = typeof suppliedRef === 'string' ? suppliedRef.trim() : undefined;
-        const outcome = await host.requestNewContext(agent, {
+        // The engine already validated the argument shape and the cited ref; the
+        // Host owns the durable intent and the generation swap that follows it at
+        // the idle boundary.
+        const outcome = await service(agent).requestNewContext(agent, {
             memberId: current.memberId,
-            ...(checkpointRef === undefined || checkpointRef === '' ? {} : { checkpointRef: checkpointRef }),
-            ...(relatedFiles.length === 0 ? {} : { relatedFiles }),
+            ...(request.checkpointRef === undefined ? {} : { checkpointRef: request.checkpointRef }),
+            ...(request.relatedFiles.length === 0 ? {} : { relatedFiles: [...request.relatedFiles] }),
         });
-        exec.concludeTurn();
-        return { mode: outcome.mode, status: 'scheduled' };
+        return { mode: outcome.mode };
     },
-});
-const contextCheckpoint = defineTool({
-    name: 'context_checkpoint',
-    description: 'Record a named checkpoint at the end of the current turn: an opaque, private, restorable anchor for this Member\'s context lineage. Use it before a noisy or risky phase — a broad refactor, an experiment whose value is unproven — when returning to the current completed state may later be useful. The checkpoint resolves only when this turn completes; the Host continues work in the next turn automatically. A checkpoint never snapshots files, git, jobs, or any external state: returning to one (via context_rollover with its checkpointRef) resumes the conversation prefix and nothing else. Checkpoints are private context structure, not Team facts, and are never visible to other Members.',
-    parameters: {
-        name: { type: 'string', required: true, description: 'Short semantic label for this checkpoint, shown in context_timeline.' },
-    },
-    output: {
-        schema: { type: 'object', additionalProperties: false, properties: {
-                checkpointRef: { type: 'string', required: true }, name: { type: 'string', required: true },
-            } },
-        // The ref is the selection surface for `context_rollover`: rendering only the
-        // name left the model with no legitimate way to cite the anchor it just
-        // recorded. Renders are the only channel results reach the model through.
-        render: (_args, value) => [{ type: 'text', text: `Checkpoint recorded: ${value.name} (ref: ${value.checkpointRef}). Work continues in the next turn; the Host will continue automatically.` }],
-    },
-    async execute(args, exec) {
-        const agent = exec.agent;
-        if (agent === undefined)
-            throw new Error('context_checkpoint requires an Agent session');
+    async recordCheckpoint(request, exec) {
+        const agent = agentOf(exec);
         const current = member(agent);
-        const host = service(agent);
-        const name = typeof args.name === 'string' ? args.name : '';
         // The Host validates binding, running-turn fencing, and the name budget;
         // the durable checkpoint is the successful call/result pair the Session
         // projection folds, and the ref derives from the tool call id.
-        const outcome = host.recordCheckpointForAgent(agent, { memberId: current.memberId, callId: exec.callId, name });
-        exec.concludeTurn();
+        const outcome = service(agent).recordCheckpointForAgent(agent, { memberId: current.memberId, callId: request.callId, name: request.name });
         return { checkpointRef: outcome.checkpointRef, name: outcome.name };
     },
-});
+    async timeline(request, exec) {
+        const agent = agentOf(exec);
+        const current = member(agent);
+        const result = await service(agent).contextTimelineForAgent(agent, {
+            memberId: current.memberId,
+            ...(request.limit === undefined ? {} : { limit: request.limit }),
+        });
+        // Team's item vocabulary is its own (`agent` / `team-boundary` / `handoff` /
+        // `compaction` / `head`); the engine names the same anchors in its terms —
+        // four Team sources collapse onto the engine's three kinds, and the two that
+        // say something a reader needs (`handoff`, `compaction`) ride its opaque
+        // `kind` field rather than being flattened silently.
+        return {
+            usageTokens: result.usageTokens,
+            handoffAt: result.handoffAt,
+            hardLimit: result.hardLimit,
+            items: result.items.map(item => ({
+                ref: item.checkpointRef,
+                label: item.name,
+                source: item.source === 'agent' ? 'checkpoint' : item.source === 'head' ? 'head' : 'boundary',
+                ...(item.source === 'handoff' || item.source === 'compaction' ? { kind: item.source } : {}),
+                retainedTokens: item.retainedTokens,
+                discardedTokens: item.discardedTokens,
+                affectedTopics: [...item.affectedThreads],
+                restorable: item.restorable,
+                ...(item.reason === undefined ? {} : { reason: item.reason }),
+            })),
+            ...(result.incompleteFrom === undefined ? {} : { incompleteFrom: result.incompleteFrom }),
+        };
+    },
+};
+/**
+ * Team vocabulary for the engine's tools. `carriedContext` names the channels a
+ * fresh generation already receives — without it the engine's "seeded only by
+ * your handoff" sentence reads as "everything must be restated", which is what
+ * our own corpus showed members doing. The checklist carries the one item the
+ * engine's default does not ask for and the corpus showed missing: which facts
+ * were verified and which were only trusted.
+ */
+const TEAM_CONTINUITY_TEXT = {
+    subjectNoun: 'Team Member',
+    carriedContext: 'You stay the same Team Member: your @handle and role, your private memory index, your skills catalog, and the Team and Workspace instructions carry across a rollover — they are re-injected at birth — and the Team ledger (Threads, Tasks, Claims, your inbox, your owner jobs) is one query away (team_view, team_inbox). Do not restate any of it.',
+    rolloverChecklist: 'the objective and the atomic action in flight; facts and evidence not already recorded elsewhere; which items you verified and which you only trusted; inferences and unresolved conflicts; current external side effects and their verification state (files, git, jobs, browser state, remote calls); one explicit next step',
+    topicNoun: 'Thread',
+    topicNounPlural: 'Threads',
+};
+const engineTools = createContinuityTools(adapter, TEAM_CONTINUITY_TEXT);
 const contextTimeline = defineTool({
     name: 'context_timeline',
     description: 'Inspect the bounded structural timeline of this Member\'s context lineage: named checkpoints you recorded, Team boundaries (effect anchors: a committed team_message, a successful team_claim mutation, a follow/unfollow — rendered as `Team message`, `Team task claim change`, `Team attention change`; plus a Thread\'s first delivered notice, rendered as `First arrival: <refs>`), handoff and compaction boundaries, and the current head — across the current generation and its archived ancestors. Only the first delivery of a Thread\'s facts anchors; later re-deliveries and reminders produce no boundary. Returns approximate retained/discarded token estimates, current usage against the pressure budget, the Threads whose facts entered your context by each anchor, and which anchors are restorable. A Team boundary is a selectable default checkpoint exactly when the retained prefix through it stays inside one Thread and the return would shrink the working set below the handoff budget; a boundary spanning several Threads, or attributable to none, states its reason instead. Every row carries a short `anchor` id: it distinguishes rows that share a label and a price, and it is NOT a ref — only the `checkpointRef` printed on a restorable row may be cited to context_rollover. Structural only: no transcript content. A fresh context_rollover (no checkpointRef) never requires consulting this timeline first — call it directly. Use this tool only when you specifically intend a checkpointRef return: to pick the smallest sufficient ref, or to confirm that a fresh handoff is the better path when every anchor is marked non-restorable.',
@@ -191,7 +201,9 @@ const contextTimeline = defineTool({
     },
 });
 export function registerContextTools(ctx) {
-    ctx.tools.register(contextRollover);
-    ctx.tools.register(contextCheckpoint);
+    // The engine's two, then the Team's own timeline: one registration each, and
+    // the roster the Host validates against stays the same three names.
+    ctx.tools.register(engineTools.rollover);
+    ctx.tools.register(engineTools.checkpoint);
     ctx.tools.register(contextTimeline);
 }

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

@@ -114,7 +114,7 @@ function rejectionLines(noun, value) {
 }
 const teamInbox = defineTool({
     name: 'team_inbox',
-    description: 'List your bounded Team Inbox across all joined Workspaces 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.',
+    description: 'List your bounded Team Inbox across all joined Workspaces 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. This is your own unread queue; to see work others have in flight (whether or not you have unread on it), use the active-task-threads section of team_view.',
     parameters: { limit: { type: 'number' }, workspace: { type: 'string', description: 'Optional Workspace id filter. Omit to triage all your participations together.' } },
     output: {
         schema: { type: 'object', additionalProperties: false, properties: {
@@ -554,7 +554,7 @@ const teamClaim = defineTool({
 });
 const teamView = defineTool({
     name: 'team_view',
-    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.',
+    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), current Members, and an「active task threads」section listing the work in flight right now — every in_progress / in_review Task Thread in your Channels, with its subject and the Members already on it. This is an address book, not a work queue: unread work lives in team_inbox, and a Thread is read with team_thread read. Consult the active-task-threads section when a Workspace change surprises you, or before you claim or commit, to tell in-flight work from a real conflict and avoid riding onto someone else\'s unpushed work — it is independent of your own unread. 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' }, workspace: workspaceParam,
@@ -571,6 +571,11 @@ const teamView = defineTool({
                             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' },
                         } } },
+                activeTaskThreads: { 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 }, subject: { type: 'string', required: true },
+                            taskNumber: { type: 'number' }, lastActivityAt: { type: 'string', required: true },
+                            members: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: { memberId: { type: 'string', required: true }, name: { type: 'string', required: true } } } },
+                        } } },
                 tasks: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: { taskRef: { type: 'string', required: true }, threadRef: { type: 'string', required: true }, channelRef: { type: 'string', required: true }, status: { type: 'string', required: true }, revision: { type: 'number' } } } },
                 cursor: { type: 'number', required: true }, hasMore: { type: 'boolean', required: true }, page: { type: 'string' },
             } },
@@ -608,6 +613,12 @@ const teamView = defineTool({
                     lines.push('No visible Members.');
                 else
                     lines.push(...value.members.map(m => `${m.memberId} · @${m.handle} (${m.kind}, ${m.presence})${m.description === '' ? '' : ` — ${m.description}`}`));
+                lines.push('', 'Active task threads — work in flight right now');
+                if (value.activeTaskThreads.length === 0)
+                    lines.push('No task thread is in flight in this Workspace.');
+                else
+                    lines.push(...value.activeTaskThreads.map(t => `${t.threadRef} · ${t.channelRef} · ${t.status}${t.taskNumber === undefined ? '' : ` · #${t.taskNumber}`}${t.members.length === 0 ? '' : ` · ${t.members.map(m => `@${m.name}`).join(', ')}`} — ${t.subject} · last activity ${formatTeamTimestamp(t.lastActivityAt)}`));
+                lines.push('Use this when a Workspace change surprises you, or before you claim or commit — to see who is already on a Task rather than riding onto their in-flight work. It is not the unread queue; unread work still lives in team_inbox.');
             }
             return [{ type: 'text', text: lines.join('\n') }];
         },
@@ -645,6 +656,10 @@ const teamView = defineTool({
                 return { taskRef: task.taskRef, threadRef: task.threadRef, channelRef: task.channelRef, status: task.status,
                     ...(revision === undefined ? {} : { revision }) };
             }),
+            activeTaskThreads: view.activeTaskThreads.map(t => ({ taskRef: t.taskRef, threadRef: t.threadRef, channelRef: t.channelRef,
+                status: t.status, subject: t.subject, lastActivityAt: t.lastActivityAt,
+                ...(t.taskNumber === undefined ? {} : { taskNumber: t.taskNumber }),
+                members: t.members.map(m => ({ memberId: m.memberId, name: m.name })) })),
             cursor: view.cursor, hasMore: view.hasMore,
             ...(args.cursor === undefined ? {} : { page: 'threads' }),
         };

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

@@ -1,11 +1,20 @@
 /**
- * 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.
+ * Model-facing context-management tools for Team Members.
+ *
+ * `context_rollover` and `context_checkpoint` are the published engine's tools,
+ * built by `createContinuityTools`: the engine owns their argument contract, the
+ * anti-forgery gate on a cited ref, the `concludeTurn()` timing, and the render
+ * shapes, while the Team supplies its own vocabulary (`TEAM_CONTINUITY_TEXT`)
+ * and the mechanism behind `ContinuityToolAdapter`. Hand-written copies of those
+ * two descriptions used to live here and drifted from the engine's defaults, so
+ * the Team's guidance now travels only through the engine's text seams.
+ *
+ * `context_timeline` deliberately stays Team-owned. Its render never prints a
+ * ref-shaped string for a non-restorable row — a short digest names the row
+ * instead, because a printed ref is exactly what a model copies into
+ * `checkpointRef` — and the engine's render has no switch for that. The
+ * adapter's own `timeline` member is still implemented: the engine's contract
+ * requires it, and the shape it returns is the one the engine's render reads.
  * @module @wowyuarm/dsh-agent-team/context-tools
  */
 export declare function registerContextTools(ctx: {

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

@@ -1 +1 @@
-{"version":3,"file":"context-tools.d.ts","sourceRoot":"","sources":["../../src/context-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAsLH,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"}
+{"version":3,"file":"context-tools.d.ts","sourceRoot":"","sources":["../../src/context-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAqMH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAA;KAAE,CAAA;CAAE,GAAG,IAAI,CAMrG"}

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;AAelD,eAAO,MAAM,IAAI,8BAA8B,CAAA;AAC/C,eAAO,MAAM,MAAM,UAAY,CAAA;AA8qB/B,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAOxC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAelD,eAAO,MAAM,IAAI,8BAA8B,CAAA;AAC/C,eAAO,MAAM,MAAM,UAAY,CAAA;AA2rB/B,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAOxC"}

package/packages/agent-team/lib/preset-roster.js

@@ -1,15 +0,0 @@
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import AgentPresets from '@deepseek-ai/dsh-agent-presets';
-export const inject = ['loader'];
-/** Bundle-private Agent preset roster. The composition must isolate `agentPresets` around this provider and AgentTeam. */
-export function apply(ctx) {
-    const here = dirname(fileURLToPath(import.meta.url));
-    const root = resolve(here, '../preset');
-    ctx.plugin(AgentPresets, {
-        default: 'team-member',
-        roots: [{ path: root, trust: 'system' }],
-        includeShippedRoot: false,
-        includeUserRoot: false,
-    });
-}