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

package/lib/harness-compat.js

@@ -0,0 +1,159 @@
+import { SubagentError } from '@deepseek-ai/dsh-subagent';
+/**
+ * Exact protocol exported by dsh-subagent/internal in Alpha.5 and rc.1.
+ * That subpath does not exist in Alpha.2, so importing it statically prevents
+ * the plugin from loading there. This small adapter uses the same process-
+ * stable symbol and call signature as upstream queueHostSubagentPrompt.
+ * Source: packages/subagent/subagent/src/internal.ts at dsh-v0.1.2-rc.1.
+ */
+const hostPromptQueue = Symbol.for('dsh.subagent.queuePrompt');
+function boundary(runtime) {
+    return runtime;
+}
+function unsupported(detail) {
+    throw new Error(`agent-teams: unsupported Harness subagent contract (${detail}); use an explicitly tested Harness version and a coherent dependency installation`);
+}
+/** Read child-owned history, excluding any descriptor inherited from a parent. */
+export function sessionOwnEvents(session) {
+    const current = session;
+    if (typeof current.ownEvents === 'function')
+        return current.ownEvents.call(session);
+    const legacy = session;
+    if (!Array.isArray(legacy.events))
+        return unsupported('missing ownEvents/legacy session log');
+    return legacy.events.slice(legacy.header.seedLength ?? 0);
+}
+/** Install before the first request, including cold resume, with HMR cleanup. */
+export function installContinuableMemberSetup(ctx, setup) {
+    const runtime = boundary(ctx.subagents);
+    if (typeof runtime.registerContinuableSetup === 'function') {
+        // 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);
+        return;
+    }
+    if (typeof runtime[hostPromptQueue] !== 'function' || typeof runtime.sendMessage !== 'function') {
+        return unsupported('missing continuable setup and modern host queue');
+    }
+    const installed = new WeakSet();
+    const active = new Set();
+    ctx.effect(() => {
+        const stop = ctx.on('agent/session-start', ({ agent }) => {
+            if (installed.has(agent))
+                return;
+            // Deliberately synchronous: awaiting here loses the first-request race.
+            let teardown;
+            try {
+                teardown = setup(agent.ctx);
+            }
+            catch (error) {
+                // session-start is a notification: Harness logs a thrown listener and
+                // still admits the first prompt. Reject request assembly explicitly so
+                // a malformed saved route cannot silently execute on a default model.
+                const failure = new Error(`agent-teams: member initialization failed: ${String(error)}`, { cause: error });
+                ctx.logger.warn(failure.message);
+                teardown = agent.ctx.on('agent/request', () => { throw failure; });
+            }
+            installed.add(agent);
+            let disposed = false;
+            const dispose = () => {
+                if (disposed)
+                    return;
+                disposed = true;
+                active.delete(dispose);
+                installed.delete(agent);
+                teardown();
+            };
+            active.add(dispose);
+            // Listeners contributed to agent.ctx already follow its lifetime. Also
+            // release our bookkeeping and remove them if this plugin is reloaded.
+            try {
+                agent.ctx.effect(() => dispose, 'agent-teams: child compatibility setup');
+            }
+            catch (error) {
+                dispose();
+                throw error;
+            }
+        });
+        return () => {
+            stop();
+            for (const dispose of [...active])
+                dispose();
+        };
+    }, 'agent-teams: member lifecycle compatibility');
+}
+/** Queue a distinct host-authored turn; never substitute model-message steer. */
+export async function queueMemberPrompt(runtime, parent, childId, content, signal) {
+    const host = boundary(runtime);
+    const source = { kind: 'plugin', plugin: 'dsh-agent-teams' };
+    if (typeof host.followup === 'function') {
+        return host.followup.call(runtime, parent, childId, content, { source, signal });
+    }
+    const queue = host[hostPromptQueue];
+    if (typeof queue !== 'function')
+        return unsupported('missing host FIFO delivery');
+    return queue.call(runtime, parent, childId, content, source, signal);
+}
+/** Guard all resumable delivery paths, preserving the native service receiver. */
+export function guardSubagentDelivery(ctx, isRetired) {
+    const runtime = ctx.subagents;
+    const host = boundary(runtime);
+    const legacy = host.followup;
+    const queue = host[hostPromptQueue];
+    const send = host.sendMessage;
+    if (typeof legacy !== 'function' && (typeof queue !== '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)],
+            ['sendMessage', Object.getOwnPropertyDescriptor(host, 'sendMessage')],
+        ]);
+        let active = true;
+        const check = async (sender, targetId) => {
+            if (active && await isRetired(sender, targetId)) {
+                throw new SubagentError(`AgentTeams member "${targetId}" was retired and cannot be resumed`, 'NOT_RESUMABLE');
+            }
+        };
+        const guardedLegacy = async (parent, childId, content, options) => {
+            await check(parent, childId);
+            return legacy.call(runtime, parent, childId, content, options);
+        };
+        const guardedQueue = async (parent, childId, content, source, signal) => {
+            await check(parent, childId);
+            return queue.call(runtime, parent, childId, content, source, signal);
+        };
+        const guardedSend = async (sender, targetId, content, options) => {
+            await check(sender, targetId);
+            return send.call(runtime, sender, targetId, content, options);
+        };
+        if (typeof legacy === 'function')
+            host.followup = guardedLegacy;
+        if (typeof queue === 'function')
+            host[hostPromptQueue] = guardedQueue;
+        if (typeof send === 'function')
+            host.sendMessage = guardedSend;
+        // Cordis wraps method reads in fresh Proxies. Compare the actual own
+        // descriptor to restore only our contribution, including prototype methods.
+        const restore = (key, installed) => {
+            if (Object.getOwnPropertyDescriptor(host, key)?.value !== installed)
+                return;
+            const original = descriptors.get(key);
+            if (original === undefined)
+                Reflect.deleteProperty(host, key);
+            else
+                Object.defineProperty(host, key, original);
+        };
+        return () => {
+            active = false;
+            if (typeof legacy === 'function')
+                restore('followup', guardedLegacy);
+            if (typeof queue === 'function')
+                restore(hostPromptQueue, guardedQueue);
+            if (typeof send === 'function')
+                restore('sendMessage', guardedSend);
+        };
+    }, 'agent-teams: retired member guard');
+}

package/lib/index.js

@@ -26,7 +26,7 @@ import { collectArchivedTeamsActivity, collectTeamsActivity } from "./snapshot.j
 import { findTeamByCaptain } from "./state.js";
 import { formatProfilesForPrompt } from "./profiles.js";
 import { qualityPlanningPrompt } from "./quality-gates.js";
-import { authenticatedWebRoutes } from "./web-routes.js";
+import { authenticatedWebRoutes, readJsonRequest, RequestBodyError } from "./web-routes.js";
 /** Web-server service key candidates, newest first. */
 const WEB_SERVER_KEYS = ['webServer', 'httpServer'];
 /** Workspace registry service key candidates, newest first. */
@@ -89,7 +89,7 @@ export function usageSectionText(toolNames, profilesText = '') {
 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. Check status after progress notifications 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.
+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()}
@@ -199,27 +199,13 @@ export function apply(ctx, config) {
                     res.end();
                     return;
                 }
-                let raw = '';
-                try {
-                    raw = await new Promise((resolve, reject) => {
-                        const chunks = [];
-                        req.on('data', (chunk) => { chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)); });
-                        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-                        req.on('error', reject);
-                    });
-                }
-                catch {
-                    res.writeHead(400, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
-                    res.end(JSON.stringify({ error: 'invalid request body' }));
-                    return;
-                }
                 let payload;
                 try {
-                    payload = raw.trim() === '' ? {} : JSON.parse(raw);
+                    payload = await readJsonRequest(req);
                 }
-                catch {
-                    res.writeHead(400, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
-                    res.end(JSON.stringify({ error: 'invalid JSON' }));
+                catch (error) {
+                    res.writeHead(error instanceof RequestBodyError ? error.status : 400, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'invalid request body' }));
                     return;
                 }
                 const sessionId = typeof payload.sessionId === 'string' ? payload.sessionId.trim() : '';
@@ -271,28 +257,10 @@ export function apply(ctx, config) {
                 }
                 let payload;
                 try {
-                    const chunks = [];
-                    const raw = await new Promise((resolve, reject) => {
-                        let size = 0;
-                        req.on('data', (chunk) => {
-                            const part = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-                            size += part.length;
-                            if (size > 1_000_000) {
-                                reject(new Error('request body is too large'));
-                                return;
-                            }
-                            chunks.push(part);
-                        });
-                        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-                        req.on('error', reject);
-                    });
-                    const parsed = raw.trim() === '' ? {} : JSON.parse(raw);
-                    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
-                        throw new Error('body must be an object');
-                    payload = parsed;
+                    payload = await readJsonRequest(req);
                 }
                 catch (error) {
-                    res.writeHead(400, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+                    res.writeHead(error instanceof RequestBodyError ? error.status : 400, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
                     res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'invalid request body' }));
                     return;
                 }

package/lib/members.js

@@ -4,7 +4,7 @@
  *
  * Members are durable continuable subagents of the captain, so a member keeps
  * its conversation across turns and across harness restarts: the captain
- * wakes it with {@link ctx.subagents.followup}, it works through its turn
+ * queues its next turn through {@link deliverToMember}, it works through its turn
  * (updating team state through the `agent_teams_*` tools), and becomes idle
  * again. Its final assistant message is not readable programmatically, so the
  * member persists its report into the captain's mailbox and the task records,
@@ -13,10 +13,12 @@
  */
 import { installModelSelection } from '@deepseek-ai/dsh-agent';
 // Declaration merge only: makes ctx.subagents visible.
-import { foldSubagentDescriptor, SubagentError } from '@deepseek-ai/dsh-subagent';
-import { ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+import { foldSubagentDescriptor } from '@deepseek-ai/dsh-subagent';
+import { createUserMessage, LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { join } from 'node:path';
-import { readRetiredMemberIds, readTeamSync, readTeam, withTeamLock, writeTeam } from "./state.js";
+import { guardSubagentDelivery, installContinuableMemberSetup, queueMemberPrompt, sessionOwnEvents } from "./harness-compat.js";
+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";
 /** Persona snapshot of a profile protocol; the full text lives on team.json. */
 export const PERSONA_PROTOCOL_MAX_CHARS = 400;
@@ -74,6 +76,81 @@ export function selectFallbackRoute(current, fallback, failureCode, alreadySwitc
     }
     return { retry: true, switched: true, selection: fallback };
 }
+/** Deliver a durable member report to the live captain at its next model step. */
+export function steerCaptainReport(captain, from, content) {
+    try {
+        captain.steer(createUserMessage({
+            content: [{ type: 'text', text: `AgentTeams message from member ${from}:\n\n${content}` }],
+            source: { kind: 'plugin', plugin: 'dsh-agent-teams' },
+        }));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Record a final turn failure, never an intermediate request retry. */
+export async function failMemberOpenAttempt(ctx, stateRoot, teamId, memberName, failure, fallbackSession, observed) {
+    const summary = `${failure.message} (code ${failure.code})`;
+    const lockKey = `team:${stateRoot}:${teamId}`;
+    const prepared = await withTeamLock(lockKey, async () => {
+        const team = await readTeam(stateRoot, teamId);
+        if (team === undefined || team.halted === true || team.captainSessionId !== observed.captainSessionId)
+            return;
+        const member = team.members.find(candidate => candidate.name === memberName
+            && candidate.id === observed.memberId && candidate.status !== 'removed');
+        if (member === undefined)
+            return;
+        const task = team.tasks.find(candidate => candidate.assignee === memberName
+            && (candidate.status === 'claimed' || candidate.status === 'in_progress'));
+        // A reassign, completion, or recreated member may win the lock while the
+        // final error is queued. Only the capability observed at that event may fail.
+        if (task?.id !== observed.task?.id || task?.attemptId !== observed.task?.attemptId
+            || task?.attempt !== observed.task?.attempt)
+            return;
+        if (task === undefined && member.status !== 'working')
+            return;
+        if (task !== undefined) {
+            task.status = 'failed';
+            task.output = summary;
+            task.updatedAt = Date.now();
+        }
+        if (ctx.agents.get(brandedSessionId(member.id))?.status !== 'running')
+            member.status = 'idle';
+        const message = {
+            ...createMessage(memberName, CAPTAIN_KEY, task === undefined
+                ? `Member "${memberName}" hit an unrecoverable turn failure: ${summary}. No open attempt was owned.`
+                : `Member "${memberName}" hit an unrecoverable turn failure: ${summary}. Task ${task.id} ("${task.subject}") was marked failed; reassign it or retry when ready.`),
+            deliveryClaimedAt: Date.now(),
+        };
+        await writeTeam(stateRoot, team);
+        await appendMailbox(stateRoot, team.id, CAPTAIN_KEY, message);
+        if (task !== undefined) {
+            appendTeamEvent(ctx, captainSessionOf(ctx, team.captainSessionId, fallbackSession), 'agent-teams/task-updated', {
+                teamId, taskId: task.id, status: task.status, assignee: memberName, output: task.output,
+            });
+        }
+        appendTeamEvent(ctx, captainSessionOf(ctx, team.captainSessionId, fallbackSession), 'agent-teams/message-sent', {
+            teamId: team.id,
+            messageId: message.id,
+            from: memberName,
+            to: CAPTAIN_KEY,
+            content: message.content,
+            ts: message.ts,
+        });
+        return { captainSessionId: team.captainSessionId, message };
+    });
+    if (prepared === undefined)
+        return false;
+    // Use the same lease/acknowledgment contract as send_message, outside the
+    // team lock: steering can synchronously start another agent turn.
+    const captain = ctx.agents.get(brandedSessionId(prepared.captainSessionId));
+    const delivered = captain !== undefined && steerCaptainReport(captain, memberName, prepared.message.content);
+    await withTeamLock(lockKey, () => delivered
+        ? acknowledgeMailbox(stateRoot, teamId, CAPTAIN_KEY, [prepared.message.id])
+        : releaseMailboxDelivery(stateRoot, teamId, CAPTAIN_KEY, [prepared.message.id]));
+    return true;
+}
 async function updateFallbackState(stateRoot, teamId, memberName, fallback, ctx) {
     await withTeamLock(`team:${stateRoot}:${teamId}`, async () => {
         const team = await readTeam(stateRoot, teamId);
@@ -99,12 +176,14 @@ function selectionFromMember(member) {
     const model = (member.activeModel ?? member.model).trim();
     if (provider === '' || model === '')
         return undefined;
-    const reasoningEffort = member.reasoningEffort?.trim();
+    // Effort ids belong to the original model. After a fallback, its own
+    // provider default remains authoritative, including after cold recovery.
+    const reasoningEffort = member.fallbackActive === true ? undefined : member.reasoningEffort?.trim();
     return {
         provider,
         model,
         ...reasoningEffort === undefined || reasoningEffort === '' ? {} : { reasoningEffort },
-        ...member.fallback === undefined ? {} : { fallback: member.fallback },
+        ...member.fallback === undefined || member.fallbackActive === true ? {} : { fallback: member.fallback },
     };
 }
 function modelSelection(selection) {
@@ -189,73 +268,119 @@ export async function resolveMemberLlmSelection(ctx, captain, request, signal) {
  * record. Legacy members without a complete saved route retain Harness's
  * descriptor provider/model behavior.
  */
-export function installMemberSelectionRuntime(ctx, stateDir) {
+export function installMemberSelectionRuntime(ctx, stateDir, onFailureSettled) {
     const pending = new Map();
-    ctx.subagents.registerContinuableSetup((childCtx) => {
+    installContinuableMemberSetup(ctx, (childCtx) => {
         const child = childCtx.agent;
         if (child === undefined)
             return () => undefined;
-        const suffix = child.session.events.slice(child.session.header.seedLength ?? 0);
-        const descriptor = foldSubagentDescriptor(suffix);
+        const descriptor = foldSubagentDescriptor(sessionOwnEvents(child.session));
         if (descriptor?.mode !== 'continuable' || !descriptor.label.startsWith(MEMBER_LABEL_PREFIX)) {
             return () => undefined;
         }
         const parentSessionId = child.session.header.parentSession;
         if (parentSessionId === undefined)
             return () => undefined;
+        const identity = descriptor.label.slice(MEMBER_LABEL_PREFIX.length);
+        const separator = identity.indexOf(':');
+        if (separator < 1 || separator === identity.length - 1)
+            return () => undefined;
+        const teamId = identity.slice(0, separator);
+        const memberName = identity.slice(separator + 1);
+        const workspace = child.session.header.cwd ?? process.cwd();
+        const stateRoot = join(workspace, stateDir);
         const key = pendingSelectionKey(parentSessionId, descriptor.label);
         let selection = pending.get(key);
         if (selection === undefined) {
-            const identity = descriptor.label.slice(MEMBER_LABEL_PREFIX.length);
-            const separator = identity.indexOf(':');
-            if (separator < 1 || separator === identity.length - 1)
-                return () => undefined;
-            const teamId = identity.slice(0, separator);
-            const memberName = identity.slice(separator + 1);
-            const workspace = child.session.header.cwd ?? process.cwd();
-            const team = readTeamSync(join(workspace, stateDir), teamId);
+            const team = readTeamSync(stateRoot, teamId);
             if (team?.captainSessionId !== parentSessionId)
                 return () => undefined;
             const durableMember = team.members.find(member => member.name === memberName);
             selection = selectionFromMember(durableMember);
-            // An old team record has no provider/reasoning snapshot. Its durable
-            // Harness descriptor still restores provider/model, so leave it alone.
-            if (selection === undefined)
-                return () => undefined;
-            if (descriptor.agentProvider !== durableMember?.provider || descriptor.agentModel !== durableMember?.model) {
+            if (selection !== undefined && (descriptor.agentProvider !== durableMember?.provider || descriptor.agentModel !== durableMember?.model)) {
                 throw new Error(`agent-teams: saved model route for member "${memberName}" does not match its subagent descriptor`);
             }
         }
+        let lastFailedTurn;
+        // Harness emits agent/error only after request recovery is exhausted. In
+        // particular, llm-retry's "always" policy calls downstream request-error
+        // listeners before it retries; that waterfall cannot declare a turn dead.
+        const disposeFailure = childCtx.on('agent/error', async (payload) => {
+            if (payload.agent.id !== child.id || payload.turn === lastFailedTurn)
+                return;
+            lastFailedTurn = payload.turn;
+            try {
+                // Capture the attempt synchronously at the event, before any lock wait
+                // can let a captain reassign it or replace the member/team generation.
+                const snapshot = readTeamSync(stateRoot, teamId);
+                if (snapshot?.captainSessionId !== parentSessionId)
+                    return;
+                const member = snapshot.members.find(item => item.id === child.id && item.name === memberName && item.status !== 'removed');
+                if (member === undefined)
+                    return;
+                const task = snapshot.tasks.find(item => item.assignee === memberName
+                    && (item.status === 'claimed' || item.status === 'in_progress'));
+                const failure = payload.error instanceof LlmError ? payload.error.failure : {
+                    code: 'UNKNOWN',
+                    message: payload.error instanceof Error ? payload.error.message : String(payload.error),
+                };
+                const recorded = await failMemberOpenAttempt(ctx, stateRoot, teamId, memberName, failure, child.session, {
+                    captainSessionId: parentSessionId, memberId: child.id, task,
+                });
+                if (!recorded)
+                    return;
+                // The final-error event precedes driver quiescence. Observe the real
+                // lifecycle and kick explicitly even if its idle event was missed.
+                // Never force an active Agent's status to idle or retry the failed task.
+                await child.whenIdle();
+                await withTeamLock(`team:${stateRoot}:${teamId}`, async () => {
+                    const team = await readTeam(stateRoot, teamId);
+                    const current = team?.members.find(item => item.id === child.id && item.name === memberName && item.status !== 'removed');
+                    if (team?.captainSessionId !== parentSessionId || current === undefined || child.status !== 'idle')
+                        return;
+                    if (current.status !== 'idle') {
+                        current.status = 'idle';
+                        await writeTeam(stateRoot, team);
+                    }
+                });
+                await onFailureSettled?.(workspace, teamId, memberName);
+            }
+            catch (error) {
+                ctx.logger.warn(`agent-teams: failed to record member turn failure: ${String(error)}`);
+            }
+        });
+        // Legacy teams still need failure reporting even without a saved route.
+        if (selection === undefined)
+            return disposeFailure;
         const selectionRef = { current: modelSelection(selection), assembled: undefined };
         const disposeSelection = installModelSelection(childCtx, selectionRef);
         const fallback = selection.fallback;
-        if (fallback === undefined)
-            return disposeSelection;
         let switched = false;
-        const disposeFallback = childCtx.on('agent/request-error', async (payload) => {
-            if (payload.agent.id !== child.id)
-                return undefined;
+        const disposeFallback = childCtx.on('agent/request-error', async (payload, next) => {
+            if (payload.agent.id !== child.id || payload.signal.aborted)
+                return next();
             const transition = selectFallbackRoute(selectionRef.current ?? { provider: selection.provider, model: selection.model }, fallback, payload.failure.code, switched);
-            if (!transition.retry)
-                return undefined;
-            switched = transition.switched;
-            selectionRef.current = transition.selection;
-            const workspace = child.session.header.cwd ?? process.cwd();
-            const identity = descriptor.label.slice(MEMBER_LABEL_PREFIX.length);
-            const separator = identity.indexOf(':');
-            if (separator > 0) {
-                const teamId = identity.slice(0, separator);
-                const memberName = identity.slice(separator + 1);
-                void updateFallbackState(join(workspace, stateDir), teamId, memberName, fallback, ctx).catch((error) => {
+            // selectFallbackRoute only retries when a fallback route exists; the
+            // explicit guard narrows that fact for the compiler.
+            if (fallback !== undefined && transition.retry) {
+                switched = transition.switched;
+                selectionRef.current = transition.selection;
+                // Request recovery repeats buildRequest inside the current step; it
+                // does not re-run prompt assembly. Override that captured route too,
+                // otherwise the authorized retry would hit the failed primary again.
+                selectionRef.assembled = transition.selection;
+                await updateFallbackState(stateRoot, teamId, memberName, fallback, ctx).catch((error) => {
                     ctx.logger.warn(`agent-teams: failed to persist fallback route: ${String(error)}`);
                 });
+                ctx.logger.warn(`agent-teams: member ${child.id} switching to fallback ${fallback.provider}/${fallback.model} after ${payload.failure.code}`);
+                return { kind: 'retry' };
             }
-            ctx.logger.warn(`agent-teams: member ${child.id} switching to fallback ${fallback.provider}/${fallback.model} after ${payload.failure.code}`);
-            return { kind: 'retry' };
+            return next();
         });
         return () => {
             disposeFallback();
             disposeSelection();
+            disposeFailure();
         };
     });
     return {
@@ -387,6 +512,9 @@ export async function spawnMember(ctx, config, selections, llmSelection, captain
             agentOptions: {
                 provider: llmSelection.provider,
                 model: llmSelection.model,
+                ...llmSelection.reasoningEffort === undefined
+                    ? {}
+                    : { reasoningEffort: ReasoningEffortId(llmSelection.reasoningEffort) },
             },
             ...config.maxDepth !== undefined ? { maxDepth: config.maxDepth } : {},
         },
@@ -413,14 +541,11 @@ export async function spawnMember(ctx, config, selections, llmSelection, captain
  */
 export async function deliverToMember(ctx, captain, childId, text, signal) {
     try {
-        await ctx.subagents.followup(captain, brandedSessionId(childId), [{ type: 'text', text }], {
-            source: { kind: 'plugin', plugin: 'dsh-agent-teams' },
-            signal,
-        });
+        await queueMemberPrompt(ctx.subagents, captain, brandedSessionId(childId), [{ type: 'text', text }], signal);
         return true;
     }
     catch (error) {
-        ctx.logger.warn(`agent-teams: followup to member ${childId} failed: ${String(error)}`);
+        ctx.logger.warn(`agent-teams: prompt delivery to member ${childId} failed: ${String(error)}`);
         return false;
     }
 }
@@ -444,30 +569,18 @@ export function interruptMember(ctx, captain, childId) {
  *
  * Upstream `interrupt()` deliberately preserves continuable sessions and the
  * upstream seam exposes no targeted forget/retire method. The durable
- * AgentTeams index therefore rejects `followup()` before it can cold-resume a
+ * AgentTeams index therefore rejects every inbox delivery before it can cold-resume a
  * retired member. Catalog rows deliberately remain discoverable: Harness rc.8
  * uses the direct-child catalog to authorize historical transcript reads and
  * `openSubagent()`, so filtering those rows would make an archived member's
  * persisted conversation inaccessible. Exact ids keep unrelated subagents
- * untouched while the followup boundary still prevents further model turns.
+ * untouched while the delivery boundary still prevents further model turns.
  */
 export function installRetiredMemberGuard(ctx, stateDir) {
-    const runtime = ctx.subagents;
-    ctx.effect(() => {
-        const followup = runtime.followup;
-        const guardedFollowup = async (parent, childId, content, options) => {
-            const retired = await readRetiredMemberIds(join(parent.session.header.cwd ?? process.cwd(), stateDir));
-            if (retired.has(childId)) {
-                throw new SubagentError(`AgentTeams member "${childId}" was retired and cannot be resumed`, 'NOT_RESUMABLE');
-            }
-            return followup.call(runtime, parent, childId, content, options);
-        };
-        runtime.followup = guardedFollowup;
-        return () => {
-            if (runtime.followup === guardedFollowup)
-                runtime.followup = followup;
-        };
-    }, 'agent-teams: retired member guard');
+    guardSubagentDelivery(ctx, async (parent, childId) => {
+        const retired = await readRetiredMemberIds(join(parent.session.header.cwd ?? process.cwd(), stateDir));
+        return retired.has(childId);
+    });
 }
 /**
  * Snapshot the real driver activity for durable member ids.

package/lib/quality-gates.js

@@ -600,6 +600,51 @@ export function isCommandResult(value) {
         && (value['exitCode'] === undefined || (Number.isSafeInteger(value['exitCode'])))
         && (value['evidence'] === undefined || typeof value['evidence'] === 'string');
 }
+// Optional fields whose persisted values must be non-empty when present
+// (mirrors the checks in hasValidQualityTaskFields). Some models materialize
+// optional tool parameters as "" instead of omitting them (e.g. GPT-5.6
+// sending reviewedTaskId:"" or profile:""), which would otherwise be written
+// to team.json and then brick the whole team state on reload.
+const BLANK_SENSITIVE_STRING_FIELDS = ['objective', 'reviewedTaskId', 'sourceTaskId'];
+const BLANK_SENSITIVE_STRING_LIST_FIELDS = [
+    'inScope',
+    'outOfScope',
+    'acceptance',
+    'verify',
+    'deliverables',
+    'nonGoals',
+    'changedPaths',
+    'sourceFindingIds',
+    'coverageOf',
+];
+/**
+ * Normalize blank optional task fields to omitted ("blank means absent").
+ * Blank string scalars are deleted; string lists have blank entries filtered
+ * out, and a list that only contained blanks is omitted entirely. Non-blank
+ * values and every other field are passed through untouched, so durable-state
+ * validation stays strict.
+ */
+export function normalizeBlankOptionalTaskFields(task) {
+    const next = { ...task };
+    for (const key of BLANK_SENSITIVE_STRING_FIELDS) {
+        const value = next[key];
+        if (typeof value === 'string' && value.trim() === '')
+            delete next[key];
+    }
+    for (const key of BLANK_SENSITIVE_STRING_LIST_FIELDS) {
+        const value = next[key];
+        if (!Array.isArray(value))
+            continue;
+        const kept = value.filter((item) => !(typeof item === 'string' && item.trim() === ''));
+        if (kept.length === value.length)
+            continue;
+        if (kept.length === 0)
+            delete next[key];
+        else
+            next[key] = kept;
+    }
+    return next;
+}
 export function hasValidQualityTaskFields(value) {
     if (value['kind'] !== undefined && !TASK_KINDS.includes(value['kind']))
         return false;