@nanmicoder/dsh-agent-teams 0.1.22 → 0.1.24-rc.1

package/lib/tools.js

@@ -1,24 +1,21 @@
-/**
- * The `agent_teams_*` model-facing tools.
- *
- * The captain (the agent that created the team) orchestrates: members are
- * continuable subagents it spawns and wakes. Members share the same tools and
- * drive their own task state, mirroring the Claude Code AgentTeams flow:
- * create team → add members → create tasks with dependencies → claim/assign →
- * work → report → status → delete.
- * @module dsh-agent-teams/tools
- */
+import { drainMemberChildren } from "./harness-compat.js";
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { join } from 'node:path';
 import { appendTeamEvent, captainSessionOf } from "./events.js";
-import { amendTaskContract, acknowledgeMailbox, markMailboxDelivered, discardMailboxMessages, appendMailbox, archiveTeamDir, beginTaskAttempt, CAPTAIN_KEY, createMessage, createTeamDir, findTeamByCaptain, findTeamByParticipant, cancelUnfinishedTask, invalidateTaskAttempt, readUnreadMailbox, readMailbox, recordRetiredMemberIds, releaseMailboxDelivery, readTeam, sanitizeKey, transitionError, unsatisfiedDependencies, withTeamLock, writeTeam, validateCreateTask, evaluateQualityCompletion, planQualityFollowUp, resumeTeamState, buildCoverageMatrix, canDeclareDelivery, describeQualityLoop, sanitizeReviewAcceptance, sanitizeReviewObjective, normalizeBlankOptionalTaskFields, taskKindOf, } from "./state.js";
+import { amendTaskContract, acknowledgeMailbox, markMailboxDelivered, discardMailboxMessages, appendMailbox, archiveTeamDir, beginTaskAttempt, CAPTAIN_KEY, createMessage, createTeamDir, findTeamByCaptain, findTeamByParticipant, cancelUnfinishedTask, invalidateTaskAttempt, readUnreadMailbox, readMailbox, recordRetiredMemberIds, releaseMailboxDelivery, readTeam, sanitizeKey, transitionError, unsatisfiedDependencies, withTeamLock, writeTeam, validateCreateTask, evaluateQualityCompletion, planQualityFollowUp, resumeTeamState, buildCoverageMatrix, canDeclareDelivery, describeQualityLoop, sanitizeReviewAcceptance, sanitizeReviewObjective, isValidFindingLine, normalizeBlankOptionalTaskFields, taskKindOf, } from "./state.js";
 import { appendTaskEvidence } from "./quality-gates.js";
+import { artifactDrift, bindReviewToRevision, isQualityKind, verdictScopePatterns, } from "./quality-gates.js";
+import { auditTeamWorkspace } from "./workspace-audit.js";
+import { readArtifactScope, snapshotWorkspacePaths, workspacePathExists } from "./artifacts.js";
+import { restrictableToolNames } from "./harness-compat.js";
+import { memberSpawnRelaxableDeny, optionalToolPolicy, requireToolPolicy, resolveMemberToolFilter } from "./tool-policies.js";
 import { deliverToMember, installRetiredMemberGuard, installMemberSelectionRuntime, installMemberDelegationGuard, memberActivity, resolveMemberLlmSelection, spawnMember, steerCaptainReport, validateMemberLlmSelections, } from "./members.js";
 import { TERMINAL_TASK_STATUSES } from "./types.js";
 import { collectCompletedDependencyOutputs, formatDependencyOutputs, installTeamScheduler } from "./scheduler.js";
 import { installMailboxAdmission, isCurrentMail, mailboxContent, mailboxPrompt, readCurrentMailbox } from "./mailbox.js";
 import { resolveTeamProfile } from "./profiles.js";
+import { forkLineageNote, leadIdentityOfAsync, nearestLiveLead, sessionLeadsTeamAsync } from "./lineage.js";
 export { steerCaptainReport } from "./members.js";
 /** The caller agent, or a loud failure for non-agent callers. */
 function requireCaptain(exec) {
@@ -39,29 +36,64 @@ function stateRootOf(workspace, config) {
 function teamLockKey(stateRoot, teamId) {
     return `team:${stateRoot}:${teamId}`;
 }
+/**
+ * Bind a closing verdict to the revision it judged, using the snapshot taken
+ * when its attempt started (if any) to notice that the workspace changed while
+ * the gate was being formed. A verdict that ran over a moving workspace binds
+ * the drift explicitly instead of claiming the current bytes.
+ */
+function bindClosingVerdict(workspace, team, task) {
+    if (task.status !== 'completed')
+        return;
+    const kind = taskKindOf(task);
+    if (kind !== 'review' && kind !== 'requirements' && kind !== 'verification')
+        return;
+    if ((kind === 'review' || kind === 'requirements') && task.verdict !== 'pass')
+        return;
+    const scope = verdictScopePatterns(team, task);
+    if (scope.length === 0)
+        return;
+    const read = readArtifactScope(workspace, scope);
+    const duringDrift = task.verdictStartSnapshot === undefined
+        ? []
+        : artifactDrift(task.verdictStartSnapshot.artifacts, read.artifacts);
+    const bound = bindReviewToRevision(team, task, {
+        artifacts: read.artifacts,
+        gaps: read.gaps,
+        scope,
+        duringDrift,
+    });
+    task.reviewedTaskId = bound.reviewedTaskId;
+    task.reviewedAttempt = bound.reviewedAttempt;
+    task.reviewedArtifacts = bound.reviewedArtifacts;
+    task.reviewedGaps = bound.reviewedGaps;
+    task.reviewedScope = bound.reviewedScope;
+    task.reviewedDuringDrift = bound.reviewedDuringDrift;
+    task.verdictStartSnapshot = undefined;
+}
 /** Process-local lock key enforcing one active team per captain session. */
 function captainLockKey(stateRoot, captainId) {
     return `captain:${stateRoot}:${captainId}`;
 }
 /** The team this captain currently leads, or a loud failure. */
-async function requireCaptainTeam(workspace, config, captain) {
-    const team = await findTeamByCaptain(stateRootOf(workspace, config), captain.id);
+async function requireCaptainTeam(ctx, workspace, config, captain) {
+    const team = await findTeamByCaptain(stateRootOf(workspace, config), captain.id, await leadIdentityOfAsync(ctx, captain.session));
     if (team === undefined) {
-        throw new Error('you are not leading any team yet — call agent_teams_create first');
+        throw new Error(`you are not leading any team yet — call agent_teams_create first${forkLineageNote(captain.session)}`);
     }
     return team;
 }
 /** The team this captain or active member currently participates in. */
-async function requireParticipantTeam(workspace, config, caller) {
-    const team = await findTeamByParticipant(stateRootOf(workspace, config), caller.id);
+async function requireParticipantTeam(ctx, workspace, config, caller) {
+    const team = await findTeamByParticipant(stateRootOf(workspace, config), caller.id, await leadIdentityOfAsync(ctx, caller.session));
     if (team === undefined) {
-        throw new Error('you do not lead or belong to any active team yet');
+        throw new Error(`you do not lead or belong to any active team yet${forkLineageNote(caller.session)}`);
     }
     return team;
 }
 /** Re-derive a caller's role from fresh state while holding the team lock. */
-function participantIdentityOf(team, agentId) {
-    if (team.captainSessionId === agentId)
+async function participantIdentityOf(ctx, team, agentId) {
+    if (await sessionLeadsTeamAsync(ctx, team, agentId))
         return { kind: 'captain', name: CAPTAIN_KEY };
     const member = team.members.find((candidate) => candidate.id === agentId && candidate.status !== 'removed');
     return member === undefined ? undefined : { kind: 'member', name: member.name };
@@ -74,17 +106,17 @@ async function requireFreshTeam(stateRoot, teamId) {
     return fresh;
 }
 /** Fresh state with captain authorization rechecked inside the lock. */
-async function requireFreshCaptainTeam(stateRoot, teamId, captainId) {
+async function requireFreshCaptainTeam(ctx, stateRoot, teamId, captainId) {
     const fresh = await requireFreshTeam(stateRoot, teamId);
-    if (fresh.captainSessionId !== captainId) {
-        throw new Error(`only the captain of team "${fresh.name}" may perform this operation`);
+    if (!(await sessionLeadsTeamAsync(ctx, fresh, captainId))) {
+        throw new Error(`only the captain of team "${fresh.name}" (session ${fresh.captainSessionId}) or one of its fork descendants may perform this operation`);
     }
     return fresh;
 }
 /** Fresh state and caller identity rechecked inside the lock. */
-async function requireFreshParticipant(stateRoot, teamId, callerId) {
+async function requireFreshParticipant(ctx, stateRoot, teamId, callerId) {
     const fresh = await requireFreshTeam(stateRoot, teamId);
-    const identity = participantIdentityOf(fresh, callerId);
+    const identity = await participantIdentityOf(ctx, fresh, callerId);
     if (identity === undefined)
         throw new Error(`you are no longer an active participant in team "${fresh.name}"`);
     return { team: fresh, identity };
@@ -116,6 +148,48 @@ function trimmedOptional(value) {
     const trimmed = value?.trim();
     return trimmed === undefined || trimmed === '' ? undefined : trimmed;
 }
+/**
+ * Resolve one member's selected tool policy into the persisted policy id and
+ * the immutable effective filter (#59).
+ *
+ * An unknown id fails here — before the member is written and before any child
+ * is created — so a typo can never persist a half-configured member or leave a
+ * resumable orphan behind. A member without a policy resolves to `{}`: the
+ * previous behavior and record shape stay untouched.
+ * @param config - resolved plugin config (declared policies + depth cap).
+ * @param captain - the live captain, whose registry view names the host tools.
+ * @param policyId - the selected policy id, or undefined for no policy.
+ * @returns the member fields to persist (`toolPolicy` + `toolFilter`), or `{}`.
+ */
+function memberToolSelection(config, captain, policyId) {
+    if (policyId === undefined)
+        return {};
+    const policy = requireToolPolicy(config.toolPolicies, policyId);
+    return {
+        toolPolicy: policyId,
+        toolFilter: resolveMemberToolFilter(policy, {
+            maxDepth: config.memberMaxDepth,
+            knownTools: restrictableToolNames(captain),
+        }),
+    };
+}
+/**
+ * Deny names the lenient spawn retry may drop for one member.
+ *
+ * A member without a policy keeps the built-in #163/#164 recovery path. A
+ * policy member may only relax built-in entries the owner did not declare
+ * itself (`memberSpawnRelaxableDeny`), and a selected policy id this
+ * deployment no longer declares relaxes nothing: the member then fails loud
+ * instead of spawning under a different filter.
+ * @param config - resolved plugin config.
+ * @param member - the member being spawned.
+ * @returns the relaxable deny names, or undefined for the legacy default.
+ */
+function memberRelaxableDeny(config, member) {
+    if (member.toolPolicy === undefined)
+        return undefined;
+    return memberSpawnRelaxableDeny(optionalToolPolicy(config.toolPolicies, member.toolPolicy), true);
+}
 /** Validate references and cycles before a staged graph can be saved or run. */
 function validateStagedGraph(team, requireRunnable) {
     const members = team.members.filter((member) => member.status !== 'removed');
@@ -183,6 +257,106 @@ function captainOpenTask(team, exceptTaskId) {
  * boundary: it waits for the activation handles to release, so a child cannot
  * keep executing after the captain-chat Stop control has reported success.
  */
+/**
+ * The live Agent the host admits member operations from.
+ *
+ * Harness continuable delivery is authorized against the member's durable
+ * direct parent (`subagents.authorizeLineage`), which is the session that
+ * spawned it — the team's recorded captain. A captain acting from its own fork
+ * therefore commands members *through* that session:
+ *
+ * - while the recorded captain is resident, its Agent is used directly;
+ * - while it is cold, this resolves it through the public session controller
+ *   (`workspaceRegistry.create` + `sessionController.create` with the existing
+ *   session id — attach/resume only: no prompt, no model request, and the
+ *   durable `captainSessionId` is never rewritten);
+ * - when the composition exposes neither service, or the resume fails, the
+ *   operation fails with an explicit bounded error instead of migrating team
+ *   ownership to a session the host would reject at delivery time.
+ *
+ * @param ctx - the plugin context (injects `agents`).
+ * @param team - current team state.
+ * @param caller - the captain-side session performing the operation.
+ * @returns the caller itself, or the live recorded captain session.
+ */
+async function memberOperationParent(ctx, team, caller) {
+    if (caller.id === team.captainSessionId)
+        return caller;
+    const resident = ctx.agents.get(team.captainSessionId);
+    if (resident !== undefined)
+        return resident;
+    const resumed = await resumeLeadAnchor(ctx, team, caller);
+    if (resumed !== undefined)
+        return resumed;
+    throw new Error(`member operations require the live captain session ${team.captainSessionId} that owns team "${team.name}"; this session is its fork and ${resumeUnavailableReason(ctx, team)}`);
+}
+/**
+ * Best-effort live anchor for scheduler calls: the recorded captain when
+ * resident, the resumed one when this composition can attach it, and
+ * `undefined` otherwise (the scheduler then keeps its existing
+ * registry-only behavior). Never throws, so mutating tools stay usable on
+ * compositions without a session controller.
+ * @param ctx - the plugin context (injects `agents`).
+ * @param team - the team whose recorded captain is the delivery parent.
+ * @param caller - the captain-side session performing the operation.
+ * @returns the anchor agent when one is live, else undefined.
+ */
+async function liveLeadAnchorAgent(ctx, team, caller) {
+    if (caller.id === team.captainSessionId)
+        return caller;
+    const resident = ctx.agents.get(team.captainSessionId);
+    if (resident !== undefined)
+        return resident;
+    return resumeLeadAnchor(ctx, team, caller);
+}
+/** Why the recorded captain could not be resumed, for one bounded error message. */
+function resumeUnavailableReason(ctx, team) {
+    const services = optionalTeamServices(ctx);
+    if (services.controller === undefined || services.registry === undefined) {
+        return 'this composition exposes no session controller to resume it, so add_member, member delivery and member drain are unavailable from the fork';
+    }
+    return `resuming it through the session controller failed (its workspace is "${team.name}"'s workspace)`;
+}
+/** Public optional services used only to attach the recorded captain session. */
+function optionalTeamServices(ctx) {
+    const get = ctx.get;
+    if (typeof get !== 'function')
+        return {};
+    const read = (name) => {
+        try {
+            return get.call(ctx, name);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    return {
+        controller: read('sessionController'),
+        registry: read('workspaceRegistry'),
+    };
+}
+/**
+ * Attach the team's recorded captain session in this process without sending a
+ * prompt: the Harness controller's create-with-existing-id path resumes the
+ * session and leaves every durable field (including `captainSessionId`)
+ * untouched.
+ * @returns the resumed Agent, or undefined when this composition cannot resume it.
+ */
+async function resumeLeadAnchor(ctx, team, caller) {
+    const { controller, registry } = optionalTeamServices(ctx);
+    if (controller?.create === undefined || registry?.create === undefined)
+        return undefined;
+    const cwd = caller.session.header.cwd ?? process.cwd();
+    try {
+        const workspace = await registry.create(cwd, cwd);
+        await controller.create({ sessionId: team.captainSessionId, workspaceId: workspace.id, agentPreset: 'standard' });
+        return ctx.agents.get(team.captainSessionId);
+    }
+    catch (error) {
+        ctx.logger.warn(`agent-teams: could not resume the recorded captain session ${team.captainSessionId}: ${String(error)}`);
+        return undefined;
+    }
+}
 async function stopTeamMemberActivations(ctx, captain, members, signal) {
     const memberIds = members.filter(member => member.id !== '').map(member => member.id);
     if (memberIds.length === 0)
@@ -190,14 +364,15 @@ async function stopTeamMemberActivations(ctx, captain, members, signal) {
     // Every supported exact host has targeted recursive drain. Unlike interrupt,
     // it closes admission and clears queued work before awaiting descendants.
     signal?.throwIfAborted();
-    await ctx.subagents.drainContinuableChildren(captain, memberIds);
+    await drainMemberChildren(ctx.subagents, captain, memberIds);
 }
 export async function haltTeamWork(input) {
     const halted = await withTeamLock(teamLockKey(input.stateRoot, input.teamId), async () => {
-        const fresh = await requireFreshCaptainTeam(input.stateRoot, input.teamId, input.captain.id);
+        const fresh = await requireFreshCaptainTeam(input.ctx, input.stateRoot, input.teamId, input.captain.id);
         if (fresh.halted === true) {
             return {
                 teamName: fresh.name,
+                captainSessionId: fresh.captainSessionId,
                 cancelledTasks: fresh.tasks.filter((task) => task.status === 'cancelled').length,
                 alreadyHalted: true,
                 members: fresh.members.filter((member) => member.id !== '' && member.status !== 'removed').map((member) => ({ ...member })),
@@ -225,6 +400,7 @@ export async function haltTeamWork(input) {
         });
         return {
             teamName: fresh.name,
+            captainSessionId: fresh.captainSessionId,
             cancelledTasks,
             alreadyHalted: false,
             members: fresh.members.filter((member) => member.id !== '' && member.status !== 'removed').map((member) => ({ ...member })),
@@ -234,7 +410,17 @@ export async function haltTeamWork(input) {
     // children. Otherwise its current model turn can observe `halted`, call
     // resume, and race the still-running HTTP stop request.
     input.captain.cancel({ kind: 'user' }, { keepInbox: true });
-    await stopTeamMemberActivations(input.ctx, input.captain, halted.members, input.signal);
+    // Members are children of the recorded captain session, so the parent-bound
+    // drain must run as that session when a fork requested the stop.
+    const haltAnchor = input.captain.id === halted.captainSessionId
+        ? input.captain
+        : input.ctx.agents.get(halted.captainSessionId);
+    if (haltAnchor === undefined) {
+        input.ctx.logger.warn(`agent-teams: captain session ${halted.captainSessionId} is not live; member activations of "${halted.teamName}" were not drained from this session`);
+    }
+    else {
+        await stopTeamMemberActivations(input.ctx, haltAnchor, halted.members, input.signal);
+    }
     // Interrupting a child emits a trailing subagent-settled notification. That
     // notification can start a fresh Captain turn after the first cancellation,
     // so close the stop boundary again once every child activation has drained.
@@ -243,6 +429,7 @@ export async function haltTeamWork(input) {
     input.captain.cancel({ kind: 'user' }, { keepInbox: true });
     return {
         teamName: halted.teamName,
+        captainSessionId: halted.captainSessionId,
         cancelledTasks: halted.cancelledTasks,
         alreadyHalted: halted.alreadyHalted,
     };
@@ -284,7 +471,6 @@ export function registerAgentTeamsTools(ctx, config) {
     installMemberDelegationGuard(ctx, config.stateDir, config.memberMaxDepth ?? 0);
     installMailboxAdmission(ctx, config.stateDir);
     const scheduler = installTeamScheduler(ctx, { stateDir: config.stateDir, executionPrompt: config.executionPrompt, dispatch: dispatchMember });
-    const memberSelections = installMemberSelectionRuntime(ctx, config.stateDir, (workspace, teamId, memberName) => (scheduler.kickMember(workspace, teamId, memberName)));
     async function dispatchMember(captain, teamId, memberName, text, signal, mode, attemptId) {
         const root = stateRootOf(workspaceOf(captain), config);
         // Record why a member never started. The scheduler treats a failed dispatch as
@@ -293,7 +479,7 @@ export function registerAgentTeamsTools(ctx, config) {
         const recordSpawnError = async (reason) => {
             try {
                 await withTeamLock(teamLockKey(root, teamId), async () => {
-                    const fresh = await requireFreshCaptainTeam(root, teamId, captain.id);
+                    const fresh = await requireFreshCaptainTeam(ctx, root, teamId, captain.id);
                     const failed = fresh.members.find(item => item.name === memberName && item.status !== 'removed');
                     if (failed === undefined || failed.id !== '')
                         return;
@@ -309,7 +495,7 @@ export function registerAgentTeamsTools(ctx, config) {
         try {
             return await withTeamLock(teamLockKey(root, teamId), async () => {
                 const team = await readTeam(root, teamId);
-                if (team?.captainSessionId !== captain.id || team.halted === true || team.phase === 'staged')
+                if (team === undefined || !(await sessionLeadsTeamAsync(ctx, team, captain.id)) || team.halted === true || team.phase === 'staged')
                     return false;
                 const member = team.members.find(item => item.name === memberName && item.status !== 'removed');
                 if (member === undefined || member.stopping === true || team.tasks.some(task => task.reassigning === true && task.assignee === memberName))
@@ -321,7 +507,7 @@ export function registerAgentTeamsTools(ctx, config) {
                 const selection = await resolveMemberLlmSelection(ctx, captain, {
                     provider: member.provider, model: member.model, reasoningEffort: member.reasoningEffort, fallback: member.fallback,
                 }, signal);
-                await spawnMember(ctx, memberRuntime(config), memberSelections, selection, captain, team, member, config.stateDir, signal, text);
+                await spawnMember(ctx, memberRuntime(config), memberSelections, selection, captain, team, member, config.stateDir, signal, text, member.toolFilter, memberRelaxableDeny(config, member));
                 orphan = { ...member };
                 delete member.spawnError;
                 await writeTeam(root, team);
@@ -349,7 +535,7 @@ export function registerAgentTeamsTools(ctx, config) {
         const workspace = workspaceOf(captain);
         const stateRoot = stateRootOf(workspace, config);
         return withTeamLock(teamLockKey(stateRoot, teamId), async () => {
-            const fresh = await requireFreshCaptainTeam(stateRoot, teamId, captain.id);
+            const fresh = await requireFreshCaptainTeam(ctx, stateRoot, teamId, captain.id);
             const staged = fresh.phase === 'staged';
             if (!staged && !allowPendingEdits)
                 requireStagedTeam(fresh);
@@ -374,6 +560,14 @@ export function registerAgentTeamsTools(ctx, config) {
                     member.model = selection.model;
                     member.reasoningEffort = selection.reasoningEffort;
                     member.executionPrompt = trimmedOptional(mutation.executionPrompt);
+                    // The roster editor replaces route/prompt fields; the tool policy is
+                    // only touched when the mutation names one, so a plan revision cannot
+                    // silently widen a member's tool set.
+                    if (mutation.toolPolicy !== undefined) {
+                        const selected = memberToolSelection(config, captain, trimmedOptional(mutation.toolPolicy));
+                        member.toolPolicy = selected.toolPolicy;
+                        member.toolFilter = selected.toolFilter;
+                    }
                 }
                 else if (mutation.action === 'update_task') {
                     const task = requireTask(fresh, mutation.taskId);
@@ -455,7 +649,7 @@ export function registerAgentTeamsTools(ctx, config) {
         const stateRoot = stateRootOf(workspace, config);
         const runSignal = signal ?? new AbortController().signal;
         const approved = await withTeamLock(teamLockKey(stateRoot, teamId), async () => {
-            const fresh = await requireFreshCaptainTeam(stateRoot, teamId, captain.id);
+            const fresh = await requireFreshCaptainTeam(ctx, stateRoot, teamId, captain.id);
             requireStagedTeam(fresh);
             // A staged removal has no child session to retain in history. Drop those
             // placeholders before transitioning to the stricter running shape.
@@ -479,7 +673,7 @@ export function registerAgentTeamsTools(ctx, config) {
             return { teamId: fresh.id, members: fresh.members.length, tasks: fresh.tasks.length };
         });
         try {
-            await scheduler.kickTeam(workspace, teamId, captain);
+            await scheduler.kickTeam(workspace, teamId, await liveLeadAnchorAgent(ctx, { captainSessionId: captain.id, name: teamId }, captain));
         }
         catch (error) {
             // Approval is already durably committed. A transient wake-up failure is
@@ -493,7 +687,7 @@ export function registerAgentTeamsTools(ctx, config) {
         const workspace = workspaceOf(captain);
         const stateRoot = stateRootOf(workspace, config);
         const prepared = await withTeamLock(teamLockKey(stateRoot, teamId), async () => {
-            const fresh = await requireFreshCaptainTeam(stateRoot, teamId, captain.id);
+            const fresh = await requireFreshCaptainTeam(ctx, stateRoot, teamId, captain.id);
             requireStagedTeam(fresh);
             if (fresh.planReviewState === 'awaiting_feedback') {
                 return { teamName: fresh.name, alreadyWaiting: true };
@@ -518,7 +712,7 @@ export function registerAgentTeamsTools(ctx, config) {
             // Do not leave the durable UI in a false waiting state when the live
             // Captain disappeared between lookup and delivery.
             await withTeamLock(teamLockKey(stateRoot, teamId), async () => {
-                const fresh = await requireFreshCaptainTeam(stateRoot, teamId, captain.id);
+                const fresh = await requireFreshCaptainTeam(ctx, stateRoot, teamId, captain.id);
                 requireStagedTeam(fresh);
                 if (fresh.planReviewState === 'awaiting_feedback') {
                     fresh.planReviewState = 'awaiting_review';
@@ -533,7 +727,7 @@ export function registerAgentTeamsTools(ctx, config) {
         const workspace = workspaceOf(captain);
         const stateRoot = stateRootOf(workspace, config);
         const discarded = await withTeamLock(teamLockKey(stateRoot, teamId), async () => {
-            const fresh = await requireFreshCaptainTeam(stateRoot, teamId, captain.id);
+            const fresh = await requireFreshCaptainTeam(ctx, stateRoot, teamId, captain.id);
             requireStagedTeam(fresh);
             appendTeamEvent(ctx, captainSessionOf(ctx, fresh.captainSessionId, captain.session), 'agent-teams/plan-discarded', {
                 teamId: fresh.id,
@@ -561,14 +755,6 @@ export function registerAgentTeamsTools(ctx, config) {
         captain.cancel({ kind: 'user' }, { keepInbox: true });
         return { teamId: discarded.teamId };
     };
-    const runtime = {
-        isPendingMember: memberSelections.isPendingMember,
-        updateStagedPlan,
-        updateStagedPlanBatch,
-        approveStagedTeam,
-        continueStagedPlanning,
-        discardStagedTeam,
-    };
     ctx.tools.register(defineTool({
         name: 'agent_teams_create',
         description: 'Create a team. Use approval=required for a two-phase plan: members and tasks remain unspawned/unclaimed until the user reviews the Web plan and explicitly approves it. Optional profiles expand their configured roster; seed profiles also expand template tasks, while captain profiles leave the graph for the Captain to design. approval=automatic preserves the legacy immediate-execution path.',
@@ -583,6 +769,7 @@ export function registerAgentTeamsTools(ctx, config) {
                     members: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
                                 name: { type: 'string', required: true }, role: { type: 'string' },
                                 provider: { type: 'string' }, model: { type: 'string' }, reasoning_effort: { type: 'string' },
+                                tool_policy: { type: 'string', description: 'Optional owner-declared tool-policy id for this member.' },
                             } } },
                     tasks: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
                                 id: { type: 'string', required: true, description: 'Local reference used by dependencies in this plan; the result maps it to a durable task id.' },
@@ -604,11 +791,12 @@ export function registerAgentTeamsTools(ctx, config) {
                 properties: {
                     team_id: { type: 'string', required: true },
                     team_name: { type: 'string', required: true },
+                    captain_session_id: { type: 'string', required: true },
                     state_dir: { type: 'string', required: true },
                     phase: { type: 'string', required: true },
                     profile: { type: 'string' },
                     task_planning: { type: 'string' },
-                    members: { type: 'array', items: { type: 'object', additionalProperties: false, properties: { member_name: { type: 'string', required: true }, member_id: { type: 'string', required: true }, provider: { type: 'string', required: true }, model: { type: 'string', required: true }, reasoning_effort: { type: 'string' }, status: { type: 'string', required: true } } } },
+                    members: { type: 'array', items: { type: 'object', additionalProperties: false, properties: { member_name: { type: 'string', required: true }, member_id: { type: 'string', required: true }, member_role: { type: 'string' }, provider: { type: 'string', required: true }, model: { type: 'string', required: true }, reasoning_effort: { type: 'string' }, tool_policy: { type: 'string' }, status: { type: 'string', required: true } } } },
                     tasks: { type: 'array', items: { type: 'object', additionalProperties: false, properties: { task_id: { type: 'string', required: true }, seed_id: { type: 'string', required: true }, subject: { type: 'string', required: true }, status: { type: 'string', required: true }, kind: { type: 'string' }, assignee: { type: 'string' }, dependencies: { type: 'array', items: { type: 'string' }, required: true } } } },
                 },
             },
@@ -619,6 +807,23 @@ export function registerAgentTeamsTools(ctx, config) {
                         : `Team "${value.team_name}" created (id ${value.team_id}) under ${value.state_dir}. You are the captain.`)
                         + (value.tasks === undefined ? '' : '\n' + value.tasks.map(task => `${task.task_id} [${task.seed_id}]: ${task.subject}; assignee=${task.assignee ?? 'unassigned'}; dependencies=${task.dependencies.join(',')}`).join('\n')),
                 }],
+            // The conversation card folds this durable result, and the card cannot
+            // reproduce the host's key cleaning for every name (issue #203). Publish
+            // the canonical identity instead of letting a client re-derive it.
+            presentationMeta: (_args, value) => ({
+                team_id: value.team_id,
+                team_name: value.team_name,
+                captain_session_id: value.captain_session_id,
+                phase: value.phase,
+                ...value.members === undefined ? {} : {
+                    members: value.members.map(member => ({
+                        id: member.member_id,
+                        name: member.member_name,
+                        role: member.member_role ?? '',
+                        status: member.status,
+                    })),
+                },
+            }),
         },
         async execute(args, exec) {
             const captain = requireCaptain(exec);
@@ -638,10 +843,11 @@ export function registerAgentTeamsTools(ctx, config) {
             if (profileName !== undefined && args.plan !== undefined)
                 throw new Error('choose either a configured profile or an inline plan');
             const created = await withTeamLock(captainLockKey(stateRoot, captain.id), async () => {
-                const current = await findTeamByParticipant(stateRoot, captain.id);
+                const current = await findTeamByParticipant(stateRoot, captain.id, await leadIdentityOfAsync(ctx, captain.session));
                 if (current !== undefined) {
-                    const relationship = current.captainSessionId === captain.id ? 'lead' : 'belong to';
-                    const guidance = current.captainSessionId === captain.id
+                    const leads = await sessionLeadsTeamAsync(ctx, current, captain.id);
+                    const relationship = leads ? 'lead' : 'belong to';
+                    const guidance = leads
                         ? '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}`);
@@ -684,7 +890,7 @@ export function registerAgentTeamsTools(ctx, config) {
             });
             if (created.committed) {
                 try {
-                    await scheduler.kickTeam(workspace, created.state.id, captain);
+                    await scheduler.kickTeam(workspace, created.state.id, await liveLeadAnchorAgent(ctx, created.state, captain));
                 }
                 catch (error) {
                     ctx.logger.warn(`agent-teams: post-create kick failed for "${created.state.id}": ${String(error)}`);
@@ -725,6 +931,7 @@ export function registerAgentTeamsTools(ctx, config) {
                 return {
                     team_id: snapshot.id,
                     team_name: snapshot.name,
+                    captain_session_id: snapshot.captainSessionId,
                     state_dir: join(stateRoot, snapshot.id),
                     phase: snapshot.phase ?? 'running',
                 };
@@ -732,6 +939,7 @@ export function registerAgentTeamsTools(ctx, config) {
             return {
                 team_id: snapshot.id,
                 team_name: snapshot.name,
+                captain_session_id: snapshot.captainSessionId,
                 state_dir: join(stateRoot, snapshot.id),
                 phase: snapshot.phase ?? 'running',
                 ...snapshot.profile === undefined ? {} : { profile: snapshot.profile.name },
@@ -739,9 +947,11 @@ export function registerAgentTeamsTools(ctx, config) {
                 members: snapshot.members.map((member) => ({
                     member_name: member.name,
                     member_id: member.id,
+                    ...member.role === undefined ? {} : { member_role: member.role },
                     provider: member.provider ?? '',
                     model: member.model ?? '',
                     ...member.reasoningEffort === undefined ? {} : { reasoning_effort: member.reasoningEffort },
+                    ...member.toolPolicy === undefined ? {} : { tool_policy: member.toolPolicy },
                     status: member.status,
                 })),
                 tasks: snapshot.tasks.map((task) => ({
@@ -784,6 +994,7 @@ export function registerAgentTeamsTools(ctx, config) {
                         model: { type: 'string', description: 'Optional member model; defaults to the current staged route.' },
                         reasoning_effort: { type: 'string', description: 'Optional member reasoning effort.' },
                         execution_prompt: { type: 'string', description: 'Optional member-specific execution prompt.' },
+                        tool_policy: { type: 'string', description: 'Optional owner-declared tool-policy id for this member; an empty string clears it back to the unchanged default tool set.' },
                     },
                 },
             },
@@ -810,7 +1021,7 @@ export function registerAgentTeamsTools(ctx, config) {
         async execute(args, exec) {
             const captain = requireCaptain(exec);
             const workspace = workspaceOf(captain);
-            const team = await requireCaptainTeam(workspace, config, captain);
+            const team = await requireCaptainTeam(ctx, workspace, config, captain);
             if (args.operations.length === 0)
                 throw new Error('at least one staged plan operation is required');
             const mutations = args.operations.map((operation, index) => {
@@ -828,6 +1039,9 @@ export function registerAgentTeamsTools(ctx, config) {
                         model: operation.model?.trim() || member.model || '',
                         reasoningEffort: operation.reasoning_effort ?? member.reasoningEffort,
                         executionPrompt: operation.execution_prompt ?? member.executionPrompt,
+                        // Omitted means "keep the current policy": a route/prompt revision
+                        // must not silently change what the member may do.
+                        ...operation.tool_policy === undefined ? {} : { toolPolicy: operation.tool_policy },
                     };
                 }
                 if (operation.action === 'update_task') {
@@ -869,7 +1083,7 @@ export function registerAgentTeamsTools(ctx, config) {
             });
             const updated = await updatePlanBatch(captain, team.id, mutations, exec.signal, true);
             if (updated.phase !== 'staged')
-                await scheduler.kickTeam(workspace, team.id, captain);
+                await scheduler.kickTeam(workspace, team.id, await liveLeadAnchorAgent(ctx, team, captain));
             return {
                 status: updated.phase ?? 'running',
                 team_id: updated.id,
@@ -908,7 +1122,7 @@ export function registerAgentTeamsTools(ctx, config) {
                 throw new Error('explicit user approval text is required');
             const captain = requireCaptain(exec);
             const workspace = workspaceOf(captain);
-            const team = await requireCaptainTeam(workspace, config, captain);
+            const team = await requireCaptainTeam(ctx, workspace, config, captain);
             const approved = await approveStagedTeam(captain, team.id, exec.signal);
             return { status: 'running', team_id: approved.teamId, members: approved.members, tasks: approved.tasks };
         },
@@ -919,10 +1133,11 @@ export function registerAgentTeamsTools(ctx, config) {
         parameters: {
             name: { type: 'string', required: true, description: 'Unique member name inside the team.' },
             role: { type: 'string', description: 'Role of the member (e.g. researcher, engineer, reviewer).' },
-            provider: { type: 'string', description: 'Optional LLM provider route. Use only when the user explicitly requests a different provider; requires model.' },
-            model: { type: 'string', description: 'Optional model override. Omit for the captain\'s current model (or the configured memberModel default).' },
+            provider: { type: 'string', description: 'Optional LLM provider route. Use only when the user explicitly requests a different provider; requires model. Omit to use the configured member route (memberLlmProvider/memberModel) or the captain\'s current route.' },
+            model: { type: 'string', description: 'Optional model override (used verbatim, including any "/" in the id). Omit for the configured memberModel default (paired with memberLlmProvider when set) or the captain\'s current model.' },
             reasoning_effort: { type: 'string', description: 'Optional reasoning effort override: one of the target model\'s supported effort ids, or "default" to force its default. When omitted, the captain\'s effort is inherited only for the same provider/model; a changed route uses the target default.' },
             executionPrompt: { type: 'string', description: 'Optional member-specific execution prompt. It remains editable while staged.' },
+            tool_policy: { type: 'string', description: 'Optional id of a tool policy declared by the deployment owner (config toolPolicies). It restricts which global tools this member sees and may invoke: a policy allow-list also keeps the four coordination tools, and captain-only tools can never be reopened. Omit for the unchanged default tool set.' },
         },
         output: {
             schema: {
@@ -934,24 +1149,26 @@ export function registerAgentTeamsTools(ctx, config) {
                     provider: { type: 'string', required: true },
                     model: { type: 'string', required: true },
                     reasoning_effort: { type: 'string' },
+                    tool_policy: { type: 'string' },
                     status: { type: 'string', required: true },
                     phase: { type: 'string', required: true },
                 },
             },
             render: (args, value) => [{
                     type: 'text',
-                    text: value.phase === 'staged'
+                    text: (value.phase === 'staged'
                         ? `Member "${value.member_name}" added to the staged roster (${value.provider}/${value.model}); no child was spawned.`
-                        : `Member "${value.member_name}" added (session ${value.member_id || 'starts with first ready task'}, ${value.provider}/${value.model}${value.reasoning_effort === undefined ? '' : `, reasoning ${value.reasoning_effort}`}, status ${value.status}).`,
+                        : `Member "${value.member_name}" added (session ${value.member_id || 'starts with first ready task'}, ${value.provider}/${value.model}${value.reasoning_effort === undefined ? '' : `, reasoning ${value.reasoning_effort}`}, status ${value.status}).`)
+                        + (value.tool_policy === undefined ? '' : ` Tool policy "${value.tool_policy}" applies to this member.`),
                 }],
         },
         async execute(args, exec) {
             const captain = requireCaptain(exec);
             const workspace = workspaceOf(captain);
             const stateRoot = stateRootOf(workspace, config);
-            const team = await requireCaptainTeam(workspace, config, captain);
+            const team = await requireCaptainTeam(ctx, workspace, config, captain);
             const created = await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                const fresh = await requireFreshCaptainTeam(stateRoot, team.id, captain.id);
+                const fresh = await requireFreshCaptainTeam(ctx, stateRoot, team.id, captain.id);
                 const memberName = args.name.trim();
                 if (memberName === '')
                     throw new Error('member name must not be empty');
@@ -969,9 +1186,11 @@ export function registerAgentTeamsTools(ctx, config) {
                     provider: args.provider,
                     model: args.model,
                     defaultModel: config.memberModel,
+                    defaultProvider: config.memberLlmProvider,
                     reasoningEffort: args.reasoning_effort,
                     fallback: config.fallback,
                 }, exec.signal);
+                const toolSelection = memberToolSelection(config, captain, trimmedOptional(args.tool_policy));
                 const member = {
                     id: '',
                     name: memberName,
@@ -981,6 +1200,7 @@ export function registerAgentTeamsTools(ctx, config) {
                     reasoningEffort: selection.reasoningEffort,
                     ...selection.fallback === undefined ? {} : { fallback: selection.fallback },
                     executionPrompt: trimmedOptional(args.executionPrompt),
+                    ...toolSelection,
                     joinedAt: Date.now(),
                     status: 'idle',
                 };
@@ -1001,11 +1221,12 @@ export function registerAgentTeamsTools(ctx, config) {
                     ...selection.reasoningEffort === undefined
                         ? {}
                         : { reasoning_effort: selection.reasoningEffort },
+                    ...member.toolPolicy === undefined ? {} : { tool_policy: member.toolPolicy },
                     status: member.status,
                     phase: fresh.phase ?? 'running',
                 };
             });
-            await scheduler.kickMember(workspace, team.id, created.member_name, captain);
+            await scheduler.kickMember(workspace, team.id, created.member_name, await liveLeadAnchorAgent(ctx, team, captain));
             const latest = (await readTeam(stateRoot, team.id))?.members.find(member => member.name === created.member_name);
             return latest === undefined ? created : { ...created, member_id: latest.id, status: latest.status };
         },
@@ -1035,9 +1256,9 @@ export function registerAgentTeamsTools(ctx, config) {
             const captain = requireCaptain(exec);
             const workspace = workspaceOf(captain);
             const stateRoot = stateRootOf(workspace, config);
-            const team = await requireCaptainTeam(workspace, config, captain);
+            const team = await requireCaptainTeam(ctx, workspace, config, captain);
             const revoked = await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                const fresh = await requireFreshCaptainTeam(stateRoot, team.id, captain.id);
+                const fresh = await requireFreshCaptainTeam(ctx, stateRoot, team.id, captain.id);
                 const member = fresh.members.find(item => item.name === args.name);
                 if (member === undefined)
                     throw new Error(`no member \"${args.name}\" in team \"${fresh.name}\"`);
@@ -1060,9 +1281,9 @@ export function registerAgentTeamsTools(ctx, config) {
             });
             if (revoked.member.id !== '') {
                 await recordRetiredMemberIds(stateRoot, [revoked.member.id]);
-                await stopTeamMemberActivations(ctx, captain, [revoked.member], exec.signal);
+                await stopTeamMemberActivations(ctx, await memberOperationParent(ctx, team, captain), [revoked.member], exec.signal);
             }
-            await scheduler.kickTeam(workspace, team.id, captain);
+            await scheduler.kickTeam(workspace, team.id, await liveLeadAnchorAgent(ctx, team, captain));
             return {
                 member_name: revoked.member.name,
                 status: revoked.member.status,
@@ -1123,14 +1344,14 @@ export function registerAgentTeamsTools(ctx, config) {
             const captain = requireCaptain(exec);
             const workspace = workspaceOf(captain);
             const stateRoot = stateRootOf(workspace, config);
-            const team = await requireCaptainTeam(workspace, config, captain);
+            const team = await requireCaptainTeam(ctx, workspace, config, captain);
             // Some models materialize optional parameters as "" instead of omitting
             // them (issue #105). Normalize blank optional fields to omitted before
             // validation so a blank value can neither be rejected spuriously nor be
             // persisted into team.json, where it would brick the team on reload.
             const input = normalizeBlankOptionalTaskFields(args);
             const created = await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                const fresh = await requireFreshCaptainTeam(stateRoot, team.id, captain.id);
+                const fresh = await requireFreshCaptainTeam(ctx, stateRoot, team.id, captain.id);
                 const gate = validateCreateTask(fresh, {
                     subject: input.subject,
                     description: input.description,
@@ -1225,7 +1446,7 @@ export function registerAgentTeamsTools(ctx, config) {
                     ...task.assignee !== undefined ? { assignee: task.assignee } : {},
                 };
             });
-            await scheduler.kickTeam(workspace, team.id, captain);
+            await scheduler.kickTeam(workspace, team.id, await liveLeadAnchorAgent(ctx, team, captain));
             return created;
         },
     }));
@@ -1259,12 +1480,12 @@ export function registerAgentTeamsTools(ctx, config) {
             const captain = requireCaptain(exec);
             const workspace = workspaceOf(captain);
             const stateRoot = stateRootOf(workspace, config);
-            const team = await requireCaptainTeam(workspace, config, captain);
+            const team = await requireCaptainTeam(ctx, workspace, config, captain);
             const target = args.assignee.trim();
             if (target === '')
                 throw new Error('reassignment assignee must not be empty');
             const revoked = await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                const fresh = await requireFreshCaptainTeam(stateRoot, team.id, captain.id);
+                const fresh = await requireFreshCaptainTeam(ctx, stateRoot, team.id, captain.id);
                 const task = requireTask(fresh, args.task_id);
                 if (task.status === 'completed')
                     throw new Error(`completed task ${task.id} is immutable and cannot be reassigned`);
@@ -1312,14 +1533,14 @@ export function registerAgentTeamsTools(ctx, config) {
             let quiescenceError;
             if (revoked.previousMember !== undefined) {
                 try {
-                    await stopTeamMemberActivations(ctx, captain, [revoked.previousMember], exec.signal);
+                    await stopTeamMemberActivations(ctx, await memberOperationParent(ctx, team, captain), [revoked.previousMember], exec.signal);
                 }
                 catch (error) {
                     quiescenceError = error;
                 }
             }
             await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                const fresh = await requireFreshCaptainTeam(stateRoot, team.id, captain.id);
+                const fresh = await requireFreshCaptainTeam(ctx, stateRoot, team.id, captain.id);
                 const task = requireTask(fresh, args.task_id);
                 if (task.handoffId !== revoked.handoffId || task.assignee !== target || task.reassigning !== true) {
                     throw new Error(`task ${task.id} changed during reassignment; refusing to overwrite the newer state`);
@@ -1350,7 +1571,7 @@ export function registerAgentTeamsTools(ctx, config) {
             if (quiescenceError !== undefined)
                 throw quiescenceError;
             if (target !== CAPTAIN_KEY)
-                await scheduler.kickMember(workspace, team.id, target, captain);
+                await scheduler.kickMember(workspace, team.id, target, await liveLeadAnchorAgent(ctx, team, captain));
             const current = await readTeam(stateRoot, team.id);
             const task = current === undefined ? undefined : requireTask(current, args.task_id);
             if (task === undefined)
@@ -1394,9 +1615,9 @@ export function registerAgentTeamsTools(ctx, config) {
             const caller = requireCaptain(exec);
             const workspace = workspaceOf(caller);
             const stateRoot = stateRootOf(workspace, config);
-            const team = await requireParticipantTeam(workspace, config, caller);
+            const team = await requireParticipantTeam(ctx, workspace, config, caller);
             return withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                const { team: fresh, identity } = await requireFreshParticipant(stateRoot, team.id, caller.id);
+                const { team: fresh, identity } = await requireFreshParticipant(ctx, stateRoot, team.id, caller.id);
                 const task = requireTask(fresh, args.task_id);
                 if (task.reassigning === true) {
                     throw new Error(`task ${task.id} is being reassigned; wait for the handoff to finish`);
@@ -1558,10 +1779,10 @@ export function registerAgentTeamsTools(ctx, config) {
             const caller = requireCaptain(exec);
             const workspace = workspaceOf(caller);
             const stateRoot = stateRootOf(workspace, config);
-            const team = await requireParticipantTeam(workspace, config, caller);
+            const team = await requireParticipantTeam(ctx, workspace, config, caller);
             let followUpMessage;
             const updated = await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                const { team: fresh, identity } = await requireFreshParticipant(stateRoot, team.id, caller.id);
+                const { team: fresh, identity } = await requireFreshParticipant(ctx, stateRoot, team.id, caller.id);
                 const task = requireTask(fresh, args.task_id);
                 if (identity.kind === 'captain'
                     && task.assignee !== undefined
@@ -1635,19 +1856,22 @@ export function registerAgentTeamsTools(ctx, config) {
                     task.acceptanceResults = acceptanceResults;
                 if (commandsRun !== undefined)
                     task.commandsRun = commandsRun;
+                // A passing gate is evidence about a revision: record which one, so a
+                // later edit cannot leave the team advertising an unreviewed revision.
+                bindClosingVerdict(workspace, fresh, task);
                 task.updatedAt = Date.now();
                 const priorDependencies = new Map(fresh.tasks.map(item => [item.id, [...item.dependencies]]));
-                const followUp = (task.status === 'failed' && (task.verdict === 'needs_revision' || task.verdict === 'reject'))
-                    ? applyQualityFollowUp(fresh, task)
+                const followUp = (task.status === 'failed' && isQualityKind(taskKindOf(task)))
+                    ? applyQualityFollowUp(fresh, task, (paths) => snapshotWorkspacePaths(workspace, paths), (path) => workspacePathExists(workspace, path))
                     : undefined;
                 let followUpSummary;
                 if ((followUp?.created.length ?? 0) > 0) {
                     const rewired = fresh.tasks.filter(item => priorDependencies.has(item.id) && JSON.stringify(priorDependencies.get(item.id)) !== JSON.stringify(item.dependencies));
-                    followUpSummary = `Automatic quality follow-up for ${task.id}: ${followUp.created.map(item => `${item.id} (${item.kind}, owner=${item.assignee ?? 'unassigned'}, deps=${item.dependencies.join(',') || 'none'})`).join('; ')}.${rewired.length ? ` Updated dependencies: ${rewired.map(item => `${item.id} -> ${item.dependencies.join(',')}`).join('; ')}.` : ''} Use these tasks; do not create duplicate repair/review work.`;
+                    followUpSummary = `Automatic quality follow-up for ${task.id}: ${followUp.created.map(item => `${item.id} (${item.kind}, owner=${item.assignee ?? 'unassigned'}, deps=${item.dependencies.join(',') || 'none'})`).join('; ')}.${rewired.length ? ` Updated dependencies: ${rewired.map(item => `${item.id} -> ${item.dependencies.join(',')}`).join('; ')}.` : ''} Use these tasks; do not create duplicate repair/review work.${followUp.excludedFindings === undefined ? '' : ` Findings on default-excluded paths were not turned into a contract and stay with the user: ${followUp.excludedFindings.join(', ')}.`}`;
                     followUpMessage = createMessage(CAPTAIN_KEY, CAPTAIN_KEY, followUpSummary);
                 }
                 if (followUp?.escalated === true) {
-                    await appendMailbox(stateRoot, fresh.id, CAPTAIN_KEY, createMessage(CAPTAIN_KEY, CAPTAIN_KEY, `Quality-gate loop escalated after ${task.id} (${task.kind ?? 'review'} verdict=${task.verdict}). Automatic repair/review stopped.`));
+                    await appendMailbox(stateRoot, fresh.id, CAPTAIN_KEY, createMessage(CAPTAIN_KEY, CAPTAIN_KEY, `Quality-gate loop escalated after ${task.id} (${task.kind ?? 'review'} verdict=${task.verdict}). Automatic repair/review stopped.${followUp.reason === undefined ? '' : ` Reason: ${followUp.reason}.`}${followUp.excludedFindings === undefined ? '' : ` Findings left for the user (default-excluded paths, not a member's to edit): ${followUp.excludedFindings.join(', ')}.`}`));
                 }
                 await writeTeam(stateRoot, fresh);
                 if (followUpMessage !== undefined)
@@ -1682,12 +1906,12 @@ export function registerAgentTeamsTools(ctx, config) {
                 };
             });
             if (followUpMessage !== undefined) {
-                const captain = ctx.agents.get(team.captainSessionId);
+                const captain = nearestLiveLead(ctx, team);
                 if (captain !== undefined && steerCaptainReport(captain, CAPTAIN_KEY, followUpMessage.content, mailboxPrompt(team.id, CAPTAIN_KEY, [followUpMessage]))) {
                     await withTeamLock(teamLockKey(stateRoot, team.id), () => markMailboxDelivered(stateRoot, team.id, CAPTAIN_KEY, [followUpMessage.id]));
                 }
             }
-            await scheduler.kickTeam(workspace, team.id, team.captainSessionId === caller.id ? caller : undefined);
+            await scheduler.kickTeam(workspace, team.id, await liveLeadAnchorAgent(ctx, team, caller));
             return updated;
         },
     }));
@@ -1724,9 +1948,9 @@ export function registerAgentTeamsTools(ctx, config) {
             const captain = requireCaptain(exec);
             const workspace = workspaceOf(captain);
             const stateRoot = stateRootOf(workspace, config);
-            const team = await requireCaptainTeam(workspace, config, captain);
+            const team = await requireCaptainTeam(ctx, workspace, config, captain);
             const amended = await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                const fresh = await requireFreshCaptainTeam(stateRoot, team.id, captain.id);
+                const fresh = await requireFreshCaptainTeam(ctx, stateRoot, team.id, captain.id);
                 const task = requireTask(fresh, args.task_id);
                 const input = {
                     ...args.objective === undefined ? {} : { objective: args.objective },
@@ -1801,10 +2025,10 @@ export function registerAgentTeamsTools(ctx, config) {
             const caller = requireCaptain(exec);
             const workspace = workspaceOf(caller);
             const stateRoot = stateRootOf(workspace, config);
-            const team = await requireParticipantTeam(workspace, config, caller);
+            const team = await requireParticipantTeam(ctx, workspace, config, caller);
             const to = args.to.trim();
             const prepared = await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                const { team: fresh, identity } = await requireFreshParticipant(stateRoot, team.id, caller.id);
+                const { team: fresh, identity } = await requireFreshParticipant(ctx, stateRoot, team.id, caller.id);
                 const from = identity.name;
                 // `from` may only be the caller's own identity: impersonating another
                 // member (or the captain) would poison the mailbox and event records.
@@ -1862,9 +2086,11 @@ export function registerAgentTeamsTools(ctx, config) {
             });
             if (prepared.kind === 'duplicate')
                 return { message_id: prepared.message.id, from: prepared.from, to: prepared.message.to, delivered: 'duplicate' };
-            // Resolve the exact live captain only after releasing the state lock.
-            // The plugin mailbox is already durable if live delivery cannot proceed.
-            const captain = ctx.agents.get(prepared.fresh.captainSessionId);
+            // Resolve a live lead only after releasing the state lock: the recorded
+            // captain while resident, otherwise the nearest live fork descendant, so
+            // a human working in a fork still receives member reports. The plugin
+            // mailbox is already durable if no lead session is live.
+            const captain = nearestLiveLead(ctx, prepared.fresh);
             if (prepared.kind === 'captain') {
                 let delivered = 'mailbox';
                 if (captain !== undefined && prepared.identity.kind === 'member') {
@@ -1910,12 +2136,13 @@ export function registerAgentTeamsTools(ctx, config) {
             const caller = requireCaptain(exec);
             const workspace = workspaceOf(caller);
             const stateRoot = stateRootOf(workspace, config);
-            const located = await requireParticipantTeam(workspace, config, caller);
-            if (located.captainSessionId === caller.id) {
-                await scheduler.kickTeam(workspace, located.id, caller);
+            const located = await requireParticipantTeam(ctx, workspace, config, caller);
+            if (await sessionLeadsTeamAsync(ctx, located, caller.id)) {
+                await scheduler.kickTeam(workspace, located.id, await memberOperationParent(ctx, located, caller));
             }
-            const { team, identity } = await withTeamLock(teamLockKey(stateRoot, located.id), () => requireFreshParticipant(stateRoot, located.id, caller.id));
+            const { team, identity } = await withTeamLock(teamLockKey(stateRoot, located.id), () => requireFreshParticipant(ctx, stateRoot, located.id, caller.id));
             const activity = memberActivity(ctx, team.members.map((member) => member.id));
+            const audit = auditTeamWorkspace(workspace, team);
             const members = team.members
                 .filter((member) => member.status !== 'removed')
                 .map((member) => ({
@@ -1924,6 +2151,7 @@ export function registerAgentTeamsTools(ctx, config) {
                 provider: member.provider ?? '',
                 model: member.model ?? '',
                 reasoning_effort: member.reasoningEffort ?? '',
+                tool_policy: member.toolPolicy ?? '',
                 status: member.status,
                 activity: member.id !== '' ? (activity.get(member.id) ?? 'unknown') : 'unspawned',
                 ...member.spawnError === undefined ? {} : { spawn_error: member.spawnError },
@@ -1941,6 +2169,7 @@ export function registerAgentTeamsTools(ctx, config) {
                 ...task.round === undefined ? {} : { round: task.round },
                 ...task.verdict === undefined ? {} : { verdict: task.verdict },
                 ...task.supplementalEvidence === undefined ? {} : { supplemental_evidence: JSON.stringify(task.supplementalEvidence) },
+                ...task.findingSourceTaskIds === undefined ? {} : { fixes: task.findingSourceTaskIds.join(',') },
                 findings_open: (task.findings ?? []).filter((finding) => finding.resolved !== true).length,
                 ...task.profileSeedId === undefined ? {} : { seed_id: task.profileSeedId },
                 ...task.output !== undefined ? { output: task.output } : {},
@@ -1976,9 +2205,13 @@ export function registerAgentTeamsTools(ctx, config) {
                 status: row.status,
                 ...row.evidence === undefined ? {} : { evidence: row.evidence },
             }));
-            const deliveryCheck = canDeclareDelivery(team);
-            const delivery = { ok: deliveryCheck.ok, blockers: [...deliveryCheck.blockers] };
-            const loop = describeQualityLoop(team);
+            const deliveryCheck = canDeclareDelivery(team, audit);
+            const delivery = {
+                ok: deliveryCheck.ok,
+                blockers: [...deliveryCheck.blockers],
+                warnings: [...deliveryCheck.warnings],
+            };
+            const loop = describeQualityLoop(team, audit);
             const result = {
                 team_id: team.id,
                 team_name: team.name,
@@ -2049,9 +2282,9 @@ export function registerAgentTeamsTools(ctx, config) {
             const captain = requireCaptain(exec);
             const workspace = workspaceOf(captain);
             const stateRoot = stateRootOf(workspace, config);
-            const team = await requireCaptainTeam(workspace, config, captain);
+            const team = await requireCaptainTeam(ctx, workspace, config, captain);
             const result = await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                const fresh = await requireFreshCaptainTeam(stateRoot, team.id, captain.id);
+                const fresh = await requireFreshCaptainTeam(ctx, stateRoot, team.id, captain.id);
                 const resumed = resumeTeamState(fresh, args.reason);
                 if (resumed.status === 'rejected')
                     throw new Error(resumed.error ?? 'resume rejected');
@@ -2071,7 +2304,7 @@ export function registerAgentTeamsTools(ctx, config) {
                 };
             });
             if (result.status === 'resumed')
-                await scheduler.kickTeam(workspace, team.id, captain);
+                await scheduler.kickTeam(workspace, team.id, await liveLeadAnchorAgent(ctx, team, captain));
             return result;
         },
     }));
@@ -2097,9 +2330,9 @@ export function registerAgentTeamsTools(ctx, config) {
             const captain = requireCaptain(exec);
             const workspace = workspaceOf(captain);
             const stateRoot = stateRootOf(workspace, config);
-            const team = await requireCaptainTeam(workspace, config, captain);
+            const team = await requireCaptainTeam(ctx, workspace, config, captain);
             const members = await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                const fresh = await requireFreshCaptainTeam(stateRoot, team.id, captain.id);
+                const fresh = await requireFreshCaptainTeam(ctx, stateRoot, team.id, captain.id);
                 // Include previously removed members so deleting a pre-fix team also
                 // retires durable catalog entries left behind by remove_member.
                 const roster = fresh.members.map(member => ({ ...member }));
@@ -2117,9 +2350,9 @@ export function registerAgentTeamsTools(ctx, config) {
                 return roster;
             });
             await recordRetiredMemberIds(stateRoot, members.map(member => member.id));
-            await stopTeamMemberActivations(ctx, captain, members, exec.signal);
+            await stopTeamMemberActivations(ctx, await memberOperationParent(ctx, team, captain), members, exec.signal);
             await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                const fresh = await requireFreshCaptainTeam(stateRoot, team.id, captain.id);
+                const fresh = await requireFreshCaptainTeam(ctx, stateRoot, team.id, captain.id);
                 appendTeamEvent(ctx, captainSessionOf(ctx, fresh.captainSessionId, captain.session), 'agent-teams/team-deleted', {
                     teamId: fresh.id,
                 });
@@ -2130,6 +2363,16 @@ export function registerAgentTeamsTools(ctx, config) {
             return { deleted: true, team_name: team.name };
         },
     }));
+    // Live-member hydration validates saved filters against registered tools.
+    const memberSelections = installMemberSelectionRuntime(ctx, config.stateDir, (workspace, teamId, memberName) => (scheduler.kickMember(workspace, teamId, memberName)));
+    const runtime = {
+        isPendingMember: memberSelections.isPendingMember,
+        updateStagedPlan,
+        updateStagedPlanBatch,
+        approveStagedTeam,
+        continueStagedPlanning,
+        discardStagedTeam,
+    };
     return runtime;
 }
 async function initializeProfileTeam(input) {
@@ -2140,6 +2383,7 @@ async function initializeProfileTeam(input) {
             provider: template.provider,
             model: template.model,
             defaultModel: input.config.memberModel,
+            defaultProvider: input.config.memberLlmProvider,
             reasoningEffort: template.reasoningEffort,
             fallback: template.fallback ?? profile.fallback ?? input.config.fallback,
         }, input.exec.signal));
@@ -2166,6 +2410,9 @@ async function initializeProfileTeam(input) {
         ...input.staged ? { phase: 'staged', planReviewState: 'awaiting_review' } : {},
         members: profile.members.map((template, index) => {
             const selection = selections[index];
+            // A profile member selects a policy by id; an unknown id fails here,
+            // before the team directory and any child session exist (#59).
+            const toolSelection = memberToolSelection(input.config, input.captain, template.toolPolicy);
             return {
                 id: '',
                 name: template.name,
@@ -2175,6 +2422,7 @@ async function initializeProfileTeam(input) {
                 reasoningEffort: selection.reasoningEffort,
                 executionPrompt: template.executionPrompt ?? profile.executionPrompt ?? input.config.executionPrompt,
                 ...selection.fallback === undefined ? {} : { fallback: selection.fallback },
+                ...toolSelection,
                 joinedAt: now,
                 status: 'idle',
             };
@@ -2227,7 +2475,12 @@ function parseFindings(value) {
             // A blank optional file must be omitted, not persisted: durable-state
             // validation requires non-empty optional strings (issue #105 class).
             ...typeof raw['file'] === 'string' && raw['file'].trim() !== '' ? { file: raw['file'] } : {},
-            ...typeof raw['line'] === 'number' ? { line: raw['line'] } : {},
+            // Only a contract-valid line is persisted. A model that materializes
+            // "no line number" as -1 (or sends a non-integer) must not write a record
+            // the durable validator rejects on the next read, which used to brick the
+            // entire team (issue #188). The predicate is shared with
+            // `isReviewFinding`, so the two sides cannot drift apart again.
+            ...isValidFindingLine(raw['line']) ? { line: raw['line'] } : {},
             ...typeof raw['resolved'] === 'boolean' ? { resolved: raw['resolved'] } : {},
         };
     });
@@ -2279,8 +2532,8 @@ function parseCommandResults(value) {
         };
     });
 }
-export function applyQualityFollowUp(team, closed) {
-    const planned = planQualityFollowUp(team, closed);
+export function applyQualityFollowUp(team, closed, snapshotPaths, pathExists) {
+    const planned = planQualityFollowUp(team, closed, pathExists === undefined ? {} : { pathExists });
     if (planned.escalated === true)
         team.escalated = true;
     const created = [];
@@ -2299,6 +2552,12 @@ export function applyQualityFollowUp(team, closed) {
                 return dependency;
             return idBySubject.get(dependency) ?? dependency;
         });
+        // Record the workspace the generated work order was derived from, so a
+        // later round that changes a cited file can mark it stale instead of
+        // letting a member read a frozen snapshot as authoritative (issue #174).
+        const contractSnapshot = draft.contractPaths === undefined || draft.contractPaths.length === 0 || snapshotPaths === undefined
+            ? undefined
+            : snapshotPaths(draft.contractPaths);
         const next = {
             id,
             subject: draft.subject ?? `${draft.kind}-round-${draft.round ?? 1}`,
@@ -2309,6 +2568,7 @@ export function applyQualityFollowUp(team, closed) {
             createdAt: now,
             updatedAt: now,
             kind: draft.kind,
+            ...draft.description === undefined ? {} : { description: draft.description },
             ...draft.round === undefined ? {} : { round: draft.round },
             ...draft.objective === undefined ? {} : { objective: draft.objective },
             ...draft.inScope === undefined ? {} : { inScope: draft.inScope },
@@ -2317,7 +2577,9 @@ export function applyQualityFollowUp(team, closed) {
             ...draft.verify === undefined ? {} : { verify: draft.verify },
             ...draft.sourceTaskId === undefined ? {} : { sourceTaskId: draft.sourceTaskId },
             ...draft.sourceFindingIds === undefined ? {} : { sourceFindingIds: draft.sourceFindingIds },
+            ...draft.findingSourceTaskIds === undefined ? {} : { findingSourceTaskIds: draft.findingSourceTaskIds },
             ...draft.reviewedTaskId === undefined ? {} : { reviewedTaskId: idBySubject.get(draft.reviewedTaskId) ?? draft.reviewedTaskId },
+            ...contractSnapshot === undefined ? {} : { contractSnapshot },
         };
         team.tasks.push(next);
         created.push(next);
@@ -2336,7 +2598,12 @@ export function applyQualityFollowUp(team, closed) {
             task.updatedAt = now;
         }
     }
-    return { created, escalated: planned.escalated === true };
+    return {
+        created,
+        escalated: planned.escalated === true,
+        ...planned.reason === undefined ? {} : { reason: planned.reason },
+        ...planned.excludedFindings === undefined ? {} : { excludedFindings: planned.excludedFindings },
+    };
 }
 /** Build the `memberRuntime` config handed to member helpers. */
 function memberRuntime(config) {
@@ -2368,7 +2635,8 @@ function renderStatus(value) {
             const route = member.provider && member.model ? ` · ${member.provider}/${member.model}` : '';
             const effort = member.reasoning_effort ? ` · reasoning ${member.reasoning_effort}` : '';
             const failure = member.spawn_error === undefined ? '' : `\n      start failed: ${member.spawn_error.slice(0, 400)}`;
-            return `  - ${member.name} [${member.role}] ${member.status}/${member.activity}${route}${effort}${failure}`;
+            const policy = member.tool_policy ? ` · policy ${member.tool_policy}` : '';
+            return `  - ${member.name} [${member.role}] ${member.status}/${member.activity}${route}${effort}${policy}${failure}`;
         }),
         `Tasks (${team.tasks.length}):`,
         ...team.tasks.map((task) => {
@@ -2380,7 +2648,8 @@ function renderStatus(value) {
             const kind = task.kind ? ` ${task.kind}` : '';
             const round = task.round === undefined ? '' : ` r${task.round}`;
             const verdict = task.verdict === undefined ? '' : ` verdict ${task.verdict}`;
-            return `  - ${task.id} [${task.status}]${kind}${round}${verdict} attempt ${task.attempt}${handoff}${seed} ${task.subject} → ${task.assignee || 'unassigned'}${deps}${output}${evidence}`;
+            const fixes = task.fixes === undefined ? '' : ` fixes ${task.fixes}`;
+            return `  - ${task.id} [${task.status}]${kind}${round}${verdict}${fixes} attempt ${task.attempt}${handoff}${seed} ${task.subject} → ${task.assignee || 'unassigned'}${deps}${output}${evidence}`;
         }),
         ...team.coverage === undefined || team.coverage.length === 0 ? [] : [
             'Coverage:',
@@ -2389,6 +2658,10 @@ function renderStatus(value) {
         ...team.delivery === undefined ? [] : [
             `Delivery: ${team.delivery.ok ? 'ok' : `blocked (${team.delivery.blockers.join('; ')})`}`,
         ],
+        ...(team.delivery?.warnings ?? []).length === 0 ? [] : [
+            'Gate warnings (delivery is not blocked, but these recorded verdicts or generated work orders no longer describe the current bytes):',
+            ...(team.delivery?.warnings ?? []).map((warning) => `  - ${warning}`),
+        ],
         `Captain inbox (${team.captain_inbox.length}):`,
         ...team.captain_inbox.map((message) => `  - [${message.from}] ${message.content}`),
         ...(team.member_inbox ?? []).map(message => `  - [${message.from}] ${message.content}`),