@nanmicoder/dsh-agent-teams 0.1.12 → 0.1.14

package/lib/scheduler.js

@@ -5,12 +5,89 @@
  * continuable agents instead expose explicit idle/running edges, so this
  * scheduler closes the same loop without keeping a polling turn alive: every
  * idle edge and every task-graph mutation attempts one atomic claim and wakes
- * the selected durable member.
+ * the selected durable member. A resident member that becomes idle while it
+ * still owns an open attempt is parked: only an explicit captain reassignment
+ * may rotate that capability. Automatic retry is reserved for cold recovery,
+ * when the durable owner is no longer resident in the live Agent registry.
  * @module dsh-agent-teams/scheduler
  */
 import { join } from 'node:path';
 import { deliverToMember } from "./members.js";
-import { acknowledgeMailbox, beginTaskAttempt, claimMailboxDelivery, findTeamByParticipant, readTeam, readUnreadMailbox, releaseMailboxDelivery, unsatisfiedDependencies, withTeamLock, writeTeam, } from "./state.js";
+import { acknowledgeMailbox, beginTaskAttempt, CAPTAIN_KEY, claimMailboxDelivery, findTeamByParticipant, invalidateTaskAttempt, readTeam, readUnreadMailbox, releaseMailboxDelivery, unsatisfiedDependencies, withTeamLock, writeTeam, } from "./state.js";
+/** Per-dependency output cap in the assignment prompt. */
+export const DEPENDENCY_OUTPUT_MAX_CHARS = 2_000;
+/** Combined dependency-output budget in the assignment prompt. */
+export const DEPENDENCY_OUTPUTS_TOTAL_MAX_CHARS = 12_000;
+function taskProfileSeedId(task) {
+    const seed = task.profileSeedId?.trim();
+    return seed === undefined || seed === '' ? undefined : seed;
+}
+function teamProfileProtocol(team) {
+    return team.profile?.protocol;
+}
+/**
+ * Recursively collect `status=completed` ancestors of `taskId` in topological
+ * order (dependencies before dependents). Cycles stop that branch only.
+ */
+export function collectCompletedDependencyOutputs(tasks, taskId, warn) {
+    const byId = new Map(tasks.map(task => [task.id, task]));
+    const visiting = new Set();
+    const visited = new Set();
+    const ordered = [];
+    const walk = (id) => {
+        if (visiting.has(id)) {
+            warn?.(`agent-teams: dependency cycle involving "${id}" while collecting outputs; stopping this branch`);
+            return;
+        }
+        if (visited.has(id))
+            return;
+        visiting.add(id);
+        const task = byId.get(id);
+        if (task !== undefined) {
+            for (const dependency of task.dependencies)
+                walk(dependency);
+            if (id !== taskId)
+                ordered.push(task);
+        }
+        visiting.delete(id);
+        visited.add(id);
+    };
+    walk(taskId);
+    return ordered
+        .filter(task => task.status === 'completed')
+        .map((task) => {
+        const profileSeedId = taskProfileSeedId(task);
+        return {
+            id: task.id,
+            subject: task.subject,
+            ...profileSeedId === undefined ? {} : { profileSeedId },
+            ...task.output === undefined ? {} : { output: task.output },
+        };
+    });
+}
+/** Format completed-dependency outputs with per-item and total truncation. */
+export function formatDependencyOutputs(items) {
+    if (items.length === 0)
+        return '(none)';
+    const formatted = items.map((item) => {
+        const seed = item.profileSeedId === undefined ? '' : ` [${item.profileSeedId}]`;
+        const raw = item.output === undefined || item.output === ''
+            ? '(no output recorded)'
+            : item.output;
+        const truncated = raw.length > DEPENDENCY_OUTPUT_MAX_CHARS;
+        const body = truncated ? `${raw.slice(0, DEPENDENCY_OUTPUT_MAX_CHARS)} [truncated]` : raw;
+        return `- ${item.id}${seed} ${item.subject}:\n  ${body}`;
+    });
+    let selected = formatted;
+    while (selected.length > 1 && selected.join('\n').length > DEPENDENCY_OUTPUTS_TOTAL_MAX_CHARS) {
+        selected = selected.slice(1);
+    }
+    const last = selected[0];
+    if (selected.length === 1 && last !== undefined && last.length > DEPENDENCY_OUTPUTS_TOTAL_MAX_CHARS) {
+        selected = [`${last.slice(0, DEPENDENCY_OUTPUTS_TOTAL_MAX_CHARS)} [truncated]`];
+    }
+    return selected.join('\n');
+}
 function stateRootOf(workspace, config) {
     return join(workspace, config.stateDir);
 }
@@ -22,8 +99,11 @@ function liveCaptain(ctx, captainSessionId, supplied) {
         return supplied;
     return ctx.agents.get(captainSessionId);
 }
+function liveMember(ctx, member) {
+    return ctx.agents.get(member.id);
+}
 function isMemberAvailable(ctx, member) {
-    const live = ctx.agents.get(member.id);
+    const live = liveMember(ctx, member);
     return live === undefined || live.status === 'idle';
 }
 function ownedOpenTask(tasks, memberName) {
@@ -37,15 +117,54 @@ function nextReadyTask(tasks, memberName) {
     return ready.find(task => task.assignee === memberName)
         ?? ready.find(task => task.assignee === undefined);
 }
-function assignmentPrompt(ticket, stateDir, teamId) {
+export function assignmentPrompt(ticket, stateDir, teamId) {
     const description = ticket.description === undefined ? '' : `\n\n${ticket.description}`;
+    const seed = ticket.profileSeedId === undefined ? '' : ` [${ticket.profileSeedId}]`;
+    const goal = ticket.teamDescription?.trim() || '(not provided)';
+    const protocol = ticket.profileProtocol?.trim() || '(none)';
+    const executionPrompt = ticket.executionPrompt?.trim();
+    const kind = ticket.kind?.trim() || 'work';
+    const contract = [
+        `Kind: ${kind}${ticket.round === undefined ? '' : ` (round ${ticket.round})`}`,
+        ticket.objective === undefined || ticket.objective === '' ? '' : `Objective: ${ticket.objective}`,
+        ticket.inScope === undefined || ticket.inScope.length === 0 ? '' : `In scope: ${ticket.inScope.join(', ')}`,
+        ticket.outOfScope === undefined || ticket.outOfScope.length === 0 ? '' : `Out of scope: ${ticket.outOfScope.join(', ')}`,
+        ticket.acceptance === undefined || ticket.acceptance.length === 0 ? '' : `Acceptance: ${ticket.acceptance.join('; ')}`,
+        ticket.verify === undefined || ticket.verify.length === 0 ? '' : `Verify: ${ticket.verify.join('; ')}`,
+        ticket.reviewedTaskId === undefined ? '' : `Reviewed task: ${ticket.reviewedTaskId}`,
+    ].filter((line) => line !== '').join('\n');
+    const structuredCompletion = ['implementation', 'repair', 'verification', 'integration'].includes(kind)
+        ? `
+Structured completion payload (keep these arrays in contract order):
+acceptanceResults: ${JSON.stringify((ticket.acceptance ?? []).map((criterion) => ({ criterion, status: 'passed', evidence: '<what proved it>' })))}
+commandsRun: ${JSON.stringify((ticket.verify ?? []).map((command) => ({ command, status: 'passed', exitCode: 0, evidence: '<observed result>' })))}
+${kind === 'implementation' || kind === 'repair' ? 'changedPaths: list the actual workspace-relative POSIX paths you changed.\n' : ''}`
+        : '';
     return `AgentTeams automatic task assignment from the shared task list.
 
-Task: ${ticket.taskId} — ${ticket.subject}${description}
+You are executing as configured member "${ticket.memberName}".
+Do not start a teammate's assigned task.
+
+Team goal:
+${goal}
+
+Profile protocol:
+${protocol}
+${executionPrompt === undefined || executionPrompt === '' ? '' : `
+Execution guidance:
+${executionPrompt}
+`}
+Completed dependency results:
+${formatDependencyOutputs(ticket.dependencyOutputs)}
+
+Task: ${ticket.taskId}${seed} — ${ticket.subject}${description}
+${contract === '' ? '' : `\nContract:\n${contract}\n`}
+${structuredCompletion}
 Attempt: ${ticket.attempt}
 Attempt id: ${ticket.attemptId}
 
-Call agent_teams_claim_task for ${ticket.taskId}; it will return this same attempt_id. Include attempt_id=${ticket.attemptId} in every agent_teams_update_task call. If it is rejected as stale, stop work because the task was reassigned. Work only this task in this turn, report the result to the captain, then become idle so the scheduler can select your next ready task.
+Call agent_teams_claim_task for ${ticket.taskId}; it will return this same attempt_id. Include attempt_id=${ticket.attemptId} in every agent_teams_update_task call. If it is rejected as stale, stop work because the task was reassigned. claimed cannot jump to completed. Mark in_progress first, then completed or failed. Include attempt_id on every update. Then send_message to captain and become idle.
+When finishing: use status=completed only when the task's success criteria are satisfied; use status=failed when blocking findings or validation failures mean downstream work must not proceed; include a concise output in either case. Quality kinds must submit structured fields: review/requirements need verdict=pass to complete (needs_revision/reject must fail with findings); implementation/repair/verification/integration need acceptanceResults and commandsRun, while implementation/repair also need in-scope changedPaths. Use status values "passed" or "failed" inside those arrays. After the work and verification finish, call agent_teams_update_task immediately; do not wait for captain confirmation and do not continue exploring. Do not approve your own implementation. Mail is not a formal next review. Treat the dependency results above as source material. Do not ignore them. Work only this task and only its in-scope paths in this turn.
 
 State policy: ${stateDir}/${teamId}/ is read-only diagnostics; mutate team state only through agent_teams_* tools.`;
 }
@@ -59,6 +178,13 @@ function fallbackMailboxPrompt(messages) {
 /** Install one scheduler and its member activity observer. */
 export function installTeamScheduler(ctx, config) {
     const memberQueues = new Map();
+    // An idle edge in this process proves that the resident member ended its
+    // turn while the current attempt was still open. Remember that capability
+    // even after Harness disposes the continuable AgentHandle: later status or
+    // graph kicks must keep it parked. A cold process starts with an empty map,
+    // so durable open attempts are still recovered after restart.
+    const parkedAttempts = new Map();
+    const memberQueueKey = (stateRoot, teamId, memberName) => (`${stateRoot}\u0000${teamId}\u0000${memberName}`);
     const serializeMember = async (key, operation) => {
         const previous = memberQueues.get(key) ?? Promise.resolve();
         let release;
@@ -79,7 +205,7 @@ export function installTeamScheduler(ctx, config) {
         async kickTeam(workspace, teamId, suppliedCaptain) {
             const stateRoot = stateRootOf(workspace, config);
             const team = await readTeam(stateRoot, teamId);
-            if (team === undefined)
+            if (team === undefined || team.halted === true || team.phase === 'staged')
                 return;
             const captain = liveCaptain(ctx, team.captainSessionId, suppliedCaptain);
             if (captain === undefined)
@@ -92,10 +218,10 @@ export function installTeamScheduler(ctx, config) {
         },
         async kickMember(workspace, teamId, memberName, suppliedCaptain) {
             const stateRoot = stateRootOf(workspace, config);
-            const queueKey = `${stateRoot}\u0000${teamId}\u0000${memberName}`;
+            const queueKey = memberQueueKey(stateRoot, teamId, memberName);
             await serializeMember(queueKey, async () => {
                 let team = await readTeam(stateRoot, teamId);
-                if (team === undefined)
+                if (team === undefined || team.halted === true || team.phase === 'staged')
                     return;
                 const captain = liveCaptain(ctx, team.captainSessionId, suppliedCaptain);
                 if (captain === undefined)
@@ -119,17 +245,25 @@ export function installTeamScheduler(ctx, config) {
                 }
                 const ticket = await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
                     const fresh = await readTeam(stateRoot, team.id);
-                    if (fresh === undefined)
+                    if (fresh === undefined || fresh.halted === true || fresh.phase === 'staged')
                         return undefined;
                     const currentMember = fresh.members.find(candidate => candidate.name === memberName && candidate.status !== 'removed');
                     if (currentMember === undefined || currentMember.id === '' || !isMemberAvailable(ctx, currentMember))
                         return undefined;
-                    // An idle/ready member that still owns an open task lost the turn
-                    // that was executing it (model stopped early, interrupt settlement,
-                    // or process restart). Retry that task with a fresh capability
-                    // instead of permanently treating the durable claim as "busy".
-                    const task = ownedOpenTask(fresh.tasks, currentMember.name)
-                        ?? nextReadyTask(fresh.tasks, currentMember.name);
+                    const owned = ownedOpenTask(fresh.tasks, currentMember.name);
+                    // A resident idle member can intentionally leave an attempt open
+                    // while waiting for guidance, or because the user paused its turn.
+                    // Re-dispatching here would revoke still-valid work on every idle
+                    // edge and every status kick. The idle observer remembers that exact
+                    // capability across normal continuable disposal; only an unobserved
+                    // durable capability (cold process recovery) or a legacy open task
+                    // with no capability is retried.
+                    const parkedAttemptId = parkedAttempts.get(currentMember.id);
+                    const recoverOwned = owned !== undefined
+                        && (owned.attemptId === undefined || owned.attemptId !== parkedAttemptId);
+                    const task = recoverOwned ? owned : owned === undefined
+                        ? nextReadyTask(fresh.tasks, currentMember.name)
+                        : undefined;
                     if (task === undefined) {
                         if (currentMember.status !== 'idle') {
                             currentMember.status = 'idle';
@@ -139,8 +273,11 @@ export function installTeamScheduler(ctx, config) {
                     }
                     const previousAssignee = task.assignee;
                     const attemptId = beginTaskAttempt(task, currentMember.name);
+                    parkedAttempts.delete(currentMember.id);
                     currentMember.status = 'working';
                     await writeTeam(stateRoot, fresh);
+                    const profileSeedId = taskProfileSeedId(task);
+                    const protocol = teamProfileProtocol(fresh);
                     return {
                         taskId: task.id,
                         memberName: currentMember.name,
@@ -150,6 +287,21 @@ export function installTeamScheduler(ctx, config) {
                         previousAssignee,
                         subject: task.subject,
                         description: task.description,
+                        teamDescription: fresh.description,
+                        ...protocol === undefined ? {} : { profileProtocol: protocol },
+                        ...profileSeedId === undefined ? {} : { profileSeedId },
+                        ...fresh.profile?.executionPrompt === undefined && config.executionPrompt === undefined
+                            ? {}
+                            : { executionPrompt: fresh.profile?.executionPrompt ?? config.executionPrompt },
+                        kind: task.kind ?? 'work',
+                        ...task.round === undefined ? {} : { round: task.round },
+                        ...task.objective === undefined ? {} : { objective: task.objective },
+                        ...task.inScope === undefined ? {} : { inScope: task.inScope },
+                        ...task.outOfScope === undefined ? {} : { outOfScope: task.outOfScope },
+                        ...task.acceptance === undefined ? {} : { acceptance: task.acceptance },
+                        ...task.verify === undefined ? {} : { verify: task.verify },
+                        ...task.reviewedTaskId === undefined ? {} : { reviewedTaskId: task.reviewedTaskId },
+                        dependencyOutputs: collectCompletedDependencyOutputs(fresh.tasks, task.id, (message) => ctx.logger.warn(message)),
                     };
                 });
                 if (ticket === undefined)
@@ -184,17 +336,62 @@ export function installTeamScheduler(ctx, config) {
         const workspace = agent.session.header.cwd ?? process.cwd();
         const stateRoot = stateRootOf(workspace, config);
         const located = await findTeamByParticipant(stateRoot, agent.id);
-        if (located === undefined || located.captainSessionId === agent.id)
+        if (located === undefined) {
+            parkedAttempts.delete(agent.id);
             return;
+        }
+        if (located.captainSessionId === agent.id) {
+            // Captain takeover is scoped to the captain's current turn. Unlike a
+            // durable member, the captain has no scheduler lane that can resume an
+            // abandoned attempt later. Returning unfinished captain-owned work to
+            // the shared pool on the idle edge prevents it from becoming a
+            // permanently parked `claimed` task after the captain answers, is
+            // interrupted, or the user switches conversations.
+            if (status === 'running')
+                return;
+            let requeued = false;
+            await withTeamLock(teamLockKey(stateRoot, located.id), async () => {
+                const fresh = await readTeam(stateRoot, located.id);
+                if (fresh === undefined || fresh.captainSessionId !== agent.id)
+                    return;
+                for (const task of fresh.tasks) {
+                    if (task.assignee !== CAPTAIN_KEY
+                        || task.status === 'completed'
+                        || task.status === 'failed'
+                        || task.status === 'cancelled')
+                        continue;
+                    invalidateTaskAttempt(task);
+                    task.reassigning = false;
+                    requeued = true;
+                }
+                if (requeued)
+                    await writeTeam(stateRoot, fresh);
+            });
+            if (requeued)
+                await runtime.kickTeam(workspace, located.id, agent);
+            return;
+        }
         const member = located.members.find(candidate => candidate.id === agent.id && candidate.status !== 'removed');
-        if (member === undefined)
+        if (member === undefined) {
+            parkedAttempts.delete(agent.id);
             return;
+        }
         await withTeamLock(teamLockKey(stateRoot, located.id), async () => {
             const fresh = await readTeam(stateRoot, located.id);
             const current = fresh?.members.find(candidate => candidate.id === agent.id && candidate.status !== 'removed');
             if (fresh === undefined || current === undefined)
                 return;
             const next = status === 'running' ? 'working' : 'idle';
+            if (next === 'idle') {
+                const owned = ownedOpenTask(fresh.tasks, current.name);
+                if (owned?.attemptId === undefined)
+                    parkedAttempts.delete(agent.id);
+                else
+                    parkedAttempts.set(agent.id, owned.attemptId);
+            }
+            else {
+                parkedAttempts.delete(agent.id);
+            }
             if (current.status === next)
                 return;
             current.status = next;

package/lib/snapshot.js

@@ -19,6 +19,16 @@ function currentTaskOf(memberName, tasks) {
     }
     return '';
 }
+/** Compact `provider/model` route for the activity panel, or just the model. */
+export function memberModelRoute(member) {
+    if (member === undefined)
+        return '';
+    const provider = member.provider?.trim() ?? '';
+    const model = member.model?.trim() ?? '';
+    if (provider !== '' && model !== '')
+        return `${provider}/${model}`;
+    return model;
+}
 /**
  * Assemble one team snapshot from its durable files plus live activity.
  * @param ctx - the plugin context (injects `subagents`, used for activity).
@@ -53,6 +63,10 @@ export async function assembleTeamSnapshot(ctx, stateRoot, workspace, state, opt
             id: member.id,
             name: member.name,
             role: member.role ?? '',
+            provider: member.provider?.trim() ?? '',
+            model: member.model?.trim() ?? '',
+            reasoningEffort: member.reasoningEffort?.trim() ?? '',
+            executionPrompt: member.executionPrompt ?? '',
             status: member.status,
             activity: options.historic === true
                 ? 'idle'
@@ -62,7 +76,7 @@ export async function assembleTeamSnapshot(ctx, stateRoot, workspace, state, opt
                         : activity.get(member.id) === 'idle' || activity.get(member.id) === 'ready'
                             ? 'idle'
                             : 'unknown')
-                    : 'unknown',
+                    : state.phase === 'staged' ? 'idle' : 'unknown',
             progress: owned.length === 0 ? 0 : Math.round((done / owned.length) * 100),
             done,
             total: owned.length,
@@ -77,15 +91,25 @@ export async function assembleTeamSnapshot(ctx, stateRoot, workspace, state, opt
         name: state.name,
         ...state.description !== undefined ? { description: state.description } : {},
         captainSessionId: state.captainSessionId,
+        phase: state.phase ?? 'running',
+        ...state.phase === 'staged'
+            ? { planReviewState: state.planReviewState ?? 'awaiting_review' }
+            : {},
+        ...state.halted === true ? { halted: true } : {},
         members,
         tasks: tasks.map((task) => ({
             id: task.id,
             subject: task.subject,
+            description: task.description ?? '',
             status: task.status,
             state: taskVisualState(task.status, task.dependencies, tasks),
             assignee: task.assignee ?? '',
+            model: memberModelRoute(roster.find((member) => member.name === task.assignee)),
             dependencies: task.dependencies,
             depth: depths.get(task.id) ?? 0,
+            ...task.kind === undefined ? {} : { kind: task.kind },
+            ...task.round === undefined ? {} : { round: task.round },
+            ...task.verdict === undefined ? {} : { verdict: task.verdict },
         })),
         messageCount: captainInbox.length
             + members.reduce((count, member) => count + member.unread, 0),

package/lib/state.js

@@ -16,6 +16,9 @@ import { createHash, randomUUID } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { TERMINAL_TASK_STATUSES } from "./types.js";
+import { hasValidQualityTaskFields, isReviewPolicy } from "./quality-gates.js";
+export { buildCoverageMatrix, canDeclareDelivery, classifyChangedPath, collectChangedPaths, defaultQualityDeliveryGraph, describeQualityLoop, evaluateQualityCompletion, hasValidQualityTaskFields, isQualityKind, pathMatchesScope, planQualityFollowUp, qualityPlanningPrompt, resumeTeamState, sanitizeReviewAcceptance, sanitizeReviewObjective, taskKindOf, validateCreateTask, } from "./quality-gates.js";
 /** Mailbox key of the captain. */
 export const CAPTAIN_KEY = 'captain';
 /** A crashed live-delivery attempt becomes retryable after this interval. */
@@ -137,6 +140,18 @@ export function beginTaskAttempt(task, assignee) {
  * Revoke the current worker immediately. Clearing its capability makes old
  * updates stale; a separate handoff generation serializes async quiescence.
  */
+/** Cancel one unfinished task without returning it to the ready pool. */
+export function cancelUnfinishedTask(task, output) {
+    if (TERMINAL_TASK_STATUSES.includes(task.status))
+        return;
+    task.status = 'cancelled';
+    task.attemptId = undefined;
+    task.handoffId = undefined;
+    task.reassigning = false;
+    if (output !== undefined)
+        task.output = output;
+    task.updatedAt = Date.now();
+}
 export function invalidateTaskAttempt(task, nextAssignee, reassigning = false) {
     task.attemptId = undefined;
     task.handoffId = randomUUID();
@@ -165,10 +180,11 @@ export async function readTeam(stateRoot, teamId) {
     try {
         const raw = await readFile(join(stateRoot, teamId, 'team.json'), 'utf8');
         const value = JSON.parse(stripLeadingBom(raw));
-        if (!isTeamState(value, teamId)) {
+        const team = coerceTeamState(value, teamId);
+        if (team === undefined) {
             throw new Error(`invalid AgentTeams state in team "${teamId}"`);
         }
-        return value;
+        return team;
     }
     catch (error) {
         if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
@@ -190,10 +206,11 @@ export function readTeamSync(stateRoot, teamId) {
     try {
         const raw = readFileSync(join(stateRoot, teamId, 'team.json'), 'utf8');
         const value = JSON.parse(stripLeadingBom(raw));
-        if (!isTeamState(value, teamId)) {
+        const team = coerceTeamState(value, teamId);
+        if (team === undefined) {
             throw new Error(`invalid AgentTeams state in team "${teamId}"`);
         }
-        return value;
+        return team;
     }
     catch (error) {
         if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
@@ -549,14 +566,82 @@ function isTeamMember(value) {
         && isOptionalString(value['provider'])
         && isOptionalString(value['model'])
         && isOptionalString(value['reasoningEffort'])
+        && isOptionalString(value['activeProvider'])
+        && isOptionalString(value['activeModel'])
+        && (value['executionPrompt'] === undefined || typeof value['executionPrompt'] === 'string')
+        && (value['fallback'] === undefined || (isRecord(value['fallback']) && typeof value['fallback']['provider'] === 'string' && typeof value['fallback']['model'] === 'string'))
+        && (value['fallbackActive'] === undefined || typeof value['fallbackActive'] === 'boolean')
         && isFiniteNumber(value['joinedAt'])
         && (value['status'] === 'idle' || value['status'] === 'working' || value['status'] === 'removed');
 }
 /** Validate one task record at the durable JSON boundary. */
-function isTeamTask(value) {
+function isTeamProfileSnapshot(value) {
+    return isRecord(value)
+        && typeof value['name'] === 'string'
+        && value['name'].trim() !== ''
+        && isOptionalString(value['description'])
+        && isOptionalString(value['protocol'])
+        && (value['executionPrompt'] === undefined || typeof value['executionPrompt'] === 'string')
+        && (value['fallback'] === undefined || (isRecord(value['fallback']) && typeof value['fallback']['provider'] === 'string' && typeof value['fallback']['model'] === 'string'))
+        && (value['taskPlanning'] === undefined || value['taskPlanning'] === 'captain' || value['taskPlanning'] === 'seed')
+        && (value['reviewPolicy'] === undefined || isReviewPolicy(value['reviewPolicy']));
+}
+function coerceProfileSnapshot(value) {
+    if (typeof value === 'string') {
+        const name = value.trim();
+        return name === '' ? undefined : { name };
+    }
+    if (!isRecord(value))
+        return undefined;
+    if (!isTeamProfileSnapshot(value))
+        return undefined;
+    return {
+        name: value.name.trim(),
+        ...value.description === undefined ? {} : { description: value.description },
+        ...value.protocol === undefined ? {} : { protocol: value.protocol },
+        ...value.taskPlanning === undefined ? {} : { taskPlanning: value.taskPlanning },
+    };
+}
+function coerceTeamState(value, expectedId) {
+    if (!isRecord(value))
+        return undefined;
+    if (value['profile'] !== undefined && !isTeamProfileSnapshot(value['profile']) && typeof value['profile'] !== 'string') {
+        const next = { ...value };
+        delete next['profile'];
+        value = next;
+    }
+    else if (typeof value['profile'] === 'string') {
+        const upgraded = coerceProfileSnapshot(value['profile']);
+        value = upgraded === undefined
+            ? (() => {
+                const next = { ...value };
+                delete next['profile'];
+                return next;
+            })()
+            : { ...value, profile: upgraded };
+    }
+    if (!isRecord(value) || !Array.isArray(value['tasks'])) {
+        return isTeamState(value, expectedId) ? value : undefined;
+    }
+    const tasks = value['tasks'].map((task) => {
+        if (!isRecord(task))
+            return task;
+        if (task['profileSeedId'] !== undefined && (typeof task['profileSeedId'] !== 'string' || task['profileSeedId'].trim() === '')) {
+            const next = { ...task };
+            delete next['profileSeedId'];
+            return next;
+        }
+        return task;
+    });
+    const coerced = { ...value, tasks };
+    return isTeamState(coerced, expectedId) ? coerced : undefined;
+}
+export function isTeamTask(value) {
     if (!isRecord(value))
         return false;
     return typeof value['id'] === 'string'
+        && isOptionalString(value['profileSeedId'])
+        && (value['profileSeedId'] === undefined || value['profileSeedId'].trim() !== '')
         && typeof value['subject'] === 'string'
         && isOptionalString(value['description'])
         && (value['status'] === 'pending'
@@ -575,7 +660,8 @@ function isTeamTask(value) {
         && isOptionalString(value['handoffId'])
         && (value['reassigning'] === undefined || typeof value['reassigning'] === 'boolean')
         && isFiniteNumber(value['createdAt'])
-        && isFiniteNumber(value['updatedAt']);
+        && isFiniteNumber(value['updatedAt'])
+        && hasValidQualityTaskFields(value);
 }
 /** Validate the full team record before it can participate in authorization. */
 function isTeamState(value, expectedId) {
@@ -585,6 +671,7 @@ function isTeamState(value, expectedId) {
         && typeof value['name'] === 'string'
         && value['name'].trim() !== ''
         && isOptionalString(value['description'])
+        && (value['profile'] === undefined || isTeamProfileSnapshot(value['profile']))
         && typeof value['captainSessionId'] === 'string'
         && value['captainSessionId'] !== ''
         && isFiniteNumber(value['createdAt'])
@@ -593,18 +680,32 @@ function isTeamState(value, expectedId) {
         && Array.isArray(value['tasks'])
         && value['tasks'].every(isTeamTask)
         && Number.isSafeInteger(value['taskSeq'])
-        && value['taskSeq'] >= 0;
+        && value['taskSeq'] >= 0
+        && (value['phase'] === undefined || value['phase'] === 'staged' || value['phase'] === 'running')
+        && (value['planReviewState'] === undefined
+            || value['planReviewState'] === 'awaiting_review'
+            || value['planReviewState'] === 'awaiting_feedback')
+        && (value['approvedAt'] === undefined || isFiniteNumber(value['approvedAt']))
+        && (value['halted'] === undefined || typeof value['halted'] === 'boolean')
+        && (value['haltedAt'] === undefined || isFiniteNumber(value['haltedAt']))
+        && (value['reviewPolicy'] === undefined || isReviewPolicy(value['reviewPolicy']))
+        && (value['escalated'] === undefined || typeof value['escalated'] === 'boolean');
     if (!validShape)
         return false;
     const members = value['members'];
     const tasks = value['tasks'];
     const memberIds = new Set();
     const memberKeys = new Set();
+    const staged = value['phase'] === 'staged';
     for (const member of members) {
         const key = sanitizeKey(member.name);
-        if (member.id === '' || key === CAPTAIN_KEY || memberIds.has(member.id) || memberKeys.has(key))
+        if ((!staged && member.id === '') || key === CAPTAIN_KEY || memberKeys.has(key))
             return false;
-        memberIds.add(member.id);
+        if (member.id !== '') {
+            if (memberIds.has(member.id))
+                return false;
+            memberIds.add(member.id);
+        }
         memberKeys.add(key);
     }
     const taskIds = new Set();
@@ -739,11 +840,16 @@ export async function listArchivedTeamIds(stateRoot) {
 }
 /**
  * The visual state of one task: `running` while in_progress, `completed`
- * when done, `blocked` while any dependency is unfinished, else `open`.
+ * when done, `failed`/`cancelled` when terminal without success, `blocked`
+ * while any dependency is unfinished, else `open`.
  */
 export function taskVisualState(status, dependencies, tasks) {
     if (status === 'completed')
         return 'completed';
+    if (status === 'failed')
+        return 'failed';
+    if (status === 'cancelled')
+        return 'cancelled';
     if (status === 'in_progress')
         return 'running';
     const byId = new Map(tasks.map((task) => [task.id, task]));