@open-multi-agent/core 1.6.0 → 1.8.0

package/dist/orchestrator/orchestrator.js

@@ -49,7 +49,10 @@ import { registerBuiltInTools } from '../tool/built-in/index.js';
 import { defaultWorkspaceDir } from '../tool/built-in/path-safety.js';
 import { Team } from '../team/team.js';
 import { TaskQueue } from '../task/queue.js';
+import { Checkpoint } from '../memory/checkpoint.js';
+import { InMemoryStore } from '../memory/store.js';
 import { createTask, validateTaskDependencies } from '../task/task.js';
+import { extractJSON, validateOutput } from '../agent/structured-output.js';
 import { Scheduler } from './scheduler.js';
 import { TokenBudgetExceededError } from '../errors.js';
 import { extractKeywords, keywordScore } from '../utils/keywords.js';
@@ -195,6 +198,23 @@ function buildAgent(config, toolRegistration) {
     });
     return new Agent(config, registry, executor);
 }
+/**
+ * Apply the orchestrator's {@link OrchestratorConfig.defaultToolPreset} as a
+ * fallback grant for an agent that declares neither `tools` nor `toolPreset`.
+ *
+ * Built-in tools are opt-in (default-deny): an agent with no grant resolves to
+ * zero built-in tools. This fills that gap when the orchestrator opts in to a
+ * default. Per-agent grants always win — the default never widens an agent that
+ * already declares `tools` or `toolPreset`.
+ */
+function applyDefaultToolPreset(config, defaultToolPreset) {
+    if (defaultToolPreset === undefined
+        || config.tools !== undefined
+        || config.toolPreset !== undefined) {
+        return config;
+    }
+    return { ...config, toolPreset: defaultToolPreset };
+}
 /** Promise-based delay. */
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -274,6 +294,53 @@ export async function executeWithRetry(run, task, onRetry, delayFn = sleep) {
         toolCalls: [],
     };
 }
+/**
+ * Resolve a parsed task spec's `verify` field into a full
+ * {@link ConsensusVerifyOptions} (or `undefined` when no verify should run).
+ *
+ * - Full `ConsensusVerifyOptions` (already has `judges`): used as-is.
+ * - `true` or `CoordinatorVerifySpec` (no `judges`): merged with
+ *   `verifyJudges` when provided; ignored when `verifyJudges` is absent.
+ * - `undefined`: no verify.
+ */
+function resolveVerify(spec, verifyJudges) {
+    if (spec === undefined)
+        return undefined;
+    if (spec !== true && 'judges' in spec)
+        return spec;
+    if (!verifyJudges || verifyJudges.length === 0)
+        return undefined;
+    const partial = spec === true ? {} : spec;
+    return {
+        judges: verifyJudges,
+        ...(partial.mode !== undefined ? { mode: partial.mode } : {}),
+        ...(partial.quorum !== undefined ? { quorum: partial.quorum } : {}),
+        ...(partial.maxRounds !== undefined ? { maxRounds: partial.maxRounds } : {}),
+        ...(partial.onDissent !== undefined ? { onDissent: partial.onDissent } : {}),
+    };
+}
+/**
+ * Parse the coordinator-emitted `verify` field on a task JSON object.
+ * Accepts `true` (use all defaults) or a partial object with `mode`,
+ * `quorum`, `maxRounds`, and/or `onDissent`. Returns `undefined` for any
+ * other value so missing / null / unrecognised values are ignored safely.
+ */
+function parseCoordinatorVerify(raw) {
+    if (raw === true)
+        return true;
+    if (typeof raw !== 'object' || raw === null)
+        return undefined;
+    const obj = raw;
+    const mode = obj['mode'] === 'refute' || obj['mode'] === 'lens' ? obj['mode'] : undefined;
+    const quorum = typeof obj['quorum'] === 'number' && obj['quorum'] >= 1 ? Math.floor(obj['quorum']) : undefined;
+    const maxRounds = typeof obj['maxRounds'] === 'number' && obj['maxRounds'] >= 1 ? Math.floor(obj['maxRounds']) : undefined;
+    const onDissent = obj['onDissent'] === 'revise' || obj['onDissent'] === 'reject' || obj['onDissent'] === 'keep'
+        ? obj['onDissent']
+        : undefined;
+    if (mode === undefined && quorum === undefined && maxRounds === undefined && onDissent === undefined)
+        return true;
+    return { mode, quorum, maxRounds, onDissent };
+}
 /**
  * Attempt to extract a JSON array of task specs from the coordinator's raw
  * output. The coordinator is prompted to emit JSON inside a ```json … ``` fence
@@ -314,6 +381,11 @@ function parseTaskSpecs(raw) {
                 maxRetries: typeof obj['maxRetries'] === 'number' ? obj['maxRetries'] : undefined,
                 retryDelayMs: typeof obj['retryDelayMs'] === 'number' ? obj['retryDelayMs'] : undefined,
                 retryBackoff: typeof obj['retryBackoff'] === 'number' ? obj['retryBackoff'] : undefined,
+                role: typeof obj['role'] === 'string' ? obj['role'] : undefined,
+                priority: obj['priority'] === 'low' || obj['priority'] === 'normal' || obj['priority'] === 'high' || obj['priority'] === 'critical'
+                    ? obj['priority']
+                    : undefined,
+                verify: parseCoordinatorVerify(obj['verify']),
             });
         }
         return specs.length > 0 ? specs : null;
@@ -322,6 +394,47 @@ function parseTaskSpecs(raw) {
         return null;
     }
 }
+function routeMatches(policy, selection) {
+    if (!policy)
+        return undefined;
+    const task = selection.task;
+    for (const rule of policy.rules) {
+        const match = rule.match;
+        if (match.phase !== undefined && match.phase !== selection.phase)
+            continue;
+        if (match.agent !== undefined && match.agent !== selection.agent)
+            continue;
+        if (match.taskRole !== undefined && match.taskRole !== task?.role)
+            continue;
+        if (match.taskPriority !== undefined && match.taskPriority !== task?.priority)
+            continue;
+        if (match.leaf !== undefined && match.leaf !== selection.leaf)
+            continue;
+        if (match.hasDependencies !== undefined && match.hasDependencies !== ((task?.dependsOn?.length ?? 0) > 0))
+            continue;
+        return rule.route;
+    }
+    return undefined;
+}
+function withModelRoute(config, route) {
+    if (!route)
+        return config;
+    return {
+        ...config,
+        model: route.model,
+        provider: route.provider ?? config.provider,
+        baseURL: route.baseURL ?? config.baseURL,
+        apiKey: route.apiKey ?? config.apiKey,
+        region: route.region ?? config.region,
+    };
+}
+function isLeafTask(task, tasks) {
+    for (const candidate of tasks) {
+        if (candidate.dependsOn?.includes(task.id))
+            return false;
+    }
+    return true;
+}
 function buildRevealCoordinatorLines(revealContext, assignee) {
     return [
         '## Team context',
@@ -376,13 +489,19 @@ function buildTaskAgentTeamInfo(ctx, taskId, traceBase, delegationDepth, delegat
         }
         // Apply orchestrator-level defaults just like buildPool, then construct a
         // one-shot Agent for this delegation only.
-        const effective = {
+        const route = routeMatches(ctx.modelRouting, {
+            phase: 'delegated',
+            agent: targetAgent,
+            task: ctx.taskById.get(taskId),
+            leaf: ctx.taskLeafById.get(taskId),
+        });
+        const effective = withModelRoute(applyDefaultToolPreset({
             ...targetConfig,
             provider: targetConfig.provider ?? ctx.config.defaultProvider,
             baseURL: targetConfig.baseURL ?? ctx.config.defaultBaseURL,
             apiKey: targetConfig.apiKey ?? ctx.config.defaultApiKey,
             cwd: targetConfig.cwd === undefined ? ctx.config.defaultCwd : targetConfig.cwd,
-        };
+        }, ctx.config.defaultToolPreset), route);
         const tempAgent = buildAgent(effective, { includeDelegateTool: true });
         const nestedTeam = buildTaskAgentTeamInfo(ctx, taskId, traceBase, delegationDepth + 1, [...delegationChain, targetAgent]);
         const childOpts = {
@@ -404,6 +523,54 @@ function buildTaskAgentTeamInfo(ctx, taskId, traceBase, delegationDepth, delegat
         runDelegatedAgent,
     };
 }
+async function saveRunCheckpoint(queue, ctx) {
+    const active = ctx.checkpoint;
+    if (!active)
+        return;
+    // Best-effort: a checkpoint write must never take down the run it protects.
+    // Both snapshot construction and the store write are guarded, so a failing
+    // store (e.g. a transient Redis/SQLite error) is surfaced via `onProgress`
+    // and the run continues — the next completed task retries the write.
+    const save = async () => {
+        const sharedMem = ctx.team.getSharedMemoryInstance();
+        const completedTaskResults = queue.getByStatus('completed').map((task) => ({
+            taskId: task.id,
+            ...(task.assignee !== undefined ? { assignee: task.assignee } : {}),
+            ...(task.result !== undefined ? { result: task.result } : {}),
+        }));
+        const snapshot = {
+            version: 1,
+            mode: active.mode,
+            createdAt: new Date().toISOString(),
+            ...(active.runId !== undefined ? { runId: active.runId } : {}),
+            ...(active.goal !== undefined ? { goal: active.goal } : {}),
+            queue: queue.snapshot(),
+            // When the checkpoint store IS the shared-memory store, the entries are
+            // already durable there — embedding a full snapshot on every task would
+            // be ~O(N^2) write volume. Persist only the turn counter (cheap) so TTL
+            // expiry stays correct; restore reads the entries straight from the store.
+            ...(sharedMem && !active.reusesSharedMemoryStore
+                ? { sharedMemory: await sharedMem.snapshot() }
+                : {}),
+            ...(sharedMem ? { turnCount: sharedMem.getTurnCount() } : {}),
+            completedTaskResults,
+        };
+        await active.manager.save(snapshot);
+    };
+    const nextSave = active.saveChain.catch(() => undefined).then(save);
+    // Keep the stored chain non-rejecting so a failed save never leaves an
+    // unhandled rejection or blocks the next checkpoint in the chain.
+    active.saveChain = nextSave.catch(() => undefined);
+    try {
+        await nextSave;
+    }
+    catch (error) {
+        ctx.config.onProgress?.({
+            type: 'error',
+            data: { kind: 'checkpoint_save_failed', error },
+        });
+    }
+}
 /**
  * Execute all tasks in `queue` using agents in `pool`, respecting dependencies
  * and running independent tasks in parallel.
@@ -461,6 +628,18 @@ async function executeQueue(queue, ctx) {
                 });
                 return;
             }
+            const agentConfig = team.getAgent(assignee);
+            if (!agentConfig) {
+                const msg = `Agent "${assignee}" not found in team for task "${task.title}".`;
+                queue.fail(task.id, msg);
+                config.onProgress?.({
+                    type: 'error',
+                    task: task.id,
+                    agent: assignee,
+                    data: msg,
+                });
+                return;
+            }
             const agent = pool.get(assignee);
             if (!agent) {
                 const msg = `Agent "${assignee}" not found in pool for task "${task.title}".`;
@@ -503,9 +682,22 @@ async function executeQueue(queue, ctx) {
                 ...traceBase,
                 team: buildTaskAgentTeamInfo(ctx, task.id, traceBase, 0, [assignee]),
             };
-            const taskStartMs = Date.now();
-            let retryCount = 0;
-            const result = await executeWithRetry(() => pool.run(assignee, prompt, runOptions, config.onAgentStream
+            const workerRoute = routeMatches(ctx.modelRouting, {
+                phase: 'worker',
+                agent: assignee,
+                task,
+                leaf: ctx.taskLeafById.get(task.id),
+            });
+            const routedAgent = workerRoute
+                ? buildAgent(withModelRoute(applyDefaultToolPreset({
+                    ...agentConfig,
+                    provider: agentConfig.provider ?? config.defaultProvider,
+                    baseURL: agentConfig.baseURL ?? config.defaultBaseURL,
+                    apiKey: agentConfig.apiKey ?? config.defaultApiKey,
+                    cwd: agentConfig.cwd === undefined ? config.defaultCwd : agentConfig.cwd,
+                }, config.defaultToolPreset), workerRoute), { includeDelegateTool: true })
+                : undefined;
+            const streamCallback = config.onAgentStream
                 ? (event) => {
                     if (config.onTrace) {
                         const streamMs = Date.now();
@@ -522,7 +714,12 @@ async function executeQueue(queue, ctx) {
                     }
                     config.onAgentStream(assignee, event);
                 }
-                : undefined), task, (retryData) => {
+                : undefined;
+            const taskStartMs = Date.now();
+            let retryCount = 0;
+            const result = await executeWithRetry(() => routedAgent
+                ? pool.runEphemeral(routedAgent, prompt, runOptions, streamCallback)
+                : pool.run(assignee, prompt, runOptions, streamCallback), task, (retryData) => {
                 retryCount++;
                 config.onProgress?.({
                     type: 'task_retry',
@@ -571,27 +768,38 @@ async function executeQueue(queue, ctx) {
                 });
             }
             if (result.success) {
-                // Persist result into shared memory so other agents can read it
                 const sharedMem = team.getSharedMemoryInstance();
+                // Opt-in consensus verification runs *before* the task is finalised so the
+                // verified outcome (accepted → revised, rejected → original) flows into the
+                // queue, shared memory, progress events, and agentResults as one consistent
+                // result. Judge usage is charged to the same parent budget as the rest of the run.
+                let effective = result;
+                if (task.verify && !ctx.budgetExceededTriggered) {
+                    effective = await runTaskVerify(task, assignee, result, sharedMem, ctx);
+                }
+                // Reflect the verified result in the per-task record the caller receives.
+                ctx.agentResults.set(`${assignee}:${task.id}`, effective);
+                // Persist result into shared memory so other agents can read it
                 if (sharedMem) {
-                    await sharedMem.write(assignee, `task:${task.id}:result`, result.output);
+                    await sharedMem.write(assignee, `task:${task.id}:result`, effective.output);
                     // Advance the turn counter so any TTL-tagged entries written during
                     // this task can be expired by subsequent reads.
                     sharedMem.advanceTurn();
                 }
-                const completedTask = queue.complete(task.id, result.output);
+                const completedTask = queue.complete(task.id, effective.output);
                 completedThisRound.push(completedTask);
+                await saveRunCheckpoint(queue, ctx);
                 config.onProgress?.({
                     type: 'task_complete',
                     task: task.id,
                     agent: assignee,
-                    data: result,
+                    data: effective,
                 });
                 config.onProgress?.({
                     type: 'agent_complete',
                     agent: assignee,
                     task: task.id,
-                    data: result,
+                    data: effective,
                 });
             }
             else {
@@ -691,6 +899,251 @@ async function buildTaskPrompt(task, team, queue, revealContext) {
     }
     return lines.join('\n');
 }
+/** Skeptic framing applied to every judge (refute mode and lens-mode base). */
+const DEFAULT_VERIFIER_INSTRUCTION = 'You are a rigorous skeptic reviewing a proposed answer to the question shown below. ' +
+    'Judge the answer against what that question actually asks: hunt for errors, unsupported ' +
+    'claims, gaps, and faulty reasoning, then decide whether it withstands scrutiny.';
+/** Per-judge review angles used in `lens` mode (assigned round-robin by index). */
+const CONSENSUS_LENSES = [
+    'factual correctness and logical soundness',
+    'completeness and coverage of the question',
+    'edge cases, failure modes, and counterexamples',
+    'clarity, precision, and freedom from ambiguity',
+    'hidden assumptions and unstated premises',
+    'evidence, citations, and verifiability',
+];
+/** Verdict contract appended to every judge prompt. */
+const VERDICT_INSTRUCTION = 'Respond ONLY with a JSON object {"accept": <true|false>, "critique": "<concise reason>"}. ' +
+    'Set "accept" to true only if the answer withstands scrutiny; otherwise set it false ' +
+    'and explain the problem in "critique".';
+/** Apply orchestrator defaults to a consensus agent config, mirroring buildPool. */
+function applyConsensusDefaults(config, defaults) {
+    return {
+        ...config,
+        provider: config.provider ?? defaults.defaultProvider,
+        baseURL: config.baseURL ?? defaults.defaultBaseURL,
+        apiKey: config.apiKey ?? defaults.defaultApiKey,
+        cwd: config.cwd === undefined ? defaults.defaultCwd : config.cwd,
+    };
+}
+/** Build the user prompt sent to a single judge, always including the original question. */
+function buildJudgePrompt(p) {
+    let instruction;
+    if (p.judgePrompt !== undefined) {
+        instruction = typeof p.judgePrompt === 'function' ? p.judgePrompt(p.judge) : p.judgePrompt;
+    }
+    else if (p.mode === 'lens') {
+        const lens = CONSENSUS_LENSES[p.judgeIndex % CONSENSUS_LENSES.length];
+        instruction = `${DEFAULT_VERIFIER_INSTRUCTION}\nFocus specifically on: ${lens}. ` +
+            'If that angle is irrelevant to this question, accept the answer rather than inventing objections.';
+    }
+    else {
+        instruction = DEFAULT_VERIFIER_INSTRUCTION;
+    }
+    return [
+        instruction,
+        '',
+        '## Question',
+        p.prompt,
+        '',
+        '## Proposed answer',
+        p.answer,
+        '',
+        '## Your verdict',
+        VERDICT_INSTRUCTION,
+    ].join('\n');
+}
+/** Build the proposer prompt for a revision round, feeding back the prior answer and the dissent. */
+function buildRevisePrompt(prompt, answer, dissent) {
+    return [
+        prompt,
+        '',
+        '## Your previous answer',
+        answer,
+        '',
+        '## Reviewer critiques to address',
+        ...dissent.map((d) => `- ${d}`),
+        '',
+        'Revise the previous answer to address every critique above. Respond with the improved answer only.',
+    ].join('\n');
+}
+/** Parse a judge's raw output into an accept/critique decision. */
+function parseJudgeVerdict(output, verdictSchema) {
+    let parsed;
+    try {
+        parsed = extractJSON(output);
+    }
+    catch {
+        return { accept: false, critique: 'Judge output was not valid JSON.' };
+    }
+    if (verdictSchema) {
+        try {
+            validateOutput(verdictSchema, parsed);
+        }
+        catch (err) {
+            return { accept: false, critique: `Verdict failed schema validation: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+    const obj = (parsed && typeof parsed === 'object' ? parsed : {});
+    const accept = typeof obj['accept'] === 'boolean' ? obj['accept'] : false;
+    const critique = typeof obj['critique'] === 'string' && obj['critique']
+        ? obj['critique']
+        : accept ? '' : 'No critique provided.';
+    return { accept, critique };
+}
+/**
+ * Run the judge/refutation loop over a proposed answer: judges run sequentially
+ * (so quorum and budget can stop the rest), dissent is recorded to shared memory
+ * and trace, and `onDissent` decides whether to revise, reject, or keep.
+ */
+async function runConsensusCore(params) {
+    const { team, prompt, judges, mode, quorum, maxRounds, verdictSchema, onDissent, judgePrompt, budget, budgetBaseTokens, reviseProposer, defaults, onTrace, runId, } = params;
+    const pool = params.pool ?? new AgentPool(Math.max(1, defaults.maxConcurrency));
+    const sharedMem = team.getSharedMemoryInstance();
+    let answer = params.initialAnswer;
+    let usage = params.initialUsage;
+    const dissent = [];
+    let rounds = 0;
+    let accepted = false;
+    const overBudget = () => budget !== undefined && budgetBaseTokens + usage.input_tokens + usage.output_tokens > budget;
+    const runEphemeral = (config, text) => pool.runEphemeral(buildAgent(applyConsensusDefaults(config, defaults)), text);
+    // Proposer usage was already accumulated by the caller; bail before judging if it blew the budget.
+    if (overBudget()) {
+        return { answer, verdict: 'rejected', dissent, rounds, tokenUsage: usage };
+    }
+    let budgetHit = false;
+    for (let round = 1; round <= maxRounds; round++) {
+        rounds = round;
+        let acceptCount = 0;
+        const roundDissent = [];
+        for (let j = 0; j < judges.length; j++) {
+            const judge = judges[j];
+            const judgeText = buildJudgePrompt({ judge: judge.name, answer, prompt, mode, judgeIndex: j, judgePrompt });
+            const r = await runEphemeral(judge, judgeText);
+            usage = addUsage(usage, r.tokenUsage);
+            if (overBudget()) {
+                budgetHit = true;
+                break;
+            }
+            const verdict = parseJudgeVerdict(r.output, verdictSchema);
+            // Trace every verdict (accept or dissent); shared memory records dissent only.
+            if (onTrace) {
+                const now = Date.now();
+                emitTrace(onTrace, {
+                    type: 'consensus',
+                    runId: runId ?? '',
+                    agent: judge.name,
+                    round,
+                    accepted: verdict.accept,
+                    ...(verdict.accept ? {} : { dissent: verdict.critique }),
+                    startMs: now,
+                    endMs: now,
+                    durationMs: 0,
+                });
+            }
+            if (verdict.accept) {
+                acceptCount++;
+                if (acceptCount >= quorum) {
+                    accepted = true;
+                    break;
+                }
+            }
+            else {
+                const labelled = `${judge.name}: ${verdict.critique}`;
+                roundDissent.push(labelled);
+                dissent.push(labelled);
+                if (sharedMem) {
+                    await sharedMem.write(judge.name, `consensus:round:${round}:dissent`, verdict.critique);
+                }
+            }
+        }
+        if (budgetHit || accepted)
+            break;
+        // Round missed quorum. Revise (if rounds remain) or stop.
+        if (onDissent === 'revise' && round < maxRounds && reviseProposer) {
+            const r = await runEphemeral(reviseProposer, buildRevisePrompt(prompt, answer, roundDissent));
+            usage = addUsage(usage, r.tokenUsage);
+            if (r.success && r.output)
+                answer = r.output;
+            if (overBudget()) {
+                budgetHit = true;
+                break;
+            }
+            continue;
+        }
+        break;
+    }
+    const verdict = accepted || (!budgetHit && onDissent === 'keep') ? 'accepted' : 'rejected';
+    return { answer, verdict, dissent, rounds, tokenUsage: usage };
+}
+/**
+ * Run the per-task `verify` hook before a task is finalised: feed the task
+ * result into the consensus loop, fold judge usage into the run's cumulative
+ * budget, surface the verdict, and return the effective result — the accepted
+ * revision when judges revise it, otherwise the original. The caller uses this
+ * to finalise the task so the queue, shared memory, events, and agentResults
+ * all agree on the verified outcome.
+ */
+async function runTaskVerify(task, assignee, result, sharedMem, ctx) {
+    const verify = task.verify;
+    const { team, config } = ctx;
+    const assigneeConfig = team.getAgents().find((a) => a.name === assignee);
+    const consensus = await runConsensusCore({
+        team,
+        prompt: task.description,
+        initialAnswer: result.output,
+        initialUsage: ZERO_USAGE,
+        budgetBaseTokens: ctx.cumulativeUsage.input_tokens + ctx.cumulativeUsage.output_tokens,
+        judges: verify.judges,
+        mode: verify.mode ?? 'refute',
+        quorum: Math.min(verify.judges.length, Math.max(1, verify.quorum ?? Math.ceil(verify.judges.length / 2))),
+        maxRounds: Math.max(1, verify.maxRounds ?? 2),
+        verdictSchema: verify.verdictSchema,
+        onDissent: verify.onDissent ?? 'revise',
+        judgePrompt: verify.judgePrompt,
+        budget: ctx.maxTokenBudget,
+        reviseProposer: assigneeConfig,
+        defaults: {
+            defaultProvider: config.defaultProvider,
+            defaultBaseURL: config.defaultBaseURL,
+            defaultApiKey: config.defaultApiKey,
+            defaultCwd: config.defaultCwd,
+            maxConcurrency: config.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY,
+        },
+        onTrace: config.onTrace,
+        ...(ctx.runId ? { runId: ctx.runId } : {}),
+    });
+    ctx.cumulativeUsage = addUsage(ctx.cumulativeUsage, consensus.tokenUsage);
+    // Surface the verdict as a task-level outcome so downstream agents and the
+    // final synthesis can see whether the result survived scrutiny.
+    if (sharedMem) {
+        const summary = consensus.verdict === 'accepted'
+            ? 'accepted'
+            : `rejected${consensus.dissent.length ? `: ${consensus.dissent.join('; ')}` : ''}`;
+        await sharedMem.write(assignee, `task:${task.id}:verdict`, summary);
+    }
+    const total = ctx.cumulativeUsage.input_tokens + ctx.cumulativeUsage.output_tokens;
+    if (!ctx.budgetExceededTriggered && ctx.maxTokenBudget !== undefined && total > ctx.maxTokenBudget) {
+        ctx.budgetExceededTriggered = true;
+        const err = new TokenBudgetExceededError('orchestrator', total, ctx.maxTokenBudget);
+        ctx.budgetExceededReason = err.message;
+        config.onProgress?.({
+            type: 'budget_exceeded',
+            agent: assignee,
+            task: task.id,
+            data: err,
+        });
+    }
+    // Only an *accepted* revision supersedes the task result; a rejected revision is
+    // recorded as dissent but the caller finalises with the original output. Judge
+    // usage rolls into the per-task usage (mirrors how delegation usage rolls in).
+    const useRevision = consensus.verdict === 'accepted' && consensus.answer && consensus.answer !== result.output;
+    return {
+        ...result,
+        output: useRevision ? consensus.answer : result.output,
+        tokenUsage: addUsage(result.tokenUsage, consensus.tokenUsage),
+    };
+}
 // ---------------------------------------------------------------------------
 // OpenMultiAgent
 // ---------------------------------------------------------------------------
@@ -703,6 +1156,7 @@ async function buildTaskPrompt(task, team, queue, revealContext) {
 export class OpenMultiAgent {
     config;
     teams = new Map();
+    fallbackCheckpointStore = new InMemoryStore();
     completedTaskCount = 0;
     /**
      * @param config - Optional top-level configuration.
@@ -726,6 +1180,8 @@ export class OpenMultiAgent {
             // disable the filesystem sandbox; a string sets a custom sandbox root.
             defaultCwd: config.defaultCwd === undefined ? defaultWorkspaceDir() : config.defaultCwd,
             maxTokenBudget: config.maxTokenBudget,
+            defaultToolPreset: config.defaultToolPreset,
+            checkpoint: config.checkpoint,
             onApproval: config.onApproval,
             onPlanReady: config.onPlanReady,
             onAgentStream: config.onAgentStream,
@@ -770,14 +1226,14 @@ export class OpenMultiAgent {
      */
     async runAgent(config, prompt, options) {
         const effectiveBudget = resolveTokenBudget(config.maxTokenBudget, this.config.maxTokenBudget);
-        const effective = {
+        const effective = applyDefaultToolPreset({
             ...config,
             provider: config.provider ?? this.config.defaultProvider,
             baseURL: config.baseURL ?? this.config.defaultBaseURL,
             apiKey: config.apiKey ?? this.config.defaultApiKey,
             cwd: config.cwd === undefined ? this.config.defaultCwd : config.cwd,
             maxTokenBudget: effectiveBudget,
-        };
+        }, this.config.defaultToolPreset);
         const agent = buildAgent(effective);
         this.config.onProgress?.({
             type: 'agent_start',
@@ -858,14 +1314,14 @@ export class OpenMultiAgent {
             // to avoid duplicate progress events and double completedTaskCount.
             // Events are emitted here; counting is handled by buildTeamRunResult().
             const effectiveBudget = resolveTokenBudget(bestAgent.maxTokenBudget, this.config.maxTokenBudget);
-            const effective = {
+            const effective = withModelRoute(applyDefaultToolPreset({
                 ...bestAgent,
                 provider: bestAgent.provider ?? this.config.defaultProvider,
                 baseURL: bestAgent.baseURL ?? this.config.defaultBaseURL,
                 apiKey: bestAgent.apiKey ?? this.config.defaultApiKey,
                 cwd: bestAgent.cwd === undefined ? this.config.defaultCwd : bestAgent.cwd,
                 maxTokenBudget: effectiveBudget,
-            };
+            }, this.config.defaultToolPreset), routeMatches(options?.modelRouting, { phase: 'short-circuit', agent: bestAgent.name }));
             const agent = buildAgent(effective);
             this.config.onProgress?.({
                 type: 'agent_start',
@@ -915,33 +1371,8 @@ export class OpenMultiAgent {
         // ------------------------------------------------------------------
         // Step 1: Coordinator decomposes goal into tasks
         // ------------------------------------------------------------------
-        const coordinatorConfig = {
-            name: 'coordinator',
-            model: coordinatorOverrides?.model ?? this.config.defaultModel,
-            ...(coordinatorOverrides?.adapter !== undefined ? { adapter: coordinatorOverrides.adapter } : {}),
-            provider: coordinatorOverrides?.provider ?? this.config.defaultProvider,
-            baseURL: coordinatorOverrides?.baseURL ?? this.config.defaultBaseURL,
-            apiKey: coordinatorOverrides?.apiKey ?? this.config.defaultApiKey,
-            systemPrompt: this.buildCoordinatorPrompt(agentConfigs, coordinatorOverrides),
-            maxTurns: coordinatorOverrides?.maxTurns ?? 3,
-            maxTokens: coordinatorOverrides?.maxTokens,
-            temperature: coordinatorOverrides?.temperature,
-            topP: coordinatorOverrides?.topP,
-            topK: coordinatorOverrides?.topK,
-            minP: coordinatorOverrides?.minP,
-            parallelToolCalls: coordinatorOverrides?.parallelToolCalls,
-            frequencyPenalty: coordinatorOverrides?.frequencyPenalty,
-            presencePenalty: coordinatorOverrides?.presencePenalty,
-            extraBody: coordinatorOverrides?.extraBody,
-            toolPreset: coordinatorOverrides?.toolPreset,
-            tools: coordinatorOverrides?.tools,
-            disallowedTools: coordinatorOverrides?.disallowedTools,
-            cwd: coordinatorOverrides?.cwd === undefined
-                ? this.config.defaultCwd
-                : coordinatorOverrides.cwd,
-            loopDetection: coordinatorOverrides?.loopDetection,
-            timeoutMs: coordinatorOverrides?.timeoutMs,
-        };
+        const coordinatorBaseConfig = this.buildCoordinatorBaseConfig(coordinatorOverrides, agentConfigs, (options?.verifyJudges?.length ?? 0) > 0);
+        const coordinatorConfig = withModelRoute(coordinatorBaseConfig, routeMatches(options?.modelRouting, { phase: 'coordinator', agent: 'coordinator' }));
         const decompositionPrompt = this.buildDecompositionPrompt(goal, agentConfigs);
         const coordinatorAgent = buildAgent(coordinatorConfig);
         const runId = this.config.onTrace ? generateRunId() : undefined;
@@ -977,7 +1408,7 @@ export class OpenMultiAgent {
         if (taskSpecs && taskSpecs.length > 0) {
             // Map title-based dependsOn references to real task IDs so we can
             // build the dependency graph before adding tasks to the queue.
-            this.loadSpecsIntoQueue(taskSpecs, agentConfigs, queue);
+            this.loadSpecsIntoQueue(taskSpecs, agentConfigs, queue, options?.verifyJudges);
         }
         else {
             // Coordinator failed to produce structured output — fall back to
@@ -999,12 +1430,14 @@ export class OpenMultiAgent {
         // Step 4: Build pool and execute
         // ------------------------------------------------------------------
         const pool = this.buildPool(agentConfigs);
+        const activeCheckpoint = this.createActiveCheckpoint(team, options?.checkpoint ?? this.config.checkpoint, 'runTeam', goal);
         const ctx = {
             team,
             pool,
             scheduler,
             agentResults,
             config: this.config,
+            ...(activeCheckpoint ? { checkpoint: activeCheckpoint } : {}),
             runId,
             abortSignal: options?.abortSignal,
             cumulativeUsage,
@@ -1020,6 +1453,9 @@ export class OpenMultiAgent {
                     },
                 }
                 : {}),
+            modelRouting: options?.modelRouting,
+            taskById: new Map(queue.list().map((task) => [task.id, task])),
+            taskLeafById: new Map(queue.list().map((task) => [task.id, isLeafTask(task, queue.list())])),
         };
         const planTasks = queue.list();
         const planReadyStartMs = Date.now();
@@ -1060,6 +1496,7 @@ export class OpenMultiAgent {
                 maxRetries: task.maxRetries,
                 retryDelayMs: task.retryDelayMs,
                 retryBackoff: task.retryBackoff,
+                verify: task.verify,
                 metrics: undefined,
             }));
             this.config.onProgress?.({
@@ -1085,38 +1522,25 @@ export class OpenMultiAgent {
             maxRetries: task.maxRetries,
             retryDelayMs: task.retryDelayMs,
             retryBackoff: task.retryBackoff,
+            verify: task.verify,
             metrics: taskMetrics.get(task.id),
         }));
         // ------------------------------------------------------------------
         // Step 5: Coordinator synthesises final result
         // ------------------------------------------------------------------
-        if (options?.abortSignal?.aborted) {
-            return this.buildTeamRunResult(agentResults, goal, taskRecords);
-        }
-        if (maxTokenBudget !== undefined
-            && cumulativeUsage.input_tokens + cumulativeUsage.output_tokens > maxTokenBudget) {
+        const synthesis = await this.runCoordinatorSynthesis(team, queue, goal, coordinatorBaseConfig, {
+            modelRouting: options?.modelRouting,
+            runId,
+            abortSignal: options?.abortSignal,
+            cumulativeUsage,
+            maxTokenBudget,
+        });
+        if (synthesis === null) {
+            // Aborted or already over budget — return raw task outputs, no synthesis.
             return this.buildTeamRunResult(agentResults, goal, taskRecords);
         }
-        const synthesisPrompt = await this.buildSynthesisPrompt(goal, queue.list(), team);
-        const synthTraceOptions = this.config.onTrace
-            ? { onTrace: this.config.onTrace, runId: runId ?? '', traceAgent: 'coordinator' }
-            : undefined;
-        const synthesisResult = await coordinatorAgent.run(synthesisPrompt, synthTraceOptions);
-        agentResults.set('coordinator', synthesisResult);
-        cumulativeUsage = addUsage(cumulativeUsage, synthesisResult.tokenUsage);
-        if (maxTokenBudget !== undefined
-            && cumulativeUsage.input_tokens + cumulativeUsage.output_tokens > maxTokenBudget) {
-            this.config.onProgress?.({
-                type: 'budget_exceeded',
-                agent: 'coordinator',
-                data: new TokenBudgetExceededError('coordinator', cumulativeUsage.input_tokens + cumulativeUsage.output_tokens, maxTokenBudget),
-            });
-        }
-        this.config.onProgress?.({
-            type: 'agent_complete',
-            agent: 'coordinator',
-            data: synthesisResult,
-        });
+        agentResults.set('coordinator', synthesis.result);
+        cumulativeUsage = synthesis.cumulativeUsage;
         // Note: coordinator decompose and synthesis are internal meta-steps.
         // Only actual user tasks (non-coordinator keys) are counted in
         // buildTeamRunResult, so we do not increment completedTaskCount here.
@@ -1162,8 +1586,8 @@ export class OpenMultiAgent {
      *
      * Task IDs, dependencies, assignees, titles, and descriptions are used exactly
      * as stored in the artifact. This is intentionally execution-only; it does not
-     * synthesize a coordinator final answer and it does not implement durable
-     * checkpoints.
+     * synthesize a coordinator final answer. Durable checkpoints are available
+     * through the same opt-in `checkpoint` option used by `runTasks`.
      */
     async runFromPlan(team, plan, options) {
         if (plan.version !== 1) {
@@ -1178,6 +1602,63 @@ export class OpenMultiAgent {
         queue.addBatch(tasks);
         return this.executeExplicitTaskQueue(team, queue, options, plan.goal);
     }
+    async restore(team, tasksOrOptions, maybeOptions) {
+        const hasTaskSource = Array.isArray(tasksOrOptions) || this.isPlanArtifact(tasksOrOptions);
+        const options = hasTaskSource ? maybeOptions : tasksOrOptions;
+        const activeCheckpoint = this.createActiveCheckpoint(team, options?.checkpoint ?? this.config.checkpoint ?? true, 'runTasks', options?.goal);
+        const snapshot = activeCheckpoint ? await activeCheckpoint.manager.loadLatest() : null;
+        if (!snapshot) {
+            if (Array.isArray(tasksOrOptions)) {
+                const queue = new TaskQueue();
+                this.loadSpecsIntoQueue(tasksOrOptions.map((t) => ({
+                    title: t.title,
+                    description: t.description,
+                    assignee: t.assignee,
+                    dependsOn: t.dependsOn,
+                    memoryScope: t.memoryScope,
+                    maxRetries: t.maxRetries,
+                    retryDelayMs: t.retryDelayMs,
+                    retryBackoff: t.retryBackoff,
+                    role: t.role,
+                    priority: t.priority,
+                    verify: t.verify,
+                })), team.getAgents(), queue);
+                return this.executeExplicitTaskQueue(team, queue, options, options?.goal, undefined, activeCheckpoint);
+            }
+            if (this.isPlanArtifact(tasksOrOptions)) {
+                const queue = new TaskQueue();
+                const tasks = this.tasksFromPlan(tasksOrOptions);
+                const validation = validateTaskDependencies(tasks);
+                if (!validation.valid) {
+                    throw new Error(`Invalid plan artifact: ${validation.errors.join(' ')}`);
+                }
+                queue.addBatch(tasks);
+                return this.executeExplicitTaskQueue(team, queue, options, tasksOrOptions.goal ?? options?.goal, undefined, activeCheckpoint);
+            }
+            const queue = new TaskQueue();
+            return this.executeExplicitTaskQueue(team, queue, options, options?.goal, undefined, activeCheckpoint);
+        }
+        const sharedMem = team.getSharedMemoryInstance();
+        if (sharedMem && snapshot.sharedMemory) {
+            await sharedMem.restore(snapshot.sharedMemory);
+        }
+        else if (sharedMem && snapshot.turnCount !== undefined) {
+            // Reused-store checkpoint: entries are already in the store; only the
+            // turn counter needs restoring so TTL expiry resumes correctly.
+            sharedMem.setTurnCount(snapshot.turnCount);
+        }
+        const queue = TaskQueue.fromSnapshot(snapshot.queue, { resetInProgress: true });
+        const agentResults = this.agentResultsFromCheckpoint(snapshot, queue);
+        const checkpointForResume = activeCheckpoint
+            ? {
+                ...activeCheckpoint,
+                mode: snapshot.mode,
+                ...(snapshot.goal !== undefined ? { goal: snapshot.goal } : {}),
+                ...(snapshot.runId !== undefined ? { runId: snapshot.runId } : {}),
+            }
+            : undefined;
+        return this.executeExplicitTaskQueue(team, queue, options, snapshot.goal ?? options?.goal, agentResults, checkpointForResume, options?.coordinator);
+    }
     /**
      * Run a team with an explicitly provided task list.
      *
@@ -1200,10 +1681,94 @@ export class OpenMultiAgent {
             maxRetries: t.maxRetries,
             retryDelayMs: t.retryDelayMs,
             retryBackoff: t.retryBackoff,
+            role: t.role,
+            priority: t.priority,
+            verify: t.verify,
         })), agentConfigs, queue);
         return this.executeExplicitTaskQueue(team, queue, options);
     }
     // -------------------------------------------------------------------------
+    // Consensus
+    // -------------------------------------------------------------------------
+    /**
+     * Run a proposer→judge consensus over a single prompt.
+     *
+     * The proposer emits an answer; judges try to refute it over up to
+     * `maxRounds`, exiting early once `quorum` accept. Proposer and judge token
+     * usage all count against the orchestrator's `maxTokenBudget` — crossing it
+     * stops issuing further judge calls, exactly like delegation and `runTasks`.
+     */
+    async runConsensus(team, prompt, options) {
+        const proposers = Array.isArray(options.proposer) ? options.proposer : [options.proposer];
+        if (proposers.length === 0) {
+            throw new Error('runConsensus: at least one proposer is required.');
+        }
+        if (options.judges.length === 0) {
+            throw new Error('runConsensus: at least one judge is required.');
+        }
+        const mode = options.mode ?? 'refute';
+        const maxRounds = Math.max(1, options.maxRounds ?? 2);
+        const quorum = Math.min(options.judges.length, Math.max(1, options.quorum ?? Math.ceil(options.judges.length / 2)));
+        const onDissent = options.onDissent ?? 'revise';
+        const budget = this.config.maxTokenBudget;
+        const defaults = {
+            defaultProvider: this.config.defaultProvider,
+            defaultBaseURL: this.config.defaultBaseURL,
+            defaultApiKey: this.config.defaultApiKey,
+            defaultCwd: this.config.defaultCwd,
+            maxConcurrency: this.config.maxConcurrency,
+        };
+        const pool = new AgentPool(Math.max(1, this.config.maxConcurrency));
+        let usage = ZERO_USAGE;
+        // Step 2: run proposer(s); accumulate usage and honour the budget before judging.
+        const candidates = [];
+        for (const proposerConfig of proposers) {
+            const r = await pool.runEphemeral(buildAgent(applyConsensusDefaults(proposerConfig, defaults)), prompt);
+            usage = addUsage(usage, r.tokenUsage);
+            if (r.success && r.output)
+                candidates.push(r.output);
+            if (budget !== undefined && usage.input_tokens + usage.output_tokens > budget) {
+                this.config.onProgress?.({
+                    type: 'budget_exceeded',
+                    agent: proposerConfig.name,
+                    data: new TokenBudgetExceededError(proposerConfig.name, usage.input_tokens + usage.output_tokens, budget),
+                });
+                return {
+                    answer: candidates.join('\n\n---\n\n'),
+                    verdict: 'rejected',
+                    dissent: [],
+                    rounds: 0,
+                    tokenUsage: usage,
+                };
+            }
+        }
+        // Every proposer failed or returned empty output: there is nothing to judge.
+        // Bail with a rejected verdict so an empty answer can never come back accepted.
+        if (candidates.length === 0) {
+            return { answer: '', verdict: 'rejected', dissent: [], rounds: 0, tokenUsage: usage };
+        }
+        return runConsensusCore({
+            team,
+            prompt,
+            initialAnswer: candidates.join('\n\n---\n\n'),
+            initialUsage: usage,
+            budgetBaseTokens: 0,
+            judges: options.judges,
+            mode,
+            quorum,
+            maxRounds,
+            verdictSchema: options.verdictSchema,
+            onDissent,
+            judgePrompt: options.judgePrompt,
+            budget,
+            reviseProposer: proposers[0],
+            defaults,
+            onTrace: this.config.onTrace,
+            runId: this.config.onTrace ? generateRunId() : undefined,
+            pool,
+        });
+    }
+    // -------------------------------------------------------------------------
     // Observability
     // -------------------------------------------------------------------------
     /**
@@ -1241,32 +1806,32 @@ export class OpenMultiAgent {
     // Private helpers
     // -------------------------------------------------------------------------
     /** Build the system prompt given to the coordinator agent. */
-    buildCoordinatorSystemPrompt(agents) {
+    buildCoordinatorSystemPrompt(agents, hasVerifyJudges) {
         return [
             'You are a task coordinator responsible for decomposing high-level goals',
             'into concrete, actionable tasks and assigning them to the right team members.',
             '',
             this.buildCoordinatorRosterSection(agents),
             '',
-            this.buildCoordinatorOutputFormatSection(),
+            this.buildCoordinatorOutputFormatSection(hasVerifyJudges),
             '',
             this.buildCoordinatorSynthesisSection(),
         ].join('\n');
     }
     /** Build coordinator system prompt with optional caller overrides. */
-    buildCoordinatorPrompt(agents, config) {
+    buildCoordinatorPrompt(agents, config, hasVerifyJudges) {
         if (config?.systemPrompt) {
             return [
                 config.systemPrompt,
                 '',
                 this.buildCoordinatorRosterSection(agents),
                 '',
-                this.buildCoordinatorOutputFormatSection(),
+                this.buildCoordinatorOutputFormatSection(hasVerifyJudges),
                 '',
                 this.buildCoordinatorSynthesisSection(),
             ].join('\n');
         }
-        const base = this.buildCoordinatorSystemPrompt(agents);
+        const base = this.buildCoordinatorSystemPrompt(agents, hasVerifyJudges);
         if (!config?.instructions) {
             return base;
         }
@@ -1288,8 +1853,8 @@ export class OpenMultiAgent {
         ].join('\n');
     }
     /** Build the coordinator JSON output-format section. */
-    buildCoordinatorOutputFormatSection() {
-        return [
+    buildCoordinatorOutputFormatSection(hasVerifyJudges) {
+        const lines = [
             '## Output Format',
             'When asked to decompose a goal, respond ONLY with a JSON array of task objects.',
             'Each task must have:',
@@ -1297,17 +1862,12 @@ export class OpenMultiAgent {
             '  - "description": Full task description with context and expected output (string)',
             '  - "assignee":    One of the agent names listed in the roster (string)',
             '  - "dependsOn":   Array of titles of tasks this task depends on (string[], may be empty).',
-            '',
-            '## Dependency Guidance',
-            'Prefer the minimum set of upstream tasks each assignee needs. When deciding dependsOn for agent X:',
-            '  1. Use X\'s system prompt as the primary signal for what inputs it consumes.',
-            '  2. Lean toward including a task as a dependency only when X\'s system prompt names or describes needing that kind of input.',
-            '  3. Avoid adding a dependency just because the information "would be useful" or matches general best practice; if X\'s system prompt gives no indication it consumes that input, prefer to leave it out.',
-            '  4. When uncertain, prefer fewer dependencies over more — extra parents cost parallelism and tokens.',
-            '',
-            'Wrap the JSON in a ```json code fence.',
-            'Do not include any text outside the code fence.',
-        ].join('\n');
+        ];
+        if (hasVerifyJudges) {
+            lines.push('  - "verify":      (optional) Set to true to apply consensus judge verification on this task\'s result.', '                   Or set to an object with any of: "mode" ("refute"|"lens"), "quorum" (number),', '                   "maxRounds" (number), "onDissent" ("revise"|"reject"|"keep").', '                   Omit for tasks where a single agent\'s answer is sufficient.');
+        }
+        lines.push('', '## Dependency Guidance', 'Prefer the minimum set of upstream tasks each assignee needs. When deciding dependsOn for agent X:', '  1. Use X\'s system prompt as the primary signal for what inputs it consumes.', '  2. Lean toward including a task as a dependency only when X\'s system prompt names or describes needing that kind of input.', '  3. Avoid adding a dependency just because the information "would be useful" or matches general best practice; if X\'s system prompt gives no indication it consumes that input, prefer to leave it out.', '  4. When uncertain, prefer fewer dependencies over more — extra parents cost parallelism and tokens.', '', 'Wrap the JSON in a ```json code fence.', 'Do not include any text outside the code fence.');
+        return lines.join('\n');
     }
     /** Build the coordinator synthesis guidance section. */
     buildCoordinatorSynthesisSection() {
@@ -1329,6 +1889,77 @@ export class OpenMultiAgent {
             'Return ONLY the JSON task array in a ```json code fence.',
         ].join('\n');
     }
+    /**
+     * Build the base coordinator {@link AgentConfig} shared by the decomposition
+     * and synthesis passes. Falls back to orchestrator defaults for any field the
+     * caller's {@link CoordinatorConfig} leaves unset.
+     */
+    buildCoordinatorBaseConfig(coordinatorOverrides, agentConfigs, hasVerifyJudges) {
+        return {
+            name: 'coordinator',
+            model: coordinatorOverrides?.model ?? this.config.defaultModel,
+            ...(coordinatorOverrides?.adapter !== undefined ? { adapter: coordinatorOverrides.adapter } : {}),
+            provider: coordinatorOverrides?.provider ?? this.config.defaultProvider,
+            baseURL: coordinatorOverrides?.baseURL ?? this.config.defaultBaseURL,
+            apiKey: coordinatorOverrides?.apiKey ?? this.config.defaultApiKey,
+            systemPrompt: this.buildCoordinatorPrompt(agentConfigs, coordinatorOverrides, hasVerifyJudges),
+            maxTurns: coordinatorOverrides?.maxTurns ?? 3,
+            maxTokens: coordinatorOverrides?.maxTokens,
+            temperature: coordinatorOverrides?.temperature,
+            topP: coordinatorOverrides?.topP,
+            topK: coordinatorOverrides?.topK,
+            minP: coordinatorOverrides?.minP,
+            parallelToolCalls: coordinatorOverrides?.parallelToolCalls,
+            frequencyPenalty: coordinatorOverrides?.frequencyPenalty,
+            presencePenalty: coordinatorOverrides?.presencePenalty,
+            extraBody: coordinatorOverrides?.extraBody,
+            toolPreset: coordinatorOverrides?.toolPreset,
+            tools: coordinatorOverrides?.tools,
+            disallowedTools: coordinatorOverrides?.disallowedTools,
+            cwd: coordinatorOverrides?.cwd === undefined
+                ? this.config.defaultCwd
+                : coordinatorOverrides.cwd,
+            loopDetection: coordinatorOverrides?.loopDetection,
+            timeoutMs: coordinatorOverrides?.timeoutMs,
+        };
+    }
+    /**
+     * Run the coordinator synthesis pass over completed task results. Returns the
+     * synthesis result plus updated cumulative usage, or `null` when synthesis is
+     * skipped (run aborted, or the token budget was already exhausted before the
+     * pass). Emits `budget_exceeded` (when synthesis tips over budget) and
+     * `agent_complete`, mirroring the inline `runTeam` path. Does not mutate
+     * `agentResults` — the caller records the `'coordinator'` entry.
+     */
+    async runCoordinatorSynthesis(team, queue, goal, coordinatorBaseConfig, opts) {
+        if (opts.abortSignal?.aborted)
+            return null;
+        if (opts.maxTokenBudget !== undefined
+            && opts.cumulativeUsage.input_tokens + opts.cumulativeUsage.output_tokens > opts.maxTokenBudget) {
+            return null;
+        }
+        const synthesisPrompt = await this.buildSynthesisPrompt(goal, queue.list(), team);
+        const synthesisAgent = buildAgent(withModelRoute(coordinatorBaseConfig, routeMatches(opts.modelRouting, { phase: 'synthesis', agent: 'coordinator' })));
+        const synthTraceOptions = this.config.onTrace
+            ? { onTrace: this.config.onTrace, runId: opts.runId ?? '', traceAgent: 'coordinator' }
+            : undefined;
+        const result = await synthesisAgent.run(synthesisPrompt, synthTraceOptions);
+        const cumulativeUsage = addUsage(opts.cumulativeUsage, result.tokenUsage);
+        if (opts.maxTokenBudget !== undefined
+            && cumulativeUsage.input_tokens + cumulativeUsage.output_tokens > opts.maxTokenBudget) {
+            this.config.onProgress?.({
+                type: 'budget_exceeded',
+                agent: 'coordinator',
+                data: new TokenBudgetExceededError('coordinator', cumulativeUsage.input_tokens + cumulativeUsage.output_tokens, opts.maxTokenBudget),
+            });
+        }
+        this.config.onProgress?.({
+            type: 'agent_complete',
+            agent: 'coordinator',
+            data: result,
+        });
+        return { result, cumulativeUsage };
+    }
     /** Build the synthesis prompt shown to the coordinator after all tasks complete. */
     async buildSynthesisPrompt(goal, tasks, team) {
         const completedTasks = tasks.filter((t) => t.status === 'completed');
@@ -1379,18 +2010,20 @@ export class OpenMultiAgent {
             ...(task.retryBackoff !== undefined ? { retryBackoff: task.retryBackoff } : {}),
         }));
     }
-    async executeExplicitTaskQueue(team, queue, options, goal) {
+    async executeExplicitTaskQueue(team, queue, options, goal, initialAgentResults, activeCheckpoint, coordinatorForSynthesis) {
         const agentConfigs = team.getAgents();
         const scheduler = new Scheduler('dependency-first');
         scheduler.autoAssign(queue, agentConfigs);
         const pool = this.buildPool(agentConfigs);
-        const agentResults = new Map();
+        const agentResults = initialAgentResults ?? new Map();
+        const checkpoint = activeCheckpoint ?? this.createActiveCheckpoint(team, options?.checkpoint ?? this.config.checkpoint, 'runTasks', goal);
         const ctx = {
             team,
             pool,
             scheduler,
             agentResults,
             config: this.config,
+            ...(checkpoint ? { checkpoint } : {}),
             runId: this.config.onTrace ? generateRunId() : undefined,
             abortSignal: options?.abortSignal,
             cumulativeUsage: ZERO_USAGE,
@@ -1398,8 +2031,50 @@ export class OpenMultiAgent {
             budgetExceededTriggered: false,
             budgetExceededReason: undefined,
             taskMetrics: new Map(),
+            modelRouting: options?.modelRouting,
+            taskById: new Map(queue.list().map((task) => [task.id, task])),
+            taskLeafById: new Map(queue.list().map((task) => [task.id, isLeafTask(task, queue.list())])),
         };
         await executeQueue(queue, ctx);
+        // A resumed `runTeam` re-runs the coordinator synthesis so the restored
+        // result matches a fresh `runTeam` (a synthesized final answer, not raw
+        // per-task outputs). Best-effort: a missing/unusable coordinator config or
+        // a failing synthesis call must not discard the recovered work — on failure
+        // we surface `synthesis_failed` and fall back to raw outputs.
+        if (checkpoint?.mode === 'runTeam' && goal !== undefined) {
+            try {
+                const coordinatorBaseConfig = this.buildCoordinatorBaseConfig(coordinatorForSynthesis, agentConfigs, false);
+                const synthesis = await this.runCoordinatorSynthesis(team, queue, goal, coordinatorBaseConfig, {
+                    modelRouting: options?.modelRouting,
+                    runId: ctx.runId,
+                    abortSignal: options?.abortSignal,
+                    cumulativeUsage: ctx.cumulativeUsage,
+                    maxTokenBudget: ctx.maxTokenBudget,
+                });
+                if (synthesis !== null && synthesis.result.success) {
+                    agentResults.set('coordinator', synthesis.result);
+                    ctx.cumulativeUsage = synthesis.cumulativeUsage;
+                }
+                else if (synthesis !== null) {
+                    // Synthesis ran but the coordinator agent failed (e.g. the LLM call
+                    // errored). Keep the recovered task outputs and surface the failure
+                    // rather than attaching a failed answer under `'coordinator'`.
+                    this.config.onProgress?.({
+                        type: 'error',
+                        data: {
+                            kind: 'synthesis_failed',
+                            error: new Error(synthesis.result.output || 'coordinator synthesis failed'),
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                this.config.onProgress?.({
+                    type: 'error',
+                    data: { kind: 'synthesis_failed', error },
+                });
+            }
+        }
         const taskRecords = queue.list().map((task) => ({
             id: task.id,
             title: task.title,
@@ -1411,17 +2086,68 @@ export class OpenMultiAgent {
             maxRetries: task.maxRetries,
             retryDelayMs: task.retryDelayMs,
             retryBackoff: task.retryBackoff,
+            verify: task.verify,
             metrics: ctx.taskMetrics.get(task.id),
         }));
         return this.buildTeamRunResult(agentResults, goal, taskRecords);
     }
+    createActiveCheckpoint(team, config, mode, goal) {
+        if (config === undefined || config === false)
+            return undefined;
+        const options = config === true ? {} : config;
+        if (options.enabled === false)
+            return undefined;
+        // The instance-level fallback store is shared across every run on this
+        // orchestrator, so concurrent runs would overwrite each other at the
+        // default checkpoint key. Require a `runId` (or an explicit `key`/`store`)
+        // before falling back, so each run resolves to a distinct, resumable key.
+        const sharedStore = team.getSharedMemory();
+        const explicitStore = options.store ?? sharedStore;
+        if (!explicitStore && options.runId === undefined && options.key === undefined) {
+            throw new Error('Checkpoint requires a `runId` (or an explicit `store`/`key`) when the team has no ' +
+                'shared-memory store. Without one, concurrent runs would share the fallback store and ' +
+                "overwrite each other's checkpoint at the default key.");
+        }
+        const store = explicitStore ?? this.fallbackCheckpointStore;
+        return {
+            manager: new Checkpoint(store, options),
+            mode,
+            ...(goal !== undefined ? { goal } : {}),
+            ...(options.runId !== undefined ? { runId: options.runId } : {}),
+            reusesSharedMemoryStore: sharedStore !== undefined && store === sharedStore,
+            saveChain: Promise.resolve(),
+        };
+    }
+    agentResultsFromCheckpoint(snapshot, queue) {
+        const taskById = new Map(queue.list().map((task) => [task.id, task]));
+        const agentResults = new Map();
+        for (const completed of snapshot.completedTaskResults) {
+            const task = taskById.get(completed.taskId);
+            const assignee = completed.assignee ?? task?.assignee ?? 'unknown';
+            const output = completed.result ?? task?.result ?? '';
+            agentResults.set(`${assignee}:${completed.taskId}`, {
+                success: true,
+                output,
+                messages: [],
+                tokenUsage: ZERO_USAGE,
+                toolCalls: [],
+            });
+        }
+        return agentResults;
+    }
+    isPlanArtifact(value) {
+        if (value === null || typeof value !== 'object')
+            return false;
+        const artifact = value;
+        return artifact['version'] === 1 && Array.isArray(artifact['tasks']);
+    }
     /**
      * Load a list of task specs into a queue.
      *
      * Handles title-based `dependsOn` references by building a title→id map first,
      * then resolving them to real IDs before adding tasks to the queue.
      */
-    loadSpecsIntoQueue(specs, agentConfigs, queue) {
+    loadSpecsIntoQueue(specs, agentConfigs, queue, verifyJudges) {
         const agentNames = new Set(agentConfigs.map((a) => a.name));
         const normalizeTitle = (title) => title.toLowerCase().trim();
         const titleCounts = new Map();
@@ -1443,6 +2169,9 @@ export class OpenMultiAgent {
                 maxRetries: spec.maxRetries,
                 retryDelayMs: spec.retryDelayMs,
                 retryBackoff: spec.retryBackoff,
+                role: spec.role,
+                priority: spec.priority,
+                verify: resolveVerify(spec.verify, verifyJudges),
             });
             const titleKey = normalizeTitle(spec.title);
             if ((titleCounts.get(titleKey) ?? 0) === 1) {
@@ -1488,14 +2217,14 @@ export class OpenMultiAgent {
     buildPool(agentConfigs) {
         const pool = new AgentPool(this.config.maxConcurrency);
         for (const config of agentConfigs) {
-            const effective = {
+            const effective = applyDefaultToolPreset({
                 ...config,
                 model: config.model,
                 provider: config.provider ?? this.config.defaultProvider,
                 baseURL: config.baseURL ?? this.config.defaultBaseURL,
                 apiKey: config.apiKey ?? this.config.defaultApiKey,
                 cwd: config.cwd === undefined ? this.config.defaultCwd : config.cwd,
-            };
+            }, this.config.defaultToolPreset);
             pool.add(buildAgent(effective, { includeDelegateTool: true }));
         }
         return pool;