oxe-cc 1.0.0 → 1.3.0

package/lib/runtime/projection/projection-engine.js

@@ -66,7 +66,7 @@ class ProjectionEngine {
         }
         return lines.join('\n');
     }
-    projectVerify(state, results, checkResults) {
+    projectVerify(state, results, checkResults, manifest, riskLedger, evidenceCoverage) {
         const run = state.run;
         const lines = [
             '# OXE — Verificação',
@@ -92,6 +92,33 @@ class ProjectionEngine {
             }
             lines.push('');
         }
+        if (manifest) {
+            lines.push('## Verification Manifest');
+            lines.push('');
+            lines.push(`- **Checks:** ${manifest.summary.total}`);
+            lines.push(`- **Pass:** ${manifest.summary.pass}`);
+            lines.push(`- **Fail:** ${manifest.summary.fail}`);
+            lines.push(`- **Skip:** ${manifest.summary.skip}`);
+            lines.push(`- **Errors:** ${manifest.summary.error}`);
+            lines.push(`- **All passed:** ${manifest.summary.all_passed ? 'sim' : 'não'}`);
+            lines.push('');
+        }
+        if (evidenceCoverage) {
+            lines.push('## Evidence Coverage');
+            lines.push('');
+            lines.push(`- **Checks com evidência:** ${evidenceCoverage.checks_with_evidence}/${evidenceCoverage.total_checks}`);
+            lines.push(`- **Refs totais:** ${evidenceCoverage.total_evidence_refs}`);
+            lines.push(`- **Cobertura:** ${evidenceCoverage.coverage_percent}%`);
+            lines.push('');
+        }
+        if (riskLedger && riskLedger.risks.length > 0) {
+            lines.push('## Residual Risks');
+            lines.push('');
+            for (const risk of riskLedger.risks) {
+                lines.push(`- [${risk.severity.toUpperCase()}] ${risk.description}`);
+            }
+            lines.push('');
+        }
         if (checkResults && checkResults.length > 0) {
             lines.push('## Resultados dos checks executados');
             lines.push('');
@@ -181,11 +208,50 @@ class ProjectionEngine {
         return lines.join('\n');
     }
     projectPRSummary(state, graph) {
+        return this.projectPromotionSummary(state, graph);
+    }
+    projectCommitSummary(state, graph) {
         const run = state.run;
         const completed = [...state.completedWorkItems];
         const failed = [...state.failedWorkItems];
+        const blocked = [...state.blockedWorkItems];
         const lines = [
-            '## Summary',
+            '## Commit Summary',
+            '',
+            `**Run:** \`${run?.run_id ?? '—'}\``,
+            `**Status:** ${run?.status ?? '—'}`,
+            '',
+            '### Included work items',
+            '',
+        ];
+        for (const id of completed) {
+            const node = graph.nodes.get(id);
+            lines.push(`- ✓ ${node?.title ?? id} (\`${id}\`)`);
+        }
+        if (failed.length || blocked.length) {
+            lines.push('');
+            lines.push('### Attention points');
+            lines.push('');
+            for (const id of failed) {
+                const node = graph.nodes.get(id);
+                lines.push(`- ✗ ${node?.title ?? id} (\`${id}\`)`);
+            }
+            for (const id of blocked) {
+                const node = graph.nodes.get(id);
+                lines.push(`- ⊘ ${node?.title ?? id} (\`${id}\`)`);
+            }
+        }
+        lines.push('');
+        lines.push('Generated by OXE Runtime.');
+        return lines.join('\n');
+    }
+    projectPromotionSummary(state, graph) {
+        const run = state.run;
+        const completed = [...state.completedWorkItems];
+        const failed = [...state.failedWorkItems];
+        const blocked = [...state.blockedWorkItems];
+        const lines = [
+            '## Promotion Summary',
             '',
         ];
         if (completed.length > 0) {
@@ -194,13 +260,17 @@ class ProjectionEngine {
                 lines.push(`- ✓ ${node?.title ?? id} (\`${id}\`)`);
             }
         }
-        if (failed.length > 0) {
+        if (failed.length > 0 || blocked.length > 0) {
             lines.push('');
             lines.push('**⚠️ Incomplete tasks:**');
             for (const id of failed) {
                 const node = graph.nodes.get(id);
                 lines.push(`- ✗ ${node?.title ?? id} (\`${id}\`)`);
             }
+            for (const id of blocked) {
+                const node = graph.nodes.get(id);
+                lines.push(`- ⊘ ${node?.title ?? id} (\`${id}\`)`);
+            }
         }
         lines.push('');
         lines.push('## Test plan');

package/lib/runtime/reducers/run-state-reducer.d.ts

@@ -3,6 +3,17 @@ import type { Run } from '../models/run';
 import type { WorkItem } from '../models/work-item';
 import type { Attempt } from '../models/attempt';
 import type { Workspace } from '../models/workspace';
+export interface PolicyDecisionRecord {
+    allowed: boolean;
+    gate_required: boolean;
+    reason: string;
+    rule_id: string | null;
+}
+export interface ToolFailureRecord {
+    tool: string;
+    error: string;
+    timestamp: string;
+}
 export interface RunState {
     run: Run | null;
     workItems: Map<string, WorkItem>;
@@ -11,6 +22,16 @@ export interface RunState {
     completedWorkItems: Set<string>;
     failedWorkItems: Set<string>;
     blockedWorkItems: Set<string>;
+    retryCounts: Map<string, number>;
+    policyDecisions: Map<string, PolicyDecisionRecord>;
+    pendingGates: Set<string>;
+    resolvedGates: Map<string, {
+        decision: string;
+        actor?: string;
+    }>;
+    verificationStatus: Map<string, 'started' | 'completed' | 'failed'>;
+    evidenceRefs: Map<string, string[]>;
+    toolFailures: Map<string, ToolFailureRecord[]>;
 }
 export declare function createEmptyRunState(): RunState;
 export declare function reduce(events: OxeEvent[]): RunState;
@@ -18,3 +39,8 @@ export { applyEvent as applyEventExported };
 declare function applyEvent(state: RunState, event: OxeEvent): RunState;
 export declare function getWorkItemStatus(state: RunState, workItemId: string): WorkItem['status'] | null;
 export declare function getAttemptCount(state: RunState, workItemId: string): number;
+export declare function getRetryCount(state: RunState, workItemId: string): number;
+export declare function getPolicyDecision(state: RunState, workItemId: string): PolicyDecisionRecord | null;
+export declare function getVerificationStatus(state: RunState, workItemId: string): 'started' | 'completed' | 'failed' | null;
+export declare function getEvidenceRefs(state: RunState, workItemId: string): string[];
+export declare function getToolFailures(state: RunState, workItemId: string): ToolFailureRecord[];

package/lib/runtime/reducers/run-state-reducer.js

@@ -5,6 +5,11 @@ exports.reduce = reduce;
 exports.applyEventExported = applyEvent;
 exports.getWorkItemStatus = getWorkItemStatus;
 exports.getAttemptCount = getAttemptCount;
+exports.getRetryCount = getRetryCount;
+exports.getPolicyDecision = getPolicyDecision;
+exports.getVerificationStatus = getVerificationStatus;
+exports.getEvidenceRefs = getEvidenceRefs;
+exports.getToolFailures = getToolFailures;
 function createEmptyRunState() {
     return {
         run: null,
@@ -14,6 +19,13 @@ function createEmptyRunState() {
         completedWorkItems: new Set(),
         failedWorkItems: new Set(),
         blockedWorkItems: new Set(),
+        retryCounts: new Map(),
+        policyDecisions: new Map(),
+        pendingGates: new Set(),
+        resolvedGates: new Map(),
+        verificationStatus: new Map(),
+        evidenceRefs: new Map(),
+        toolFailures: new Map(),
     };
 }
 function reduce(events) {
@@ -43,7 +55,6 @@ function applyEvent(state, event) {
                 workItems.set(event.work_item_id, { ...existing, status: 'ready' });
             }
             else {
-                // First time we see this work item — create from payload
                 const item = event.payload;
                 workItems.set(event.work_item_id, { ...item, work_item_id: event.work_item_id, status: 'ready' });
             }
@@ -85,6 +96,14 @@ function applyEvent(state, event) {
                 workItems.set(event.work_item_id, { ...item, status: 'completed' });
             const completedWorkItems = new Set(state.completedWorkItems);
             completedWorkItems.add(event.work_item_id);
+            // Collect evidence refs from payload
+            const evidence = event.payload.evidence ?? [];
+            if (evidence.length > 0) {
+                const evidenceRefs = new Map(state.evidenceRefs);
+                const existing = evidenceRefs.get(event.work_item_id) ?? [];
+                evidenceRefs.set(event.work_item_id, [...existing, ...evidence]);
+                return { ...state, workItems, completedWorkItems, evidenceRefs };
+            }
             return { ...state, workItems, completedWorkItems };
         }
         case 'WorkItemBlocked': {
@@ -98,6 +117,88 @@ function applyEvent(state, event) {
             blockedWorkItems.add(event.work_item_id);
             return { ...state, workItems, blockedWorkItems };
         }
+        case 'RetryScheduled': {
+            if (!event.work_item_id)
+                return state;
+            const retryCounts = new Map(state.retryCounts);
+            const current = retryCounts.get(event.work_item_id) ?? 0;
+            retryCounts.set(event.work_item_id, current + 1);
+            return { ...state, retryCounts };
+        }
+        case 'PolicyEvaluated': {
+            const p = event.payload;
+            const key = p.work_item_id ?? event.work_item_id;
+            if (!key)
+                return state;
+            const policyDecisions = new Map(state.policyDecisions);
+            policyDecisions.set(key, {
+                allowed: p.allowed ?? true,
+                gate_required: p.gate_required ?? false,
+                reason: p.reason ?? '',
+                rule_id: p.rule_id ?? null,
+            });
+            return { ...state, policyDecisions };
+        }
+        case 'GateRequested': {
+            const gateId = event.payload.gate_id;
+            if (!gateId)
+                return state;
+            const pendingGates = new Set(state.pendingGates);
+            pendingGates.add(gateId);
+            return { ...state, pendingGates };
+        }
+        case 'GateResolved': {
+            const p = event.payload;
+            if (!p.gate_id)
+                return state;
+            const pendingGates = new Set(state.pendingGates);
+            pendingGates.delete(p.gate_id);
+            const resolvedGates = new Map(state.resolvedGates);
+            resolvedGates.set(p.gate_id, { decision: p.decision ?? 'approved', actor: p.actor });
+            return { ...state, pendingGates, resolvedGates };
+        }
+        case 'VerificationStarted': {
+            const key = event.work_item_id ?? event.payload.work_item_id;
+            if (!key)
+                return state;
+            const verificationStatus = new Map(state.verificationStatus);
+            verificationStatus.set(key, 'started');
+            return { ...state, verificationStatus };
+        }
+        case 'VerificationCompleted': {
+            const p = event.payload;
+            const key = event.work_item_id ?? p.work_item_id;
+            if (!key)
+                return state;
+            const verificationStatus = new Map(state.verificationStatus);
+            verificationStatus.set(key, p.status ?? 'completed');
+            return { ...state, verificationStatus };
+        }
+        case 'ToolFailed': {
+            if (!event.work_item_id)
+                return state;
+            const p = event.payload;
+            const toolFailures = new Map(state.toolFailures);
+            const existing = toolFailures.get(event.work_item_id) ?? [];
+            toolFailures.set(event.work_item_id, [
+                ...existing,
+                { tool: p.tool ?? 'unknown', error: p.error ?? '', timestamp: event.timestamp },
+            ]);
+            return { ...state, toolFailures };
+        }
+        case 'EvidenceCollected': {
+            const p = event.payload;
+            const key = event.work_item_id ?? p.work_item_id;
+            if (!key)
+                return state;
+            const refs = p.refs ?? (p.ref ? [p.ref] : []);
+            if (refs.length === 0)
+                return state;
+            const evidenceRefs = new Map(state.evidenceRefs);
+            const existing = evidenceRefs.get(key) ?? [];
+            evidenceRefs.set(key, [...existing, ...refs]);
+            return { ...state, evidenceRefs };
+        }
         default:
             return state;
     }
@@ -108,3 +209,18 @@ function getWorkItemStatus(state, workItemId) {
 function getAttemptCount(state, workItemId) {
     return state.attempts.get(workItemId)?.length ?? 0;
 }
+function getRetryCount(state, workItemId) {
+    return state.retryCounts.get(workItemId) ?? 0;
+}
+function getPolicyDecision(state, workItemId) {
+    return state.policyDecisions.get(workItemId) ?? null;
+}
+function getVerificationStatus(state, workItemId) {
+    return state.verificationStatus.get(workItemId) ?? null;
+}
+function getEvidenceRefs(state, workItemId) {
+    return state.evidenceRefs.get(workItemId) ?? [];
+}
+function getToolFailures(state, workItemId) {
+    return state.toolFailures.get(workItemId) ?? [];
+}

package/lib/runtime/scheduler/agent-registry.d.ts

@@ -0,0 +1,44 @@
+import type { TaskExecutor } from './scheduler';
+import type { WorkspaceManager } from '../workspace/workspace-manager';
+import type { AgentRole, AgentActionLog } from './agent-roles';
+export type AgentStatus = 'idle' | 'running' | 'paused' | 'failed' | 'timeout';
+export interface AgentHeartbeat {
+    agent_id: string;
+    last_seen: string;
+    current_task: string | null;
+    status: AgentStatus;
+}
+export interface RegisteredAgent {
+    id: string;
+    executor: TaskExecutor;
+    workspaceManager: WorkspaceManager;
+    assignedTaskIds: string[];
+    heartbeat: AgentHeartbeat;
+    role?: AgentRole;
+    actionLog: AgentActionLog[];
+}
+export declare class AgentRegistry {
+    private agents;
+    private readonly heartbeatTimeoutMs;
+    constructor(heartbeatTimeoutMs?: number);
+    register(id: string, executor: TaskExecutor, workspaceManager: WorkspaceManager, assignedTaskIds?: string[], role?: AgentRole): RegisteredAgent;
+    unregister(id: string): void;
+    beat(id: string, currentTask?: string | null): void;
+    setStatus(id: string, status: AgentStatus): void;
+    isAlive(id: string): boolean;
+    /** Returns agents that haven't sent a heartbeat within the timeout window */
+    timedOut(): RegisteredAgent[];
+    liveAgents(): RegisteredAgent[];
+    get(id: string): RegisteredAgent | null;
+    list(): RegisteredAgent[];
+    /**
+     * Reassign orphaned tasks from timed-out agents to a fallback agent.
+     * Returns the list of task IDs that were reassigned.
+     */
+    failover(fallbackAgentId: string): string[];
+    /** Return all agents assigned to a given role */
+    getByRole(role: AgentRole): RegisteredAgent[];
+    /** Append an action log entry for a registered agent (no-op if unknown) */
+    logAction(agentId: string, log: AgentActionLog): void;
+    clear(): void;
+}

package/lib/runtime/scheduler/agent-registry.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRegistry = void 0;
+class AgentRegistry {
+    constructor(heartbeatTimeoutMs = 30000) {
+        this.agents = new Map();
+        this.heartbeatTimeoutMs = heartbeatTimeoutMs;
+    }
+    register(id, executor, workspaceManager, assignedTaskIds = [], role) {
+        if (this.agents.has(id))
+            throw new Error(`Agent "${id}" is already registered`);
+        const agent = {
+            id,
+            executor,
+            workspaceManager,
+            assignedTaskIds,
+            heartbeat: {
+                agent_id: id,
+                last_seen: new Date().toISOString(),
+                current_task: null,
+                status: 'idle',
+            },
+            role,
+            actionLog: [],
+        };
+        this.agents.set(id, agent);
+        return agent;
+    }
+    unregister(id) {
+        this.agents.delete(id);
+    }
+    beat(id, currentTask = null) {
+        const agent = this.agents.get(id);
+        if (!agent)
+            return;
+        agent.heartbeat.last_seen = new Date().toISOString();
+        agent.heartbeat.current_task = currentTask;
+        agent.heartbeat.status = currentTask ? 'running' : 'idle';
+    }
+    setStatus(id, status) {
+        const agent = this.agents.get(id);
+        if (agent)
+            agent.heartbeat.status = status;
+    }
+    isAlive(id) {
+        const agent = this.agents.get(id);
+        if (!agent)
+            return false;
+        const elapsed = Date.now() - new Date(agent.heartbeat.last_seen).getTime();
+        return elapsed < this.heartbeatTimeoutMs;
+    }
+    /** Returns agents that haven't sent a heartbeat within the timeout window */
+    timedOut() {
+        return [...this.agents.values()].filter((a) => !this.isAlive(a.id));
+    }
+    liveAgents() {
+        return [...this.agents.values()].filter((a) => this.isAlive(a.id));
+    }
+    get(id) {
+        return this.agents.get(id) ?? null;
+    }
+    list() {
+        return [...this.agents.values()];
+    }
+    /**
+     * Reassign orphaned tasks from timed-out agents to a fallback agent.
+     * Returns the list of task IDs that were reassigned.
+     */
+    failover(fallbackAgentId) {
+        const fallback = this.agents.get(fallbackAgentId);
+        if (!fallback)
+            throw new Error(`Fallback agent "${fallbackAgentId}" not found`);
+        const orphaned = [];
+        for (const agent of this.timedOut()) {
+            orphaned.push(...agent.assignedTaskIds);
+            agent.assignedTaskIds = [];
+            agent.heartbeat.status = 'failed';
+        }
+        fallback.assignedTaskIds = [...fallback.assignedTaskIds, ...orphaned];
+        return orphaned;
+    }
+    /** Return all agents assigned to a given role */
+    getByRole(role) {
+        return [...this.agents.values()].filter((a) => a.role === role);
+    }
+    /** Append an action log entry for a registered agent (no-op if unknown) */
+    logAction(agentId, log) {
+        const agent = this.agents.get(agentId);
+        if (agent)
+            agent.actionLog.push(log);
+    }
+    clear() {
+        this.agents.clear();
+    }
+}
+exports.AgentRegistry = AgentRegistry;

package/lib/runtime/scheduler/agent-roles.d.ts

@@ -0,0 +1,54 @@
+import type { TaskResult } from './scheduler';
+export type AgentRole = 'planner' | 'executor' | 'reviewer' | 'verifier';
+export interface AgentBudget {
+    max_tokens: number;
+    max_time_ms: number;
+    max_retries: number;
+    consumed_tokens: number;
+    consumed_time_ms: number;
+    consumed_retries: number;
+}
+export interface CooperativeHandoff {
+    handoff_id: string;
+    from_agent_id: string;
+    to_agent_id: string;
+    from_role: AgentRole;
+    to_role: AgentRole;
+    work_item_id: string;
+    context_pack_ref: string | null;
+    transferred_at: string;
+}
+export interface AgentActionLog {
+    agent_id: string;
+    role: AgentRole;
+    work_item_id: string;
+    action: 'execute' | 'verify' | 'review' | 'plan';
+    result: 'success' | 'failure';
+    duration_ms: number;
+    timestamp: string;
+}
+export declare function createBudget(opts?: Partial<Omit<AgentBudget, 'consumed_tokens' | 'consumed_time_ms' | 'consumed_retries'>>): AgentBudget;
+export declare function consumeBudget(budget: AgentBudget, delta: {
+    tokens?: number;
+    time_ms?: number;
+    retries?: number;
+}): AgentBudget;
+export declare function isBudgetExhausted(budget: AgentBudget): boolean;
+export declare function buildHandoff(opts: {
+    from_agent_id: string;
+    to_agent_id: string;
+    from_role: AgentRole;
+    to_role: AgentRole;
+    work_item_id: string;
+    context_pack_ref?: string | null;
+}): CooperativeHandoff;
+export declare class ArbitrationEngine {
+    /**
+     * Choose the best result from multiple competing agents.
+     * Prefers success; among successes prefers more evidence; falls back to first.
+     */
+    arbitrate(results: Array<{
+        agent_id: string;
+        result: TaskResult;
+    }>): TaskResult;
+}

package/lib/runtime/scheduler/agent-roles.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArbitrationEngine = void 0;
+exports.createBudget = createBudget;
+exports.consumeBudget = consumeBudget;
+exports.isBudgetExhausted = isBudgetExhausted;
+exports.buildHandoff = buildHandoff;
+function createBudget(opts = {}) {
+    return {
+        max_tokens: opts.max_tokens ?? Infinity,
+        max_time_ms: opts.max_time_ms ?? Infinity,
+        max_retries: opts.max_retries ?? Infinity,
+        consumed_tokens: 0,
+        consumed_time_ms: 0,
+        consumed_retries: 0,
+    };
+}
+function consumeBudget(budget, delta) {
+    return {
+        ...budget,
+        consumed_tokens: budget.consumed_tokens + (delta.tokens ?? 0),
+        consumed_time_ms: budget.consumed_time_ms + (delta.time_ms ?? 0),
+        consumed_retries: budget.consumed_retries + (delta.retries ?? 0),
+    };
+}
+function isBudgetExhausted(budget) {
+    return (budget.consumed_tokens >= budget.max_tokens ||
+        budget.consumed_time_ms >= budget.max_time_ms ||
+        budget.consumed_retries >= budget.max_retries);
+}
+function buildHandoff(opts) {
+    return {
+        handoff_id: `hoff-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+        from_agent_id: opts.from_agent_id,
+        to_agent_id: opts.to_agent_id,
+        from_role: opts.from_role,
+        to_role: opts.to_role,
+        work_item_id: opts.work_item_id,
+        context_pack_ref: opts.context_pack_ref ?? null,
+        transferred_at: new Date().toISOString(),
+    };
+}
+// ─── ArbitrationEngine ────────────────────────────────────────────────────────
+class ArbitrationEngine {
+    /**
+     * Choose the best result from multiple competing agents.
+     * Prefers success; among successes prefers more evidence; falls back to first.
+     */
+    arbitrate(results) {
+        if (results.length === 0) {
+            return { success: false, failure_class: null, evidence: [], output: 'no results to arbitrate' };
+        }
+        const successes = results.filter((r) => r.result.success);
+        if (successes.length === 0) {
+            return results[0].result;
+        }
+        // Among successes, prefer the one with most evidence
+        successes.sort((a, b) => b.result.evidence.length - a.result.evidence.length);
+        return successes[0].result;
+    }
+}
+exports.ArbitrationEngine = ArbitrationEngine;

package/lib/runtime/scheduler/index.d.ts

@@ -1 +1,4 @@
 export * from './scheduler';
+export * from './run-journal';
+export * from './agent-registry';
+export * from './agent-roles';

package/lib/runtime/scheduler/index.js

@@ -15,3 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./scheduler"), exports);
+__exportStar(require("./run-journal"), exports);
+__exportStar(require("./agent-registry"), exports);
+__exportStar(require("./agent-roles"), exports);

package/lib/runtime/scheduler/multi-agent-coordinator.d.ts

@@ -1,6 +1,7 @@
 import type { ExecutionGraph } from '../compiler/graph-compiler';
 import type { WorkspaceManager } from '../workspace/workspace-manager';
-import type { TaskExecutor, SchedulerContext } from './scheduler';
+import type { TaskExecutor, TaskResult, SchedulerContext } from './scheduler';
+import type { CooperativeHandoff } from './agent-roles';
 export type CoordinationMode = 'parallel' | 'competitive' | 'cooperative';
 export interface AgentSpec {
     id: string;
@@ -17,6 +18,44 @@ export interface CoordinationOptions {
     runId: string;
     onEvent?: SchedulerContext['onEvent'];
 }
+export interface ArbitrationRecord {
+    work_item_id: string;
+    mode: CoordinationMode;
+    winner_agent_id: string | null;
+    participant_agent_ids: string[];
+    success: boolean;
+    failure_class: TaskResult['failure_class'];
+    evidence_count: number;
+    recorded_at: string;
+}
+export interface MultiAgentOwnership {
+    work_item_id: string;
+    owner_agent_id: string;
+}
+export interface MultiAgentStatusSnapshot {
+    run_id: string;
+    mode: CoordinationMode;
+    workspace_isolation_required: 'isolated';
+    workspace_isolation_enforced: boolean;
+    agent_count: number;
+    ownership: MultiAgentOwnership[];
+    completed: string[];
+    failed: string[];
+    blocked: string[];
+    agent_results: Array<{
+        agent_id: string;
+        isolation_level: 'shared' | 'isolated';
+        assigned_task_ids: string[];
+        completed: string[];
+        failed: string[];
+    }>;
+    orphan_reassignments: Array<{
+        from_agent_id: string;
+        to_agent_id: string;
+        work_item_ids: string[];
+    }>;
+    updated_at: string;
+}
 export interface CoordinationResult {
     mode: CoordinationMode;
     run_id: string;
@@ -28,7 +67,12 @@ export interface CoordinationResult {
         completed: string[];
         failed: string[];
     }>;
+    handoffs?: CooperativeHandoff[];
+    arbitration_results?: ArbitrationRecord[];
+    state?: MultiAgentStatusSnapshot;
 }
 export declare class MultiAgentCoordinator {
     run(graph: ExecutionGraph, opts: CoordinationOptions): Promise<CoordinationResult>;
 }
+export declare function multiAgentStatePath(projectRoot: string, runId: string): string;
+export declare function loadMultiAgentState(projectRoot: string, runId: string): MultiAgentStatusSnapshot | null;