@shapeshift-labs/frontier-swarm 0.5.21 → 0.5.22

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import type { JsonObject, JsonValue } from '@shapeshift-labs/frontier';
+import { type FrontierRunActorId, type FrontierRunDashboardSnapshot, type FrontierRunEvent, type FrontierRunEventId, type FrontierRunProjection } from '@shapeshift-labs/frontier-run';
 export declare const FRONTIER_SWARM_MANIFEST_KIND = "frontier.swarm.manifest";
 export declare const FRONTIER_SWARM_MANIFEST_VERSION = 1;
 export declare const FRONTIER_SWARM_TASK_KIND = "frontier.swarm.task";
@@ -11,6 +12,22 @@ export declare const FRONTIER_SWARM_EVENT_KIND = "frontier.swarm.event";
 export declare const FRONTIER_SWARM_EVENT_VERSION = 1;
 export declare const FRONTIER_SWARM_EVENT_STREAM_KIND = "frontier.swarm.event-stream";
 export declare const FRONTIER_SWARM_EVENT_STREAM_VERSION = 1;
+export declare const FRONTIER_SWARM_RUN_GRAPH_KIND = "frontier.swarm.run-graph";
+export declare const FRONTIER_SWARM_RUN_GRAPH_VERSION = 1;
+export declare const FRONTIER_SWARM_GRAPH_SNAPSHOT_KIND = "frontier.swarm.graph-snapshot";
+export declare const FRONTIER_SWARM_GRAPH_SNAPSHOT_VERSION = 1;
+export declare const FRONTIER_SWARM_RUN_GRAPH_CHUNK_KIND = "frontier.swarm.run-graph-chunk";
+export declare const FRONTIER_SWARM_RUN_GRAPH_CHUNK_VERSION = 1;
+export declare const FRONTIER_SWARM_GATE_RECORD_KIND = "frontier.swarm.gate-record";
+export declare const FRONTIER_SWARM_GATE_RECORD_VERSION = 1;
+export declare const FRONTIER_SWARM_EVIDENCE_RECORD_KIND = "frontier.swarm.evidence-record";
+export declare const FRONTIER_SWARM_EVIDENCE_RECORD_VERSION = 1;
+export declare const FRONTIER_SWARM_PATCH_EVENT_KIND = "frontier.swarm.patch-event";
+export declare const FRONTIER_SWARM_PATCH_EVENT_VERSION = 1;
+export declare const FRONTIER_SWARM_REPLAY_RECORD_KIND = "frontier.swarm.replay-record";
+export declare const FRONTIER_SWARM_REPLAY_RECORD_VERSION = 1;
+export declare const FRONTIER_SWARM_IMPROVEMENT_LOOP_KIND = "frontier.swarm.improvement-loop";
+export declare const FRONTIER_SWARM_IMPROVEMENT_LOOP_VERSION = 1;
 export declare const FRONTIER_SWARM_MAILBOX_KIND = "frontier.swarm.mailbox";
 export declare const FRONTIER_SWARM_MAILBOX_VERSION = 1;
 export declare const FRONTIER_SWARM_PROOF_KIND = "frontier.swarm.proof";
@@ -31,6 +48,10 @@ export declare const FRONTIER_SWARM_MERGE_PLAN_KIND = "frontier.swarm.merge-plan
 export declare const FRONTIER_SWARM_MERGE_PLAN_VERSION = 1;
 export declare const FRONTIER_SWARM_MERGE_BUNDLE_KIND = "frontier.swarm.merge-bundle";
 export declare const FRONTIER_SWARM_MERGE_BUNDLE_VERSION = 1;
+export declare const FRONTIER_SWARM_SEMANTIC_CHANGE_KIND = "frontier.swarm.semantic-change";
+export declare const FRONTIER_SWARM_SEMANTIC_CHANGE_VERSION = 1;
+export declare const FRONTIER_SWARM_MERGE_CANDIDATE_KIND = "frontier.swarm.merge-candidate";
+export declare const FRONTIER_SWARM_MERGE_CANDIDATE_VERSION = 1;
 export declare const FRONTIER_SWARM_QUEUE_OVERLAY_KIND = "frontier.swarm.queue-overlay";
 export declare const FRONTIER_SWARM_QUEUE_OVERLAY_VERSION = 1;
 export declare const FRONTIER_SWARM_MERGE_INDEX_KIND = "frontier.swarm.merge-index";
@@ -97,6 +118,8 @@ export declare const FRONTIER_SWARM_QUEUE_OUTCOME_MODEL_KIND = "frontier.swarm.q
 export declare const FRONTIER_SWARM_QUEUE_OUTCOME_MODEL_VERSION = 1;
 export declare const FRONTIER_SWARM_TERMINAL_STATE_RECONCILIATION_KIND = "frontier.swarm.terminal-state-reconciliation";
 export declare const FRONTIER_SWARM_TERMINAL_STATE_RECONCILIATION_VERSION = 1;
+export declare const FRONTIER_SWARM_TERMINAL_OUTCOME_RECORD_KIND = "frontier.swarm.terminal-outcome-record";
+export declare const FRONTIER_SWARM_TERMINAL_OUTCOME_RECORD_VERSION = 1;
 export declare const FRONTIER_SWARM_PRIORITY_POLICY_KIND = "frontier.swarm.priority-policy";
 export declare const FRONTIER_SWARM_PRIORITY_POLICY_VERSION = 1;
 export declare const FRONTIER_SWARM_MODEL_ROUTE_KIND = "frontier.swarm.model-route";
@@ -111,6 +134,10 @@ export declare const FRONTIER_SWARM_DEFAULT_CODEX_COMPUTE_ID = "codex.gpt-5.5.xh
 export declare const FRONTIER_SWARM_DEFAULT_MODEL = "gpt-5.5";
 export declare const FRONTIER_SWARM_DEFAULT_REASONING_EFFORT = "xhigh";
 export declare const FRONTIER_SWARM_VERIFICATION_CATEGORY_HINTS: readonly ["build", "typecheck", "smoke", "unit", "fuzz", "browser", "oracle"];
+export declare const FRONTIER_SWARM_GRAPH_NODE_KINDS: readonly ["intent", "task", "worker", "candidate", "evidence", "gate", "decision", "merge", "replay", "rsi"];
+export declare const FRONTIER_SWARM_GRAPH_EDGE_KINDS: readonly ["dependsOn", "blocks", "produces", "verifies", "conflictsWith", "supersedes", "mergesInto"];
+export declare const FRONTIER_SWARM_MERGE_CANDIDATE_ADMISSION_STATUSES: readonly ["safe", "safe-with-losses", "review-required", "blocked"];
+export declare const FRONTIER_SWARM_MERGE_CANDIDATE_REASON_CODES: readonly ["missing-sidecar", "empty-sidecar", "stale-source-hash", "symbol-conflict", "effect-conflict", "lossy-import", "tests-missing"];
 export type FrontierSwarmComputeKind = 'codex' | 'shell' | 'human' | 'external' | string;
 export type FrontierSwarmReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | string;
 export type FrontierSwarmPolicyMode = 'advisory' | 'hard-file-ownership' | string;
@@ -905,6 +932,517 @@ export interface FrontierSwarmJobGraphEdge {
     to: string;
     type: 'depends-on' | 'parent-task';
 }
+export type FrontierSwarmGraphNodeKind = (typeof FRONTIER_SWARM_GRAPH_NODE_KINDS)[number] | string;
+export type FrontierSwarmGraphEdgeKind = (typeof FRONTIER_SWARM_GRAPH_EDGE_KINDS)[number] | string;
+export type FrontierSwarmGraphStatus = 'pending' | 'running' | 'passed' | 'failed' | 'accepted' | 'rejected' | 'blocked' | 'superseded' | 'unknown' | string;
+export interface FrontierSwarmGraphNodeInput {
+    id?: string;
+    kind: FrontierSwarmGraphNodeKind;
+    title?: string;
+    status?: FrontierSwarmGraphStatus;
+    jobId?: string;
+    taskId?: string;
+    path?: string;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmGraphNode {
+    id: string;
+    kind: FrontierSwarmGraphNodeKind;
+    title?: string;
+    status?: FrontierSwarmGraphStatus;
+    jobId?: string;
+    taskId?: string;
+    path?: string;
+    generatedAt?: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmGraphEdgeInput {
+    id?: string;
+    from: string;
+    to: string;
+    kind: FrontierSwarmGraphEdgeKind;
+    label?: string;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmGraphEdge {
+    id: string;
+    from: string;
+    to: string;
+    kind: FrontierSwarmGraphEdgeKind;
+    label?: string;
+    generatedAt?: number;
+    metadata?: JsonObject;
+}
+export type FrontierSwarmMergeCandidateAdmissionStatus = (typeof FRONTIER_SWARM_MERGE_CANDIDATE_ADMISSION_STATUSES)[number] | string;
+export type FrontierSwarmMergeCandidateReasonCode = (typeof FRONTIER_SWARM_MERGE_CANDIDATE_REASON_CODES)[number] | string;
+export type FrontierSwarmSemanticChangeOperation = 'add' | 'modify' | 'delete' | 'move' | 'rename' | 'replace' | 'unknown' | string;
+export type FrontierSwarmSemanticChangeConfidence = FrontierSwarmConfidence | number;
+export interface FrontierSwarmSourceSpanInput {
+    path?: string;
+    startLine?: number;
+    startColumn?: number;
+    endLine?: number;
+    endColumn?: number;
+    startOffset?: number;
+    endOffset?: number;
+    sourceHash?: string;
+    expectedSourceHash?: string;
+    metadata?: unknown;
+}
+export interface FrontierSwarmSourceSpan {
+    path?: string;
+    startLine?: number;
+    startColumn?: number;
+    endLine?: number;
+    endColumn?: number;
+    startOffset?: number;
+    endOffset?: number;
+    sourceHash?: string;
+    expectedSourceHash?: string;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmSemanticChangeInput {
+    id?: string;
+    symbolId: string;
+    declarationKind: string;
+    sourceSpan?: FrontierSwarmSourceSpanInput;
+    sourcePath?: string;
+    sourceHash?: string;
+    expectedSourceHash?: string;
+    operation: FrontierSwarmSemanticChangeOperation;
+    confidence?: FrontierSwarmSemanticChangeConfidence;
+    conflictReason?: FrontierSwarmMergeCandidateReasonCode;
+    status?: FrontierSwarmMergeCandidateAdmissionStatus;
+    reasonCodes?: readonly FrontierSwarmMergeCandidateReasonCode[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmSemanticChange {
+    kind: typeof FRONTIER_SWARM_SEMANTIC_CHANGE_KIND;
+    version: typeof FRONTIER_SWARM_SEMANTIC_CHANGE_VERSION;
+    id: string;
+    symbolId: string;
+    declarationKind: string;
+    sourceSpan: FrontierSwarmSourceSpan;
+    operation: FrontierSwarmSemanticChangeOperation;
+    confidence: FrontierSwarmSemanticChangeConfidence;
+    conflictReason?: FrontierSwarmMergeCandidateReasonCode;
+    status: FrontierSwarmMergeCandidateAdmissionStatus;
+    reasonCodes: FrontierSwarmMergeCandidateReasonCode[];
+    generatedAt: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmMergeCandidateInput {
+    id?: string;
+    jobId?: string;
+    taskId?: string;
+    lane?: string;
+    title?: string;
+    sidecarPath?: string;
+    sidecarRequired?: boolean;
+    sidecarEmpty?: boolean;
+    symbolId?: string;
+    declarationKind?: string;
+    sourceSpan?: FrontierSwarmSourceSpanInput;
+    sourcePath?: string;
+    sourceHash?: string;
+    expectedSourceHash?: string;
+    operation?: FrontierSwarmSemanticChangeOperation;
+    confidence?: FrontierSwarmSemanticChangeConfidence;
+    conflictReason?: FrontierSwarmMergeCandidateReasonCode;
+    status?: FrontierSwarmMergeCandidateAdmissionStatus;
+    reasonCodes?: readonly FrontierSwarmMergeCandidateReasonCode[];
+    semanticChanges?: readonly (FrontierSwarmSemanticChangeInput | FrontierSwarmSemanticChange)[];
+    changes?: readonly (FrontierSwarmSemanticChangeInput | FrontierSwarmSemanticChange)[];
+    hasLosses?: boolean;
+    testsRequired?: boolean;
+    testsPassed?: boolean;
+    evidencePaths?: readonly string[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmMergeCandidate {
+    kind: typeof FRONTIER_SWARM_MERGE_CANDIDATE_KIND;
+    version: typeof FRONTIER_SWARM_MERGE_CANDIDATE_VERSION;
+    id: string;
+    jobId?: string;
+    taskId?: string;
+    lane?: string;
+    title?: string;
+    sidecarPath?: string;
+    symbolId: string;
+    symbolIds: string[];
+    declarationKind: string;
+    declarationKinds: string[];
+    sourceSpan: FrontierSwarmSourceSpan;
+    operation: FrontierSwarmSemanticChangeOperation;
+    confidence: FrontierSwarmSemanticChangeConfidence;
+    conflictReason?: FrontierSwarmMergeCandidateReasonCode;
+    status: FrontierSwarmMergeCandidateAdmissionStatus;
+    reasonCodes: FrontierSwarmMergeCandidateReasonCode[];
+    semanticChanges: FrontierSwarmSemanticChange[];
+    changedPaths: string[];
+    evidencePaths: string[];
+    generatedAt: number;
+    summary: {
+        changeCount: number;
+        symbolCount: number;
+        reasonCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmMergeCandidateGraphInput {
+    id?: string;
+    runId?: string;
+    title?: string;
+    candidates: readonly (FrontierSwarmMergeCandidateInput | FrontierSwarmMergeCandidate)[];
+    includeChangeNodes?: boolean;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmMergeCandidateGraphProjection {
+    candidates: FrontierSwarmMergeCandidate[];
+    nodes: FrontierSwarmGraphNodeInput[];
+    edges: FrontierSwarmGraphEdgeInput[];
+}
+export interface FrontierSwarmGraphEventInput {
+    id?: string;
+    type: string;
+    nodeId?: string;
+    edgeId?: string;
+    timestamp?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmGraphEvent {
+    id: string;
+    type: string;
+    nodeId?: string;
+    edgeId?: string;
+    timestamp: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmRunGraphSummary {
+    nodeCount: number;
+    edgeCount: number;
+    eventCount: number;
+    nodeKinds: Record<string, number>;
+    edgeKinds: Record<string, number>;
+    openBlockerCount: number;
+    humanQuestionCount: number;
+}
+export interface FrontierSwarmRunGraphInput {
+    id?: string;
+    runId?: string;
+    title?: string;
+    generatedAt?: number;
+    nodes?: readonly FrontierSwarmGraphNodeInput[];
+    edges?: readonly FrontierSwarmGraphEdgeInput[];
+    events?: readonly FrontierSwarmGraphEventInput[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmRunGraph {
+    kind: typeof FRONTIER_SWARM_RUN_GRAPH_KIND;
+    version: typeof FRONTIER_SWARM_RUN_GRAPH_VERSION;
+    id: string;
+    runId?: string;
+    title?: string;
+    generatedAt: number;
+    nodes: FrontierSwarmGraphNode[];
+    edges: FrontierSwarmGraphEdge[];
+    events: FrontierSwarmGraphEvent[];
+    summary: FrontierSwarmRunGraphSummary;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmGraphSnapshotInput {
+    id?: string;
+    graph: FrontierSwarmRunGraphInput | FrontierSwarmRunGraph;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmGraphSnapshot {
+    kind: typeof FRONTIER_SWARM_GRAPH_SNAPSHOT_KIND;
+    version: typeof FRONTIER_SWARM_GRAPH_SNAPSHOT_VERSION;
+    id: string;
+    graphId: string;
+    generatedAt: number;
+    summary: FrontierSwarmRunGraphSummary;
+    graph: FrontierSwarmRunGraph;
+    metadata?: JsonObject;
+}
+export type FrontierSwarmGateRecordType = FrontierSwarmVerificationCategory | 'command' | 'browser' | 'fuzz' | 'oracle' | 'benchmark' | 'semantic-sidecar' | 'replay' | string;
+export type FrontierSwarmGateRecordStatus = 'passed' | 'failed' | 'unknown' | 'skipped' | 'blocked' | string;
+export type FrontierSwarmEvidenceRecordType = 'command-output' | 'browser' | 'fuzz' | 'oracle' | 'benchmark' | 'semantic-sidecar' | 'replay' | 'artifact' | string;
+export type FrontierSwarmPatchEventOperation = 'add' | 'remove' | 'replace' | 'move' | 'copy' | 'test' | string;
+export type FrontierSwarmReplayRecordStatus = 'pending' | 'running' | 'passed' | 'failed' | 'blocked' | 'skipped' | 'unknown' | string;
+export type FrontierSwarmImprovementLoopStatus = 'observed' | 'planned' | 'running' | 'applied' | 'verified' | 'failed' | 'blocked' | 'unknown' | string;
+export interface FrontierSwarmGateRecordInput {
+    id?: string;
+    type: FrontierSwarmGateRecordType;
+    status?: FrontierSwarmGateRecordStatus;
+    required?: boolean;
+    command?: string;
+    path?: string;
+    jobId?: string;
+    taskId?: string;
+    startedAt?: number;
+    finishedAt?: number;
+    failureReason?: string;
+    confidence?: FrontierSwarmConfidence;
+    metrics?: unknown;
+    metadata?: unknown;
+}
+export interface FrontierSwarmGateRecord {
+    kind: typeof FRONTIER_SWARM_GATE_RECORD_KIND;
+    version: typeof FRONTIER_SWARM_GATE_RECORD_VERSION;
+    id: string;
+    type: FrontierSwarmGateRecordType;
+    status: FrontierSwarmGateRecordStatus;
+    required: boolean;
+    command?: string;
+    path?: string;
+    jobId?: string;
+    taskId?: string;
+    startedAt?: number;
+    finishedAt?: number;
+    failureReason?: string;
+    confidence?: FrontierSwarmConfidence;
+    metrics?: JsonObject;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmEvidenceRecordInput {
+    id?: string;
+    type: FrontierSwarmEvidenceRecordType;
+    path?: string;
+    ref?: string;
+    jobId?: string;
+    taskId?: string;
+    gateId?: string;
+    producedAt?: number;
+    confidence?: FrontierSwarmConfidence;
+    metrics?: unknown;
+    metadata?: unknown;
+}
+export interface FrontierSwarmEvidenceRecord {
+    kind: typeof FRONTIER_SWARM_EVIDENCE_RECORD_KIND;
+    version: typeof FRONTIER_SWARM_EVIDENCE_RECORD_VERSION;
+    id: string;
+    type: FrontierSwarmEvidenceRecordType;
+    path?: string;
+    ref?: string;
+    jobId?: string;
+    taskId?: string;
+    gateId?: string;
+    producedAt: number;
+    confidence?: FrontierSwarmConfidence;
+    metrics?: JsonObject;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmGraphRefInput {
+    id?: string;
+    kind?: string;
+    graphId?: string;
+    nodeId?: string;
+    edgeId?: string;
+    role?: string;
+    metadata?: unknown;
+}
+export interface FrontierSwarmGraphRef {
+    id: string;
+    kind: string;
+    graphId?: string;
+    nodeId?: string;
+    edgeId?: string;
+    role?: string;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmPatchEventInput {
+    id?: string;
+    operation: FrontierSwarmPatchEventOperation;
+    path: string;
+    from?: string;
+    hash?: string;
+    sequence?: number;
+    value?: unknown;
+    before?: unknown;
+    after?: unknown;
+    jobId?: string;
+    taskId?: string;
+    replayRecordId?: string;
+    graphRefs?: readonly FrontierSwarmGraphRefInput[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmPatchEvent {
+    kind: typeof FRONTIER_SWARM_PATCH_EVENT_KIND;
+    version: typeof FRONTIER_SWARM_PATCH_EVENT_VERSION;
+    id: string;
+    operation: FrontierSwarmPatchEventOperation;
+    path: string;
+    from?: string;
+    hash?: string;
+    sequence?: number;
+    value?: JsonValue;
+    before?: JsonValue;
+    after?: JsonValue;
+    jobId?: string;
+    taskId?: string;
+    replayRecordId?: string;
+    graphRefs: FrontierSwarmGraphRef[];
+    generatedAt: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmReplayRecordInput {
+    id?: string;
+    title?: string;
+    status?: FrontierSwarmReplayRecordStatus;
+    subject?: string;
+    replayBundleId?: string;
+    patchEvents?: readonly (FrontierSwarmPatchEventInput | FrontierSwarmPatchEvent)[];
+    evidenceRefs?: readonly (string | FrontierSwarmNamedRefInput)[];
+    graphRefs?: readonly FrontierSwarmGraphRefInput[];
+    jobId?: string;
+    taskId?: string;
+    startedAt?: number;
+    finishedAt?: number;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmReplayRecord {
+    kind: typeof FRONTIER_SWARM_REPLAY_RECORD_KIND;
+    version: typeof FRONTIER_SWARM_REPLAY_RECORD_VERSION;
+    id: string;
+    title: string;
+    status: FrontierSwarmReplayRecordStatus;
+    subject?: string;
+    replayBundleId?: string;
+    patchEvents: FrontierSwarmPatchEvent[];
+    evidenceRefs: FrontierSwarmNamedRef[];
+    graphRefs: FrontierSwarmGraphRef[];
+    jobId?: string;
+    taskId?: string;
+    startedAt?: number;
+    finishedAt?: number;
+    generatedAt: number;
+    summary: {
+        patchEventCount: number;
+        evidenceRefCount: number;
+        graphRefCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmImprovementLoopInput {
+    id?: string;
+    title?: string;
+    status?: FrontierSwarmImprovementLoopStatus;
+    subject?: string;
+    observation?: unknown;
+    action?: unknown;
+    result?: unknown;
+    replayRecordIds?: readonly string[];
+    patchEventIds?: readonly string[];
+    evidenceRefs?: readonly (string | FrontierSwarmNamedRefInput)[];
+    graphRefs?: readonly FrontierSwarmGraphRefInput[];
+    jobId?: string;
+    taskId?: string;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmImprovementLoop {
+    kind: typeof FRONTIER_SWARM_IMPROVEMENT_LOOP_KIND;
+    version: typeof FRONTIER_SWARM_IMPROVEMENT_LOOP_VERSION;
+    id: string;
+    title: string;
+    status: FrontierSwarmImprovementLoopStatus;
+    subject?: string;
+    observation?: JsonValue;
+    action?: JsonValue;
+    result?: JsonValue;
+    replayRecordIds: string[];
+    patchEventIds: string[];
+    evidenceRefs: FrontierSwarmNamedRef[];
+    graphRefs: FrontierSwarmGraphRef[];
+    jobId?: string;
+    taskId?: string;
+    generatedAt: number;
+    summary: {
+        replayRecordCount: number;
+        patchEventCount: number;
+        evidenceRefCount: number;
+        graphRefCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmRunGraphChunkInput {
+    id?: string;
+    nodes?: readonly FrontierSwarmGraphNodeInput[];
+    edges?: readonly FrontierSwarmGraphEdgeInput[];
+    entryNodeIds?: readonly string[];
+    exitNodeIds?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmRunGraphChunk {
+    kind: typeof FRONTIER_SWARM_RUN_GRAPH_CHUNK_KIND;
+    version: typeof FRONTIER_SWARM_RUN_GRAPH_CHUNK_VERSION;
+    id: string;
+    nodes: FrontierSwarmGraphNode[];
+    edges: FrontierSwarmGraphEdge[];
+    entryNodeIds: string[];
+    exitNodeIds: string[];
+    summary: {
+        nodeCount: number;
+        edgeCount: number;
+        entryCount: number;
+        exitCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmRunGraphSynthesisChunkInput {
+    id?: string;
+    source?: FrontierSwarmGraphNodeInput;
+    panel?: FrontierSwarmGraphNodeInput;
+    candidates?: readonly FrontierSwarmGraphNodeInput[];
+    selectedCandidateId?: string;
+    rejectedCandidateIds?: readonly string[];
+    decision?: FrontierSwarmGraphNodeInput;
+    output?: FrontierSwarmGraphNodeInput;
+    metadata?: unknown;
+}
+export interface FrontierSwarmRunGraphVerificationGateChunkInput {
+    id?: string;
+    subject: FrontierSwarmGraphNodeInput;
+    gate: FrontierSwarmGraphNodeInput;
+    evidence?: readonly FrontierSwarmGraphNodeInput[];
+    pass?: FrontierSwarmGraphNodeInput;
+    block?: FrontierSwarmGraphNodeInput;
+    metadata?: unknown;
+}
+export interface FrontierSwarmRunGraphMergeGateChunkInput {
+    id?: string;
+    candidate: FrontierSwarmGraphNodeInput;
+    gate?: FrontierSwarmGraphNodeInput;
+    decision?: FrontierSwarmGraphNodeInput;
+    target: FrontierSwarmGraphNodeInput;
+    blockers?: readonly FrontierSwarmGraphNodeInput[];
+    superseded?: readonly FrontierSwarmGraphNodeInput[];
+    status?: FrontierSwarmGraphStatus;
+    metadata?: unknown;
+}
+export interface FrontierSwarmRunGraphBarrierInput {
+    id?: string;
+    prerequisites: readonly FrontierSwarmGraphNodeInput[];
+    barrier?: FrontierSwarmGraphNodeInput;
+    metadata?: unknown;
+}
+export interface FrontierSwarmRunGraphRaceSelectInput {
+    id?: string;
+    branches: readonly FrontierSwarmGraphNodeInput[];
+    selector?: FrontierSwarmGraphNodeInput;
+    selectedBranchId?: string;
+    rejectedBranchIds?: readonly string[];
+    metadata?: unknown;
+}
 export interface FrontierSwarmScheduleInput {
     plan: FrontierSwarmPlan;
     run?: FrontierSwarmRun;
@@ -1212,6 +1750,20 @@ export interface FrontierSwarmRun {
     summary: FrontierSwarmSummary;
     metadata?: JsonObject;
 }
+export interface FrontierSwarmRunEventAdapterOptions {
+    runId?: string;
+    actorId?: FrontierRunActorId;
+    startActorSeq?: number;
+    parents?: readonly FrontierRunEventId[];
+    time?: string;
+    now?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmRunProjectionOptions {
+    runId?: string;
+    goal?: string;
+    metadata?: unknown;
+}
 export interface FrontierSwarmEventInput {
     id?: string;
     type: string;
@@ -1365,6 +1917,8 @@ export interface FrontierSwarmSemanticImportSummary {
         patchHints?: number;
         [key: string]: unknown;
     };
+    semanticChanges?: readonly FrontierSwarmSemanticChange[];
+    mergeCandidates?: readonly FrontierSwarmMergeCandidate[];
     dependencies?: unknown;
     semanticEditScripts?: unknown;
     semanticEditProjection?: unknown;
@@ -1570,10 +2124,11 @@ export interface FrontierSwarmMergeIndexEntry {
 export interface FrontierSwarmMergeConflict {
     jobIds: string[];
     key: string;
-    kind: 'path' | 'region' | 'symbol';
+    kind: 'path' | 'region' | 'symbol' | 'public-contract';
     path?: string;
     region?: string;
     symbol?: string;
+    publicContract?: string;
 }
 export interface FrontierSwarmRegionOwnershipInput {
     changedPaths?: readonly string[];
@@ -2924,16 +3479,20 @@ export interface FrontierSwarmMergeQueuePromotion {
 export type FrontierSwarmCoordinatorAgentDrainDecision = 'applied' | 'queued' | 'escalated' | 'rerun' | 'rejected' | 'recorded' | 'blocked' | string;
 export type FrontierSwarmCoordinatorAgentDrainClassification = 'terminal' | 'non-terminal' | string;
 export type FrontierSwarmQueueOutcomeCategory = 'terminal' | 'continuation' | 'coordinator-review' | 'human-blocked' | 'stale-rerun' | 'conflict' | string;
-export type FrontierSwarmQueueTerminalOutcome = 'applied' | 'committed' | 'checked' | 'superseded' | 'no-change' | 'rejected' | 'rerun' | 'conflict-blocked' | 'human-question' | 'recorded' | 'closed' | string;
+export type FrontierSwarmQueueTerminalOutcome = 'applied' | 'committed' | 'checked' | 'superseded' | 'no-change' | 'research-complete' | 'rejected' | 'rerun' | 'conflict-blocked' | 'human-question' | 'recorded' | 'closed' | string;
 export type FrontierSwarmQueueContinuationOutcome = 'queued' | 'continued' | 'ready' | 'running' | 'leased' | string;
 export type FrontierSwarmQueueCoordinatorReviewOutcome = 'coordinator-review' | 'escalated' | 'needs-port' | string;
 export type FrontierSwarmQueueHumanBlockedOutcome = 'human-blocked' | 'human-question' | 'blocked' | string;
 export type FrontierSwarmQueueStaleRerunOutcome = 'stale-rerun' | 'rerun' | string;
 export type FrontierSwarmQueueConflictOutcome = 'conflict' | 'merge-conflict' | 'conflict-blocked' | string;
 export type FrontierSwarmQueueOutcome = FrontierSwarmQueueTerminalOutcome | FrontierSwarmQueueContinuationOutcome | FrontierSwarmQueueCoordinatorReviewOutcome | FrontierSwarmQueueHumanBlockedOutcome | FrontierSwarmQueueStaleRerunOutcome | FrontierSwarmQueueConflictOutcome;
-export declare const FRONTIER_SWARM_TERMINAL_OUTCOME_LABELS: readonly ["applied", "committed", "checked", "superseded", "evidence-only", "no-change", "generated-by-collector", "patch-missing", "bundle-missing", "rerun", "rejected", "conflict-blocked", "human-question", "human-blocked", "coordinator-review"];
+export declare const FRONTIER_SWARM_TERMINAL_OUTCOME_LABELS: readonly ["applied", "committed", "checked", "superseded", "evidence-only", "no-change", "research-complete", "generated-by-collector", "patch-missing", "bundle-missing", "rerun", "rejected", "conflict-blocked", "human-question", "human-blocked", "coordinator-review"];
 export type FrontierSwarmTerminalOutcomeLabel = typeof FRONTIER_SWARM_TERMINAL_OUTCOME_LABELS[number] | string;
 export type FrontierSwarmTerminalOutcomeCategory = 'success' | 'incomplete' | 'rerun' | 'rejected' | 'blocked' | 'review' | 'unknown' | string;
+export declare const FRONTIER_SWARM_TERMINAL_OUTCOME_STATUSES: readonly ["applied", "rejected", "superseded", "no-change", "conflict", "human-needed", "research-complete", "rerun"];
+export declare const FRONTIER_SWARM_TERMINAL_OUTCOME_REASON_CODES: readonly ["accepted-by-admission", "failed-verification", "superseded-by-newer-output", "no-effective-change", "conflict-detected", "human-decision-required", "research-complete", "stale-rerun-required"];
+export type FrontierSwarmTerminalOutcomeStatus = typeof FRONTIER_SWARM_TERMINAL_OUTCOME_STATUSES[number] | string;
+export type FrontierSwarmTerminalOutcomeReasonCode = typeof FRONTIER_SWARM_TERMINAL_OUTCOME_REASON_CODES[number] | string;
 export interface FrontierSwarmTerminalOutcomeInput {
     label?: FrontierSwarmTerminalOutcomeLabel | string;
     outcome?: FrontierSwarmTerminalOutcomeLabel | string;
@@ -2963,6 +3522,65 @@ export interface FrontierSwarmTerminalOutcome {
     reasons: string[];
     metadata?: JsonObject;
 }
+export interface FrontierSwarmTerminalOutcomeRecordInput {
+    id?: string;
+    subjectId?: string;
+    subjectAliases?: readonly string[];
+    jobId?: string;
+    taskId?: string;
+    queueId?: string;
+    queueItemId?: string;
+    queueItemIds?: readonly string[];
+    lane?: string;
+    source?: string;
+    status?: FrontierSwarmTerminalOutcomeStatus | string;
+    outcome?: FrontierSwarmTerminalOutcomeInput | FrontierSwarmTerminalOutcomeLabel | string;
+    label?: FrontierSwarmTerminalOutcomeLabel | string;
+    decision?: string;
+    admitted?: boolean;
+    reasonCodes?: readonly FrontierSwarmTerminalOutcomeReasonCode[];
+    reasons?: readonly string[];
+    conflictingJobIds?: readonly string[];
+    supersedes?: readonly string[];
+    supersededBy?: string;
+    rerunOf?: string;
+    evidenceRefs?: readonly (string | FrontierSwarmNamedRefInput)[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmTerminalOutcomeRecord {
+    kind: typeof FRONTIER_SWARM_TERMINAL_OUTCOME_RECORD_KIND;
+    version: typeof FRONTIER_SWARM_TERMINAL_OUTCOME_RECORD_VERSION;
+    id: string;
+    generatedAt: number;
+    subjectId: string;
+    subjectAliases: string[];
+    jobId?: string;
+    taskId?: string;
+    queueId?: string;
+    queueItemIds: string[];
+    lane?: string;
+    source?: string;
+    status: FrontierSwarmTerminalOutcomeStatus;
+    outcome: FrontierSwarmTerminalOutcome;
+    terminal: true;
+    admitted: boolean;
+    success: boolean;
+    rejected: boolean;
+    conflict: boolean;
+    humanNeeded: boolean;
+    rerun: boolean;
+    noChange: boolean;
+    researchComplete: boolean;
+    reasonCodes: FrontierSwarmTerminalOutcomeReasonCode[];
+    reasons: string[];
+    conflictingJobIds: string[];
+    supersedes: string[];
+    supersededBy?: string;
+    rerunOf?: string;
+    evidenceRefs: FrontierSwarmNamedRef[];
+    metadata?: JsonObject;
+}
 export interface FrontierSwarmQueueOutcomeClassification {
     category: FrontierSwarmQueueOutcomeCategory;
     outcome: FrontierSwarmQueueOutcome;
@@ -3475,12 +4093,107 @@ export declare function compileSwarm(input: FrontierSwarmManifest | FrontierSwar
 export declare function validateSwarmManifest(input: FrontierSwarmManifest | FrontierSwarmManifestInput): FrontierSwarmValidation;
 export declare function createSwarmPlan(manifestInput: FrontierSwarmManifest | FrontierSwarmManifestInput, taskInput: readonly FrontierSwarmTaskInput[] | FrontierSwarmTaskSetInput | readonly FrontierSwarmTask[], options?: FrontierSwarmPlanInput): FrontierSwarmPlan;
 export declare function createSwarmTaskSelection(manifestInput: FrontierSwarmManifest | FrontierSwarmManifestInput, taskInput: readonly FrontierSwarmTaskInput[] | FrontierSwarmTaskSetInput | readonly FrontierSwarmTask[], options?: FrontierSwarmTaskSelectionInput): FrontierSwarmTaskSelection;
+export declare function createSwarmRunGraph(input?: FrontierSwarmRunGraphInput): FrontierSwarmRunGraph;
+export declare function normalizeSwarmRunGraph(input: FrontierSwarmRunGraphInput | FrontierSwarmRunGraph): FrontierSwarmRunGraph;
+export declare function createSwarmGraphSnapshot(input: FrontierSwarmGraphSnapshotInput): FrontierSwarmGraphSnapshot;
+export declare function createSwarmGateRecord(input: FrontierSwarmGateRecordInput): FrontierSwarmGateRecord;
+export declare function createSwarmEvidenceRecord(input: FrontierSwarmEvidenceRecordInput): FrontierSwarmEvidenceRecord;
+export declare function createSwarmPatchEvent(input: FrontierSwarmPatchEventInput): FrontierSwarmPatchEvent;
+export declare function createSwarmReplayRecord(input?: FrontierSwarmReplayRecordInput): FrontierSwarmReplayRecord;
+export declare function createSwarmImprovementLoop(input?: FrontierSwarmImprovementLoopInput): FrontierSwarmImprovementLoop;
+export declare function mapSwarmGateEvidenceToGraph(input: {
+    runId?: string;
+    gates?: readonly (FrontierSwarmGateRecordInput | FrontierSwarmGateRecord)[];
+    evidence?: readonly (FrontierSwarmEvidenceRecordInput | FrontierSwarmEvidenceRecord)[];
+    generatedAt?: number;
+}): FrontierSwarmRunGraph;
+export declare function createSwarmGateEvidenceGraph(input: Parameters<typeof mapSwarmGateEvidenceToGraph>[0]): FrontierSwarmRunGraph;
+export declare function classifySwarmMergeCandidateAdmission(input?: {
+    status?: FrontierSwarmMergeCandidateAdmissionStatus;
+    reasonCodes?: readonly FrontierSwarmMergeCandidateReasonCode[];
+} | readonly FrontierSwarmMergeCandidateReasonCode[]): FrontierSwarmMergeCandidateAdmissionStatus;
+export declare function createSwarmSemanticChange(input: FrontierSwarmSemanticChangeInput | FrontierSwarmSemanticChange): FrontierSwarmSemanticChange;
+export declare function createSwarmMergeCandidate(input: FrontierSwarmMergeCandidateInput | FrontierSwarmMergeCandidate): FrontierSwarmMergeCandidate;
+export declare function mapSwarmMergeCandidatesToGraph(input: FrontierSwarmMergeCandidateGraphInput): FrontierSwarmMergeCandidateGraphProjection;
+export declare function createSwarmMergeCandidateGraph(input: FrontierSwarmMergeCandidateGraphInput): FrontierSwarmRunGraph;
+export declare function mapSwarmReplayRecordsToGraph(input: {
+    runId?: string;
+    replayRecords?: readonly (FrontierSwarmReplayRecordInput | FrontierSwarmReplayRecord)[];
+    generatedAt?: number;
+}): FrontierSwarmRunGraph;
+export declare function createSwarmReplayRecordGraph(input: Parameters<typeof mapSwarmReplayRecordsToGraph>[0]): FrontierSwarmRunGraph;
+export declare function mapSwarmImprovementLoopsToGraph(input: {
+    runId?: string;
+    improvementLoops?: readonly (FrontierSwarmImprovementLoopInput | FrontierSwarmImprovementLoop)[];
+    generatedAt?: number;
+}): FrontierSwarmRunGraph;
+export declare function createSwarmImprovementLoopGraph(input: Parameters<typeof mapSwarmImprovementLoopsToGraph>[0]): FrontierSwarmRunGraph;
+export declare function createSwarmRunGraphChunk(input?: FrontierSwarmRunGraphChunkInput): FrontierSwarmRunGraphChunk;
+export declare function createSwarmRunGraphChain(input: {
+    id?: string;
+    nodes: readonly FrontierSwarmGraphNodeInput[];
+    edgeKind?: FrontierSwarmGraphEdgeKind;
+    metadata?: unknown;
+}): FrontierSwarmRunGraphChunk;
+export declare function createSwarmRunGraphFork(input: {
+    id?: string;
+    source: FrontierSwarmGraphNodeInput;
+    branches: readonly FrontierSwarmGraphNodeInput[];
+    metadata?: unknown;
+}): FrontierSwarmRunGraphChunk;
+export declare function createSwarmRunGraphJoin(input: {
+    id?: string;
+    branches: readonly FrontierSwarmGraphNodeInput[];
+    join: FrontierSwarmGraphNodeInput;
+    metadata?: unknown;
+}): FrontierSwarmRunGraphChunk;
+export declare function createSwarmRunGraphBarrier(input: FrontierSwarmRunGraphBarrierInput): FrontierSwarmRunGraphChunk;
+export declare function createSwarmRunGraphRaceSelect(input: FrontierSwarmRunGraphRaceSelectInput): FrontierSwarmRunGraphChunk;
+export declare function createSwarmRunGraphTournament(input: {
+    id?: string;
+    candidates: readonly FrontierSwarmGraphNodeInput[];
+    winner?: string;
+    rejectedCandidates?: readonly string[];
+    metadata?: unknown;
+}): FrontierSwarmRunGraphChunk;
+export declare function createSwarmRunGraphRetryLoop(input: {
+    id?: string;
+    action: FrontierSwarmGraphNodeInput;
+    gate: FrontierSwarmGraphNodeInput;
+    retry: FrontierSwarmGraphNodeInput;
+    success?: FrontierSwarmGraphNodeInput;
+    failure?: FrontierSwarmGraphNodeInput;
+    metadata?: unknown;
+}): FrontierSwarmRunGraphChunk;
+export declare function createSwarmRunGraphRsiLoop(input: {
+    id?: string;
+    observe: FrontierSwarmGraphNodeInput;
+    improve: FrontierSwarmGraphNodeInput;
+    apply?: FrontierSwarmGraphNodeInput;
+    metadata?: unknown;
+}): FrontierSwarmRunGraphChunk;
+export declare function createSwarmRunGraphSynthesisChunk(input?: FrontierSwarmRunGraphSynthesisChunkInput): FrontierSwarmRunGraphChunk;
+export declare function createSwarmRunGraphVerificationGateChunk(input: FrontierSwarmRunGraphVerificationGateChunkInput): FrontierSwarmRunGraphChunk;
+export declare function createSwarmRunGraphMergeGateChunk(input: FrontierSwarmRunGraphMergeGateChunkInput): FrontierSwarmRunGraphChunk;
 export declare const FRONTIER_SWARM_TASK_MODEL_PROFILES: readonly FrontierSwarmTaskModelProfile[];
 export declare function resolveSwarmTaskModelProfile(task: FrontierSwarmTask, profiles?: readonly FrontierSwarmTaskModelProfile[]): FrontierSwarmTaskModelProfile;
 export declare function createSwarmModelRoute(input: FrontierSwarmModelRouterInput): FrontierSwarmModelRoute;
 export declare function createSwarmPanelEvaluation(input?: FrontierSwarmPanelEvaluationInput): FrontierSwarmPanelEvaluation;
 export declare function createSwarmOptimizationSummary(input?: FrontierSwarmOptimizationSummaryInput): FrontierSwarmOptimizationSummary;
 export declare function createSwarmRun(input: FrontierSwarmRunInput): FrontierSwarmRun;
+export declare function createRunEventsFromSwarmPlan(plan: FrontierSwarmPlan, options?: FrontierSwarmRunEventAdapterOptions): FrontierRunEvent[];
+export declare function createRunEventsFromSwarmLease(lease: FrontierSwarmLease, options?: FrontierSwarmRunEventAdapterOptions & {
+    job?: FrontierSwarmJob;
+    eventType?: 'lease.requested' | 'lease.granted' | 'lease.released';
+}): FrontierRunEvent[];
+export declare function createRunEventsFromSwarmResult(resultInput: FrontierSwarmJobResult | FrontierSwarmJobResultInput, options?: FrontierSwarmRunEventAdapterOptions & {
+    job?: FrontierSwarmJob;
+}): FrontierRunEvent[];
+export declare function createRunEventsFromMergeBundle(bundle: FrontierSwarmMergeBundle, options?: FrontierSwarmRunEventAdapterOptions): FrontierRunEvent[];
+export declare function createRunEventsFromCoordinatorDecision(decision: FrontierSwarmQueueOutcomeDecision | FrontierSwarmQueueOutcomeDecisionInput, options?: FrontierSwarmRunEventAdapterOptions): FrontierRunEvent[];
+export declare function createRunProjectionFromSwarmRunEvents(events: readonly FrontierRunEvent[], options?: FrontierSwarmRunProjectionOptions): FrontierRunProjection;
+export declare function createRunDashboardFromSwarmRun(input: FrontierSwarmRun | readonly FrontierRunEvent[], options?: FrontierSwarmRunProjectionOptions): FrontierRunDashboardSnapshot;
+export declare function createRunEventsFromSwarmRun(run: FrontierSwarmRun, options?: FrontierSwarmRunEventAdapterOptions): FrontierRunEvent[];
 export declare function recordSwarmEvent(runInput: FrontierSwarmRun, eventInput: FrontierSwarmEventInput): FrontierSwarmRun;
 export declare function createSwarmMailbox(input?: FrontierSwarmMailboxInput): FrontierSwarmMailbox;
 export declare function createSwarmEventStream(input?: FrontierSwarmEventStreamInput): FrontierSwarmEventStream;
@@ -3544,6 +4257,7 @@ export declare function createSwarmQueueOutcomeDecision(input: FrontierSwarmQueu
 export declare function createSwarmQueueOutcomeModel(input?: FrontierSwarmQueueOutcomeModelInput): FrontierSwarmQueueOutcomeModel;
 export declare function collapseSwarmQueueOutcomeDecisions(input: FrontierSwarmQueueOutcomeModelInput | readonly (FrontierSwarmQueueOutcomeDecisionInput | FrontierSwarmQueueOutcomeDecision)[]): FrontierSwarmQueueOutcomeModel;
 export declare function normalizeSwarmTerminalOutcome(input?: FrontierSwarmTerminalOutcomeInput | FrontierSwarmTerminalOutcomeLabel | string): FrontierSwarmTerminalOutcome;
+export declare function createSwarmTerminalOutcomeRecord(input?: FrontierSwarmTerminalOutcomeRecordInput): FrontierSwarmTerminalOutcomeRecord;
 export declare function reconcileSwarmTerminalState(input?: FrontierSwarmTerminalStateReconciliationInput): FrontierSwarmTerminalStateReconciliation;
 export declare function resolveSwarmCompute(manifestInput: FrontierSwarmManifest | FrontierSwarmManifestInput, taskInput: FrontierSwarmTask | FrontierSwarmTaskInput): FrontierSwarmCompute;
 export declare function createSwarmProof(input: FrontierSwarmManifest | FrontierSwarmPlan | FrontierSwarmRun, options?: {