@nanmicoder/dsh-agent-teams 0.1.16-rc.1 → 0.1.17-rc.1

package/lib/command.js

@@ -54,11 +54,11 @@ export function invokedAgentTeamsGoal(messages) {
 }
 export function buildActivationDirective(goal, profile, taskPlanning = 'seed') {
     const lines = [
-        'The user invoked an AgentTeams slash command. Activate the AgentTeams protocol from your instructions now: you are the captain of a multi-agent team.',
-        'Call agent_teams_create with approval="required". Build the complete staged roster and DAG, then stop and ask the user to review the Web plan. Do not approve or start it in this same turn.',
+        'The user invoked an AgentTeams slash command. Follow the AgentTeams protocol already in your system instructions. Inspect existing team state with agent_teams_status when needed.',
+        'Respect the current team state. Continue an existing plan or team without recreating it. Only when no current team exists, call agent_teams_create with approval="required". Build the complete staged roster and DAG, then stop and ask the user to review the Web plan. Do not approve or start it in this same turn.',
     ];
     if (profile !== undefined) {
-        lines.push(`Use configured AgentTeams profile "${profile}" when calling agent_teams_create.`);
+        lines.push(`Use profile="${profile}" when creating a new team.`);
         if (taskPlanning === 'captain') {
             lines.push('This profile supplies the roster and guardrails. After create, do not recreate members.', 'Derive the smallest useful task graph from the goal while the team is staged; do not ask the user whether to split, merge, serialize, or parallelize.', 'Independent supplemental work must become separate ready tasks so idle members can run in parallel. Add dependencies only for genuine prerequisites and later synthesis.');
         }

package/lib/harness-compat.js

@@ -7,6 +7,9 @@ import { SubagentError } from '@deepseek-ai/dsh-subagent';
  * Source: packages/subagent/subagent/src/internal.ts at dsh-v0.1.2-rc.1.
  */
 const hostPromptQueue = Symbol.for('dsh.subagent.queuePrompt');
+// 0.1.5 keeps queueHostSubagentPrompt but replaces its symbol with this
+// delivery-mode-aware implementation (packages/subagent/subagent/src/internal.ts).
+const hostPromptDeliver = Symbol.for('dsh.subagent.deliverPrompt');
 function boundary(runtime) {
     return runtime;
 }
@@ -30,10 +33,14 @@ export function installContinuableMemberSetup(ctx, setup) {
         // Upstream owns this registration with this.ctx.effect. Cordis resolves
         // that ctx to the accessing plugin, so its disposal revokes installations
         // even while the subagents service and child Agents remain live.
-        runtime.registerContinuableSetup.call(ctx.subagents, setup);
+        runtime.registerContinuableSetup.call(ctx.subagents, (childCtx) => {
+            if (childCtx.agent === undefined)
+                return unsupported('legacy setup lacks child Agent');
+            return setup(childCtx, childCtx.agent);
+        });
         return;
     }
-    if (typeof runtime[hostPromptQueue] !== 'function' || typeof runtime.sendMessage !== 'function') {
+    if ((typeof runtime[hostPromptQueue] !== 'function' && typeof runtime[hostPromptDeliver] !== 'function') || typeof runtime.sendMessage !== 'function') {
         return unsupported('missing continuable setup and modern host queue');
     }
     const installed = new WeakSet();
@@ -45,7 +52,7 @@ export function installContinuableMemberSetup(ctx, setup) {
             // Deliberately synchronous: awaiting here loses the first-request race.
             let teardown;
             try {
-                teardown = setup(agent.ctx);
+                teardown = setup(agent.ctx, agent);
             }
             catch (error) {
                 // session-start is a notification: Harness logs a thrown listener and
@@ -90,6 +97,9 @@ export async function queueMemberPrompt(runtime, parent, childId, content, signa
     if (typeof host.followup === 'function') {
         return host.followup.call(runtime, parent, childId, content, { source, signal });
     }
+    const deliver = host[hostPromptDeliver];
+    if (typeof deliver === 'function')
+        return deliver.call(runtime, parent, childId, content, source, signal, 'queue');
     const queue = host[hostPromptQueue];
     if (typeof queue !== 'function')
         return unsupported('missing host FIFO delivery');
@@ -101,14 +111,16 @@ export function guardSubagentDelivery(ctx, isRetired) {
     const host = boundary(runtime);
     const legacy = host.followup;
     const queue = host[hostPromptQueue];
+    const deliver = host[hostPromptDeliver];
     const send = host.sendMessage;
-    if (typeof legacy !== 'function' && (typeof queue !== 'function' || typeof send !== 'function')) {
+    if (typeof legacy !== 'function' && ((typeof queue !== 'function' && typeof deliver !== 'function') || typeof send !== 'function')) {
         return unsupported('cannot install complete retired-member guard');
     }
     ctx.effect(() => {
         const descriptors = new Map([
             ['followup', Object.getOwnPropertyDescriptor(host, 'followup')],
             [hostPromptQueue, Object.getOwnPropertyDescriptor(host, hostPromptQueue)],
+            [hostPromptDeliver, Object.getOwnPropertyDescriptor(host, hostPromptDeliver)],
             ['sendMessage', Object.getOwnPropertyDescriptor(host, 'sendMessage')],
         ]);
         let active = true;
@@ -129,10 +141,16 @@ export function guardSubagentDelivery(ctx, isRetired) {
             await check(sender, targetId);
             return send.call(runtime, sender, targetId, content, options);
         };
+        const guardedDeliver = async (parent, childId, content, source, signal, delivery) => {
+            await check(parent, childId);
+            return deliver.call(runtime, parent, childId, content, source, signal, delivery);
+        };
         if (typeof legacy === 'function')
             host.followup = guardedLegacy;
         if (typeof queue === 'function')
             host[hostPromptQueue] = guardedQueue;
+        if (typeof deliver === 'function')
+            host[hostPromptDeliver] = guardedDeliver;
         if (typeof send === 'function')
             host.sendMessage = guardedSend;
         // Cordis wraps method reads in fresh Proxies. Compare the actual own
@@ -152,6 +170,8 @@ export function guardSubagentDelivery(ctx, isRetired) {
                 restore('followup', guardedLegacy);
             if (typeof queue === 'function')
                 restore(hostPromptQueue, guardedQueue);
+            if (typeof deliver === 'function')
+                restore(hostPromptDeliver, guardedDeliver);
             if (typeof send === 'function')
                 restore('sendMessage', guardedSend);
         };

package/lib/index.js

@@ -2,7 +2,9 @@
  * AgentTeams for DeepSeek Harness.
  *
  * A host-plane plugin that registers the `agent_teams_*` tools and one usage
- * section into the global system prompt. After installation any session can
+ * agent-scoped usage section. Each session keeps a stable tool set and core
+ * instructions. Existing business tools cover the complete team lifecycle.
+ * After installation any session can
  * run multi-agent teamwork through natural language (e.g. "use AgentTeams to research X"):
  * the model creates a team (it becomes the captain), spawns members as
  * durable continuable subagents, breaks the goal into tasks with
@@ -17,7 +19,8 @@
  * @module dsh-agent-teams
  */
 import z from '@deepseek-ai/schemastery';
-import { haltTeamWork, registerAgentTeamsTools, } from "./tools.js";
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { haltTeamWork, stagedPlanApprovedContext, registerAgentTeamsTools, } from "./tools.js";
 import { installAgentTeamsGestureBoundary, registerAgentTeamsCommand } from "./command.js";
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -25,7 +28,8 @@ import { fileURLToPath } from 'node:url';
 import { collectArchivedTeamsActivity, collectTeamsActivity } from "./snapshot.js";
 import { findTeamByCaptain } from "./state.js";
 import { formatProfilesForPrompt } from "./profiles.js";
-import { qualityPlanningPrompt } from "./quality-gates.js";
+import { installTeamCapabilities } from "./capabilities.js";
+import { TEAM_TOOL_NAMES } from "./tool-names.js";
 import { authenticatedWebRoutes, readJsonRequest, RequestBodyError } from "./web-routes.js";
 /** Web-server service key candidates, newest first. */
 const WEB_SERVER_KEYS = ['webServer', 'httpServer'];
@@ -83,18 +87,17 @@ export const Config = z.object({
 });
 /** The model-facing usage policy: when and how to drive AgentTeams. */
 export function usageSectionText(toolNames, profilesText = '') {
-    return `When the user asks to run something with AgentTeams (e.g. "use AgentTeams to do X"), or an activation message from the /agent-teams slash command arrives, you are the captain of a multi-agent team. Follow this protocol:
-1. Call agent_teams_create with a team name, the goal as description, and approval="required". This creates a staged plan and must not spawn members or schedule work. Use approval="automatic" only when the user explicitly asks to skip review and run immediately.
-2. Call agent_teams_add_member once per role the goal needs (researcher, engineer, reviewer, ...). In staging these are editable roster entries, not running subagents. By default a member snapshots your current provider/model/reasoning route; use a different route only when the goal or user requires it.
-3. Analyze the goal and create the smallest useful task DAG while staged. Every agent_teams_create_task call must include a non-empty subject, including verification and review tasks. Independent work should be parallel; dependencies are only genuine prerequisites. Finish the complete roster and DAG, tell the user the Web plan is ready, then end this turn. Never call agent_teams_approve during the planning turn. The user may click Approve & Run, explicitly approve in a later user turn, return to chat to request changes, or discard the plan. The review UI injects an authoritative control message for return/discard actions: follow it exactly and never infer that a missing or paused team should be recreated. When the user returns to chat, first ask one concise clarification question without editing or recreating; after their answer, call agent_teams_edit_plan once with an ordered atomic batch, update downstream dependencies/assignees before removals, summarize the revision, and wait for review again. Never inspect or edit .agent-teams state files or plugin source code to revise a plan. Only explicit approval may call agent_teams_approve.
-4. After approval, the final member configuration is spawned atomically and the scheduler starts ready work. Lead by delegation: monitor with agent_teams_status, send guidance with agent_teams_send_message, and let idle teammates execute ready work. Do not duplicate a teammate's work merely because its turn is slow. If the user requires every member to contribute or report, create one task per required contribution (or message each member directly); never wait for an unassigned member to produce work it was never given.
-5. If the user explicitly asks to pause a running member, its open attempt remains parked after interruption; after answering the user, send that same member guidance with agent_teams_send_message so it continues the same attempt. Do not interrupt members for an ordinary user question that did not request a pause. If work must change owner, restart from scratch, or be taken over, call agent_teams_reassign_task first. Prefer another idle member or a retry with the same member. Use assignee=captain only for one ready task that you will personally drive to a terminal status in this same turn; never start a second captain takeover while one is unfinished, and never end your turn with captain-owned work open. Reassignment revokes the old attempt and waits for that member to quiesce, preventing late results from overwriting the new attempt.
-6. Tasks carry attempt_id capabilities. Members must use the current attempt_id for updates; stale-attempt errors mean ownership changed. After dispatch, end your turn while members work: mailbox progress deliveries will wake you. Read status after a delivery or an explicit user request until every required task is terminal and every member is idle/ready; do not busy-poll or require reports from members with no assigned work.
-7. If the user names a configured profile / template / fixed roster, pass that name as profile= to agent_teams_create. After a successful profile create, do not recreate the same members. Seed profiles provide their template tasks; captain-planning profiles provide only the roster and guardrails, so you must design their DAG while staged. Add repair or retry tasks when review/test fails, but never make a new task depend on a failed task. Do not send_message to start the next stage; the scheduler assigns ready work after approval. Watch every required task until it is terminal before deleting the team. Never perform a real deployment without explicit user confirmation.
-8. Quality kinds (requirements, implementation, verification, review, repair, integration) need a contract: non-empty objective and acceptance; implementation/repair also need inScope and verify. Review/requirements can complete only with verdict=pass; needs_revision/reject must fail with findings. The system then opens repair + next review that depend on the successful source, never the failed review. Do not approve your own implementation. create_task no longer silently resumes a halted team — call agent_teams_resume with a reason, or create_task({resume:true, resumeReason}).
-9. ${qualityPlanningPrompt()}
-10. Present the team's results to the user, then agent_teams_delete the team unless the user wants to keep working with it. Stopping a team aborts the Captain's current turn as well as member work; only a later explicit user turn may resume it.
-
+    return `AgentTeams captain protocol:
+1. Inspect current team state when needed, using agent_teams_status. Continue existing work without duplicating its roster/tasks. Create only when no current team exists, with the user's goal as description and approval="required"; automatic approval requires an explicit request to run immediately. Staged plans never spawn or schedule work.
+2. Add each needed role once; members inherit your model route unless another is requested/needed. A requested profile goes to create({profile}); it supplies its roster. Seed profiles also supply tasks; captain-planning profiles require your DAG. Do not duplicate either.
+3. Build the complete smallest useful DAG while staged. Every task needs a subject; dependencies represent prerequisites. Give every required contributor a task or explicit message. Present the plan and end your turn for review; never approve in that planning turn. Approve only after a later explicit user approval or the Web action.
+4. Respect Web approve/return/discard control messages. On return, ask what to change before editing; after the answer, use one atomic agent_teams_edit_plan batch (edit downstream references before removals), summarize and await review again. Never inspect or edit .agent-teams state files or plugin source code to revise plans. Discard does not authorize a replacement.
+5. The scheduler dispatches ready tasks after approval. Delegate; do not duplicate slow work or send messages merely to start a stage. Handle reports/user work, then yield when waiting is all that remains: reports wake you automatically. Use status after a delivery or user request, never busy-poll or wait for unassigned members.
+6. Tasks carry attempt_id capabilities. Use the current attempt_id; stale means ownership changed. Pause members only on explicit request; later guidance via send_message continues that same attempt. Retry, transfer or take over through reassign_task first; it revokes the old attempt and waits for quiescence. Prefer a member. Captain implementation/review takeover requires a user request. Every takeover is one ready task at a time, finished in this turn; never yield with captain-owned work open.
+7. Quality kinds (requirements, implementation, verification, review, repair, integration) require objective + acceptance; implementation/repair also require inScope + verify. Derive paths/commands from the workspace/profile, never assume src/ or pnpm test. Review/requirements complete only with verdict=pass; needs_revision/reject fail with findings. Never approve your own implementation or ask for a deliberate failure.
+8. When full quality mode is requested: requirements → implementation → verification → review → integration. Plan the entire DAG while staged, including implementation before requirements finishes and integration depending on review round 1. Failed review automatically adds repair + next review and rewires pending downstream gates. Do not recreate this loop, omit integration or depend on a failed task. Review acceptance judges the latest implementation. Do not put smoke-test scripts into task instructions.
+9. Halted means the user stopped work (including the captain turn). Resume only on a later explicit user request with a reason, via agent_teams_resume or create_task({resume:true,resumeReason}); creating tasks alone never resumes. Escalated means the review loop hit its limit, not a halt. Deployment requires explicit user confirmation.
+10. Wait for all required tasks to be terminal and members idle/ready, present results, then delete/archive unless the user wants to continue. Never discard unfinished work without authorization.
 Tools: ${toolNames}${profilesText === '' ? '' : `\n\n${profilesText}`}`;
 }
 export function apply(ctx, config) {
@@ -113,28 +116,15 @@ export function apply(ctx, config) {
     // concurrent activation — so capability validation happens at the first
     // member spawn (`spawnMember`), the earliest point the provider list is
     // settled, rather than here.
-    const toolNames = [
-        'agent_teams_create',
-        'agent_teams_approve',
-        'agent_teams_edit_plan',
-        'agent_teams_add_member',
-        'agent_teams_remove_member',
-        'agent_teams_create_task',
-        'agent_teams_reassign_task',
-        'agent_teams_claim_task',
-        'agent_teams_update_task',
-        'agent_teams_send_message',
-        'agent_teams_status',
-        'agent_teams_resume',
-        'agent_teams_delete',
-    ].join(', ');
-    ctx.systemPrompt.section({
-        name: 'agent-teams:usage',
-        order: config.promptSectionOrder ?? 117,
-        text: () => usageSectionText(toolNames, formatProfilesForPrompt(config.profiles ?? {})),
-    });
-    // Exported for TDD / docs checks. Not a public runtime API.
     const agentTeamsRuntime = registerAgentTeamsTools(ctx, resolved);
+    installTeamCapabilities(ctx, {
+        stateDir: resolved.stateDir,
+        isPendingMember: agentTeamsRuntime.isPendingMember,
+        order: config.promptSectionOrder,
+        // Keep the bounded profile directory available without extra tool calls.
+        // installTeamCapabilities snapshots this once; no business state rewrites it.
+        captainPrompt: () => usageSectionText(TEAM_TOOL_NAMES.join(', '), formatProfilesForPrompt(config.profiles)),
+    });
     // Deterministic activation surfaces: the closed-namespace `/agent-teams`
     // host command (surfaces in the Web GUI slash menu via the Harness
     // ui-commands client) and the plain-text gesture boundary for surfaces
@@ -289,6 +279,20 @@ export function apply(ctx, config) {
                 try {
                     if (action === 'approve') {
                         const approved = await agentTeamsRuntime.approveStagedTeam(captain, teamId);
+                        // The browser receives the HTTP result, so the model needs its own
+                        // control message. steer wakes an idle captain or joins its next
+                        // step; the tool approve path already returns to the model itself.
+                        try {
+                            captain.steer(createUserMessage({
+                                content: [{ type: 'text', text: stagedPlanApprovedContext(team.name) }],
+                                source: { kind: 'plugin', plugin: 'dsh-agent-teams' },
+                            }));
+                        }
+                        catch (error) {
+                            // Approval is already committed. Do not report a failed approval
+                            // and invite a retry that could duplicate the user's action.
+                            ctx.logger.warn(`agent-teams: approval notification failed for ${teamId}: ${String(error)}`);
+                        }
                         res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
                         res.end(JSON.stringify({ ok: true, phase: 'running', ...approved }));
                         return;

package/lib/members.js

@@ -20,18 +20,11 @@ import { guardSubagentDelivery, installContinuableMemberSetup, queueMemberPrompt
 import { acknowledgeMailbox, appendMailbox, CAPTAIN_KEY, createMessage, readRetiredMemberIds, readTeamSync, readTeam, releaseMailboxDelivery, withTeamLock, writeTeam } from "./state.js";
 import { appendTeamEvent, captainSessionOf } from "./events.js";
 import { TERMINAL_TASK_STATUSES } from "./types.js";
+import { CAPTAIN_TOOL_NAMES } from "./tool-names.js";
 /** Persona snapshot of a profile protocol; the full text lives on team.json. */
 export const PERSONA_PROTOCOL_MAX_CHARS = 400;
 /** Captain-only AgentTeams tools hidden from newly spawned members. */
-const MEMBER_DENIED_TOOLS = [
-    'agent_teams_create',
-    'agent_teams_add_member',
-    'agent_teams_remove_member',
-    'agent_teams_reassign_task',
-    'agent_teams_create_task',
-    'agent_teams_resume',
-    'agent_teams_delete',
-];
+const MEMBER_DENIED_TOOLS = CAPTAIN_TOOL_NAMES;
 /**
  * Restore the SessionId brand on a value that round-tripped through the
  * durable team file. The brand is erased by JSON serialization; the value
@@ -270,10 +263,7 @@ export async function resolveMemberLlmSelection(ctx, captain, request, signal) {
  */
 export function installMemberSelectionRuntime(ctx, stateDir, onFailureSettled) {
     const pending = new Map();
-    installContinuableMemberSetup(ctx, (childCtx) => {
-        const child = childCtx.agent;
-        if (child === undefined)
-            return () => undefined;
+    installContinuableMemberSetup(ctx, (childCtx, child) => {
         const descriptor = foldSubagentDescriptor(sessionOwnEvents(child.session));
         if (descriptor?.mode !== 'continuable' || !descriptor.label.startsWith(MEMBER_LABEL_PREFIX)) {
             return () => undefined;
@@ -384,6 +374,12 @@ export function installMemberSelectionRuntime(ctx, stateDir, onFailureSettled) {
         };
     });
     return {
+        isPendingMember(agent) {
+            const parent = agent.session.header.parentSession;
+            const descriptor = foldSubagentDescriptor(sessionOwnEvents(agent.session));
+            return parent !== undefined && descriptor?.mode === 'continuable'
+                && pending.has(pendingSelectionKey(parent, descriptor.label));
+        },
         async withPending(parentSessionId, label, selection, operation) {
             const key = pendingSelectionKey(parentSessionId, label);
             if (pending.has(key)) {

package/lib/profiles.js

@@ -116,7 +116,7 @@ function formatProfileListingLine(entry) {
         ? 'captain planning'
         : countLabel(Array.isArray(entry.config.tasks) ? entry.config.tasks.length : 0, 'task');
     const counts = `(${countLabel(memberCount, 'member')}, ${graph})`;
-    const summary = protocolSummary(entry.config.protocol);
+    const summary = protocolSummary(entry.config.protocol) ?? protocolSummary(entry.config.description);
     return summary === undefined
         ? `- ${entry.name} ${counts}`
         : `- ${entry.name} ${counts}: ${summary}`;

package/lib/state.js

@@ -37,15 +37,29 @@ export async function withTeamLock(key, fn) {
     const previous = locks.get(key) ?? Promise.resolve();
     let release;
     const gate = new Promise((resolve) => { release = resolve; });
-    locks.set(key, previous.then(() => gate));
+    const tail = previous.then(() => gate);
+    locks.set(key, tail);
     await previous;
     try {
         return await fn();
     }
     finally {
         release();
+        // Drop this key's queue entry once we are still its tail, so settled
+        // teams do not leave one resolved promise chained forever (the same
+        // cleanup discipline as the scheduler's serializeMember). A successor
+        // that already appended itself owns the map slot; keep its entry.
+        if (locks.get(key) === tail)
+            locks.delete(key);
     }
 }
+/**
+ * Keys with an in-process lock queue (held or waiting), snapshot for
+ * diagnostics and leak checks. The queue promises themselves stay private.
+ */
+export function teamLockQueueKeys() {
+    return [...locks.keys()];
+}
 /** Longest key emitted before truncating and appending a digest. */
 const MAX_KEY_LENGTH = 48;
 /** Short stable digest, used to keep otherwise-colliding keys distinct. */
@@ -228,13 +242,27 @@ export async function writeTeam(stateRoot, state) {
     await atomicWriteText(join(stateRoot, state.id, 'team.json'), JSON.stringify(state, null, 2));
 }
 /** Read the durable set of member session ids retired by remove/delete. */
+function parseRetiredMemberIds(raw) {
+    const parsed = JSON.parse(stripLeadingBom(raw));
+    if (!Array.isArray(parsed) || parsed.some(value => typeof value !== 'string' || value === '')) {
+        throw new Error('invalid AgentTeams retired member index');
+    }
+    return new Set(parsed);
+}
+/** Synchronous role hydration before the host's first prompt assembly. */
+export function readRetiredMemberIdsSync(stateRoot) {
+    try {
+        return parseRetiredMemberIds(readFileSync(join(stateRoot, RETIRED_MEMBERS_FILE), 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return new Set();
+        throw error;
+    }
+}
 export async function readRetiredMemberIds(stateRoot) {
     try {
-        const parsed = JSON.parse(stripLeadingBom(await readFile(join(stateRoot, RETIRED_MEMBERS_FILE), 'utf8')));
-        if (!Array.isArray(parsed) || parsed.some(value => typeof value !== 'string' || value === '')) {
-            throw new Error('invalid AgentTeams retired member index');
-        }
-        return new Set(parsed);
+        return parseRetiredMemberIds(await readFile(join(stateRoot, RETIRED_MEMBERS_FILE), 'utf8'));
     }
     catch (error) {
         if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {

package/lib/tool-names.js

@@ -0,0 +1,11 @@
+/** Stable business API names; exposure changes never rename these operations. */
+export const TEAM_TOOL_NAMES = [
+    'agent_teams_create', 'agent_teams_approve', 'agent_teams_edit_plan',
+    'agent_teams_add_member', 'agent_teams_remove_member', 'agent_teams_create_task',
+    'agent_teams_reassign_task', 'agent_teams_claim_task', 'agent_teams_update_task',
+    'agent_teams_send_message', 'agent_teams_status', 'agent_teams_resume', 'agent_teams_delete',
+];
+export const MEMBER_TOOL_NAMES = [
+    'agent_teams_claim_task', 'agent_teams_update_task', 'agent_teams_send_message', 'agent_teams_status',
+];
+export const CAPTAIN_TOOL_NAMES = TEAM_TOOL_NAMES.filter(name => !MEMBER_TOOL_NAMES.includes(name));

package/lib/tools.js

@@ -276,6 +276,15 @@ export async function haltTeamWork(input) {
         alreadyHalted: halted.alreadyHalted,
     };
 }
+/** Web approval has no tool result in the captain's conversation. */
+export function stagedPlanApprovedContext(teamName) {
+    return [
+        `The user approved the staged AgentTeams plan "${teamName}" from the pre-run review UI.`,
+        'Approval has committed; the scheduler owns dispatch of the approved team. Do not approve again, recreate the roster, or send messages merely to start assigned tasks.',
+        'Acknowledge the approval and handle any reports or user work already pending. Yield only when waiting for members is the remaining action. Their reports will wake you automatically; do not busy-poll status or keep a turn running just to wait.',
+        'On a report, inspect the result and coordinate the next necessary action. If work has since been halted, respect that state and resume only on an explicit user request.',
+    ].join('\n');
+}
 /** Context queued after the human rejects a staged plan. */
 export function stagedPlanDiscardContext(teamName) {
     return [
@@ -524,6 +533,7 @@ export function registerAgentTeamsTools(ctx, config) {
         return { teamId: discarded.teamId };
     };
     const runtime = {
+        isPendingMember: memberSelections.isPendingMember,
         updateStagedPlan,
         updateStagedPlanBatch,
         approveStagedTeam,
@@ -584,7 +594,10 @@ export function registerAgentTeamsTools(ctx, config) {
                 const current = await findTeamByParticipant(stateRoot, captain.id);
                 if (current !== undefined) {
                     const relationship = current.captainSessionId === captain.id ? 'lead' : 'belong to';
-                    throw new Error(`you already ${relationship} team "${current.name}" — end or leave it before creating another`);
+                    const guidance = current.captainSessionId === captain.id
+                        ? 'Use agent_teams_status and continue the existing team. Do not delete and recreate it merely to continue work. End it only when the user explicitly wants a separate new team.'
+                        : 'Continue your assigned member work and report to your captain; do not create a separate team.';
+                    throw new Error(`you already ${relationship} team "${current.name}" (id ${current.id}). ${guidance}`);
                 }
                 return withTeamLock(teamLockKey(stateRoot, teamId), async () => {
                     const existing = await readTeam(stateRoot, teamId);
@@ -1873,7 +1886,7 @@ export function registerAgentTeamsTools(ctx, config) {
     }));
     ctx.tools.register(defineTool({
         name: 'agent_teams_delete',
-        description: 'End your team: interrupts all members (best effort) and deletes the team\'s state directory (team file, tasks, mailboxes). Use when the team\'s work is done or abandoned.',
+        description: 'End and archive your team: interrupts members and moves the current tasks and mailboxes out of active state for later inspection. Use when the work is done or explicitly abandoned. A same-name archive replaces its previous generation.',
         parameters: {},
         output: {
             schema: {
@@ -1886,7 +1899,7 @@ export function registerAgentTeamsTools(ctx, config) {
             },
             render: (args, value) => [{
                     type: 'text',
-                    text: `Team "${value.team_name}" deleted.`,
+                    text: `Team "${value.team_name}" ended and archived.`,
                 }],
         },
         async execute(_args, exec) {

package/lib/types/capabilities.d.ts

@@ -0,0 +1,14 @@
+/** Stable, agent-scoped presentation. Business authority stays in the tools. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+export declare const TEAM_ACTIVATION_PROMPT = "AgentTeams (Agent Teams) provides multi-agent team collaboration. Apply these rules when the user requests it (including /agent-teams) or when continuing an existing team. Mentioning, quoting, discussing, or declining AgentTeams alone is not a request to start work.";
+export declare const TEAM_MEMBER_PROMPT = "You are an AgentTeams member. Follow your assigned member persona and task contract. Use agent_teams_claim_task, agent_teams_update_task, agent_teams_send_message and agent_teams_status for your own work. Include the current attempt_id in updates; report completion or failure to the captain. Do not create, approve, edit or resume a team. If your durable membership is unavailable, report that to the parent instead of creating a replacement.";
+interface CapabilityConfig {
+    stateDir: string;
+    isPendingMember: (agent: Agent) => boolean;
+    captainPrompt: () => string;
+    order?: number;
+}
+/** Call once, after all business definitions have registered. Never per member. */
+export declare function installTeamCapabilities(ctx: Context, config: CapabilityConfig): void;
+export {};

package/lib/types/client/ActivityPanel.d.ts

@@ -25,8 +25,9 @@ import type { SessionListState } from '@deepseek-ai/dsh-api-session-controller/c
  * snapshots and historic card summaries are only shown while their captain
  * session is the one currently open. */
 export type ActivityPanelProps = {
+    readonly conversationVisible?: boolean;
     readonly sessionsList: ObservableSnapshot<SessionListState>;
     readonly modelDirectories: ModelDirectoryResolver;
     readonly openMember: (parentId: SessionId, childId: SessionId) => void;
 } & PropsLocale<'agentTeams'>;
-export declare function ActivityPanel({ sessionsList, modelDirectories, openMember, t }: ActivityPanelProps): import("react").JSX.Element | null;
+export declare function ActivityPanel({ sessionsList, modelDirectories, openMember, t, conversationVisible }: ActivityPanelProps): import("react").JSX.Element | null;

package/lib/types/client/session-navigation.d.ts

@@ -12,12 +12,18 @@ export interface AgentTeamsSessionNavigator {
     /** Reuse an address already retained by the client runtime when available. */
     subagentAddress?(id: SessionId): SubagentAddress | undefined;
 }
+/** Main-panel navigation added in Harness 0.1.5; older layouts omit these actions. */
+export interface AgentTeamsLayoutNavigator {
+    selectPanel?(panelId: null): void;
+    beginNavigation?(): AbortSignal;
+}
 /**
  * Open one member's persisted transcript.
  *
  * Harness rc.8 intentionally removed cold subagents from the ordinary session
  * list. They must first be rediscovered in their parent's catalog, then opened
  * with the exact parent/child/mode address. Older runtimes have only `open()`;
- * the fallback preserves the plugin's rc.6 peer range.
+ * the fallback preserves ordinary-session navigation. New layouts also select
+ * the Conversation panel and cancel catalog refreshes superseded by navigation.
  */
-export declare function openAgentTeamMember(sessions: AgentTeamsSessionNavigator, parentSessionId: SessionId, childSessionId: SessionId): Promise<'subagent' | 'session'>;
+export declare function openAgentTeamMember(sessions: AgentTeamsSessionNavigator, parentSessionId: SessionId, childSessionId: SessionId, layout?: AgentTeamsLayoutNavigator): Promise<'subagent' | 'session' | 'cancelled'>;

package/lib/types/harness-compat.d.ts

@@ -1,16 +1,17 @@
 /**
- * The audited Harness 0.1.2 subagent boundary. Keep version-specific shapes
+ * The audited Harness 0.1.2 / 0.1.5 subagent boundary. Keep version-specific shapes
  * here: API presence alone is not a promise of support for future versions.
  *
  * Alpha.2 owns followup/registerContinuableSetup; Alpha.5 and rc.1 own a
- * host-only FIFO queue and synchronous agent/session-start. Their public
+ * host-only FIFO queue; 0.1.5 uses a queue/steer deliverer. Both emit
+ * synchronous agent/session-start with the explicit Agent. Their public
  * sendMessage instead steers a running Agent and must never carry team jobs.
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
 import type { ContentBlock, MessageId } from '@deepseek-ai/dsh-llm';
 import type { Session, SessionEvent, SessionId } from '@deepseek-ai/dsh-session';
-type Setup = (childCtx: Context) => () => void;
+type Setup = (childCtx: Context, child: Agent) => () => void;
 /** Read child-owned history, excluding any descriptor inherited from a parent. */
 export declare function sessionOwnEvents(session: Session): readonly SessionEvent[];
 /** Install before the first request, including cold resume, with HMR cleanup. */

package/lib/types/index.d.ts

@@ -2,7 +2,9 @@
  * AgentTeams for DeepSeek Harness.
  *
  * A host-plane plugin that registers the `agent_teams_*` tools and one usage
- * section into the global system prompt. After installation any session can
+ * agent-scoped usage section. Each session keeps a stable tool set and core
+ * instructions. Existing business tools cover the complete team lifecycle.
+ * After installation any session can
  * run multi-agent teamwork through natural language (e.g. "use AgentTeams to research X"):
  * the model creates a team (it becomes the captain), spawns members as
  * durable continuable subagents, breaks the goal into tasks with

package/lib/types/members.d.ts

@@ -63,6 +63,8 @@ export interface MemberLlmSelectionRequest {
 }
 /** Process-local bridge between spawn admission and synchronous child setup. */
 export interface MemberSelectionRuntime {
+    /** Trusted fresh-child admission, before the durable member id is written. */
+    isPendingMember(agent: Agent): boolean;
     /** Make one selection visible while Harness materializes the fresh child. */
     withPending<T>(parentSessionId: string, label: string, selection: MemberLlmSelection, operation: () => Promise<T>): Promise<T>;
 }

package/lib/types/state.d.ts

@@ -23,6 +23,11 @@ export declare const CAPTAIN_KEY = "captain";
  * @returns the mutation's result.
  */
 export declare function withTeamLock<T>(key: string, fn: () => Promise<T>): Promise<T>;
+/**
+ * Keys with an in-process lock queue (held or waiting), snapshot for
+ * diagnostics and leak checks. The queue promises themselves stay private.
+ */
+export declare function teamLockQueueKeys(): readonly string[];
 /**
  * Fold a free-form name into a safe path/key segment.
  *
@@ -101,7 +106,8 @@ export declare function readTeamSync(stateRoot: string, teamId: string): TeamSta
  * @param state - the record to persist.
  */
 export declare function writeTeam(stateRoot: string, state: TeamState): Promise<void>;
-/** Read the durable set of member session ids retired by remove/delete. */
+/** Synchronous role hydration before the host's first prompt assembly. */
+export declare function readRetiredMemberIdsSync(stateRoot: string): Set<string>;
 export declare function readRetiredMemberIds(stateRoot: string): Promise<Set<string>>;
 /** Atomically add session ids to the durable retired-member deny-list. */
 export declare function recordRetiredMemberIds(stateRoot: string, memberIds: readonly string[]): Promise<void>;

package/lib/types/tool-names.d.ts

@@ -0,0 +1,4 @@
+/** Stable business API names; exposure changes never rename these operations. */
+export declare const TEAM_TOOL_NAMES: readonly ["agent_teams_create", "agent_teams_approve", "agent_teams_edit_plan", "agent_teams_add_member", "agent_teams_remove_member", "agent_teams_create_task", "agent_teams_reassign_task", "agent_teams_claim_task", "agent_teams_update_task", "agent_teams_send_message", "agent_teams_status", "agent_teams_resume", "agent_teams_delete"];
+export declare const MEMBER_TOOL_NAMES: readonly string[];
+export declare const CAPTAIN_TOOL_NAMES: ("agent_teams_create" | "agent_teams_approve" | "agent_teams_edit_plan" | "agent_teams_add_member" | "agent_teams_remove_member" | "agent_teams_create_task" | "agent_teams_reassign_task" | "agent_teams_claim_task" | "agent_teams_update_task" | "agent_teams_send_message" | "agent_teams_status" | "agent_teams_resume" | "agent_teams_delete")[];

package/lib/types/tools.d.ts

@@ -62,6 +62,7 @@ export type StagedPlanMutation = {
 };
 /** Runtime bridge shared by model-facing tools and the Web staging surface. */
 export interface AgentTeamsRuntime {
+    isPendingMember(agent: Agent): boolean;
     updateStagedPlan(captain: Agent, teamId: string, mutation: StagedPlanMutation, signal?: AbortSignal): Promise<TeamState>;
     updateStagedPlanBatch(captain: Agent, teamId: string, mutations: readonly StagedPlanMutation[], signal?: AbortSignal): Promise<TeamState>;
     approveStagedTeam(captain: Agent, teamId: string, signal?: AbortSignal): Promise<{
@@ -88,6 +89,8 @@ export declare function haltTeamWork(input: {
     cancelledTasks: number;
     alreadyHalted: boolean;
 }>;
+/** Web approval has no tool result in the captain's conversation. */
+export declare function stagedPlanApprovedContext(teamName: string): string;
 /** Context queued after the human rejects a staged plan. */
 export declare function stagedPlanDiscardContext(teamName: string): string;
 /** Model-facing continuation that turns the review UI back into a conversation. */