@shapeshift-labs/frontier-swarm 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -31,6 +31,64 @@ 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_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";
+export declare const FRONTIER_SWARM_MERGE_INDEX_VERSION = 1;
+export declare const FRONTIER_SWARM_HOTSPOT_REPORT_KIND = "frontier.swarm.hotspot-report";
+export declare const FRONTIER_SWARM_HOTSPOT_REPORT_VERSION = 1;
+export declare const FRONTIER_SWARM_REVIEWER_LANE_PLAN_KIND = "frontier.swarm.reviewer-lane-plan";
+export declare const FRONTIER_SWARM_REVIEWER_LANE_PLAN_VERSION = 1;
+export declare const FRONTIER_SWARM_RUN_STORE_SHARDS_KIND = "frontier.swarm.run-store-shards";
+export declare const FRONTIER_SWARM_RUN_STORE_SHARDS_VERSION = 1;
+export declare const FRONTIER_SWARM_MERGE_ADMISSION_KIND = "frontier.swarm.merge-admission";
+export declare const FRONTIER_SWARM_MERGE_ADMISSION_VERSION = 1;
+export declare const FRONTIER_SWARM_CONTEXT_PACK_KIND = "frontier.swarm.context-pack";
+export declare const FRONTIER_SWARM_CONTEXT_PACK_VERSION = 1;
+export declare const FRONTIER_SWARM_ORACLE_CORPUS_KIND = "frontier.swarm.oracle-corpus";
+export declare const FRONTIER_SWARM_ORACLE_CORPUS_VERSION = 1;
+export declare const FRONTIER_SWARM_REPLAY_BUNDLE_KIND = "frontier.swarm.replay-bundle";
+export declare const FRONTIER_SWARM_REPLAY_BUNDLE_VERSION = 1;
+export declare const FRONTIER_SWARM_PARITY_ORACLE_KIND = "frontier.swarm.parity-oracle";
+export declare const FRONTIER_SWARM_PARITY_ORACLE_VERSION = 1;
+export declare const FRONTIER_SWARM_DIVERGENCE_REPORT_KIND = "frontier.swarm.divergence-report";
+export declare const FRONTIER_SWARM_DIVERGENCE_REPORT_VERSION = 1;
+export declare const FRONTIER_SWARM_OBSERVABILITY_POINT_KIND = "frontier.swarm.observability-point";
+export declare const FRONTIER_SWARM_OBSERVABILITY_POINT_VERSION = 1;
+export declare const FRONTIER_SWARM_WATCHPOINT_PLAN_KIND = "frontier.swarm.watchpoint-plan";
+export declare const FRONTIER_SWARM_WATCHPOINT_PLAN_VERSION = 1;
+export declare const FRONTIER_SWARM_DEBUG_HANDOFF_KIND = "frontier.swarm.debug-handoff";
+export declare const FRONTIER_SWARM_DEBUG_HANDOFF_VERSION = 1;
+export declare const FRONTIER_SWARM_INSTRUMENTATION_BUDGET_KIND = "frontier.swarm.instrumentation-budget";
+export declare const FRONTIER_SWARM_INSTRUMENTATION_BUDGET_VERSION = 1;
+export declare const FRONTIER_SWARM_BOTTLENECK_REPORT_KIND = "frontier.swarm.bottleneck-report";
+export declare const FRONTIER_SWARM_BOTTLENECK_REPORT_VERSION = 1;
+export declare const FRONTIER_SWARM_EVIDENCE_INDEX_KIND = "frontier.swarm.evidence-index";
+export declare const FRONTIER_SWARM_EVIDENCE_INDEX_VERSION = 1;
+export declare const FRONTIER_SWARM_BLACKBOARD_KIND = "frontier.swarm.blackboard";
+export declare const FRONTIER_SWARM_BLACKBOARD_VERSION = 1;
+export declare const FRONTIER_SWARM_REFERENCE_ORACLE_PLAN_KIND = "frontier.swarm.reference-oracle-plan";
+export declare const FRONTIER_SWARM_REFERENCE_ORACLE_PLAN_VERSION = 1;
+export declare const FRONTIER_SWARM_REFERENCE_ORACLE_RESPONSE_KIND = "frontier.swarm.reference-oracle-response";
+export declare const FRONTIER_SWARM_REFERENCE_ORACLE_RESPONSE_VERSION = 1;
+export declare const FRONTIER_SWARM_ARTIFACT_ROUTING_PLAN_KIND = "frontier.swarm.artifact-routing-plan";
+export declare const FRONTIER_SWARM_ARTIFACT_ROUTING_PLAN_VERSION = 1;
+export declare const FRONTIER_SWARM_SCHEDULER_RECOMMENDATIONS_KIND = "frontier.swarm.scheduler-recommendations";
+export declare const FRONTIER_SWARM_SCHEDULER_RECOMMENDATIONS_VERSION = 1;
+export declare const FRONTIER_SWARM_FIXTURE_CATALOG_KIND = "frontier.swarm.fixture-catalog";
+export declare const FRONTIER_SWARM_FIXTURE_CATALOG_VERSION = 1;
+export declare const FRONTIER_SWARM_PROGRESS_MODEL_KIND = "frontier.swarm.progress-model";
+export declare const FRONTIER_SWARM_PROGRESS_MODEL_VERSION = 1;
+export declare const FRONTIER_SWARM_AUTO_REVIEW_REPORT_KIND = "frontier.swarm.auto-review-report";
+export declare const FRONTIER_SWARM_AUTO_REVIEW_REPORT_VERSION = 1;
+export declare const FRONTIER_SWARM_REBASE_REPORT_KIND = "frontier.swarm.rebase-report";
+export declare const FRONTIER_SWARM_REBASE_REPORT_VERSION = 1;
+export declare const FRONTIER_SWARM_USAGE_GOVERNOR_KIND = "frontier.swarm.usage-governor";
+export declare const FRONTIER_SWARM_USAGE_GOVERNOR_VERSION = 1;
+export declare const FRONTIER_SWARM_LANE_PLAYBOOK_KIND = "frontier.swarm.lane-playbook";
+export declare const FRONTIER_SWARM_LANE_PLAYBOOK_VERSION = 1;
+export declare const FRONTIER_SWARM_PATCH_STACK_PLAN_KIND = "frontier.swarm.patch-stack-plan";
+export declare const FRONTIER_SWARM_PATCH_STACK_PLAN_VERSION = 1;
 export declare const FRONTIER_SWARM_DEFAULT_CODEX_COMPUTE_ID = "codex.gpt-5.5.xhigh";
 export declare const FRONTIER_SWARM_DEFAULT_MODEL = "gpt-5.5";
 export declare const FRONTIER_SWARM_DEFAULT_REASONING_EFFORT = "xhigh";
@@ -42,6 +100,17 @@ export type FrontierSwarmJobStatus = 'planned' | 'scheduled' | 'running' | 'bloc
 export type FrontierSwarmMergeReadiness = 'discovery-only' | 'patch-candidate' | 'verified-patch' | 'rejected' | 'blocked' | string;
 export type FrontierSwarmMergeDisposition = 'auto-mergeable' | 'needs-port' | 'discovery-only' | 'rejected' | 'blocked' | 'stale-against-head' | string;
 export type FrontierSwarmRiskLevel = 'low' | 'medium' | 'high' | 'unknown' | string;
+export type FrontierSwarmPatchStatus = 'unknown' | 'applies' | 'missing' | 'stale' | 'failed-check' | string;
+export type FrontierSwarmQueueOverlayStatus = 'satisfied' | 'ready-to-apply' | 'needs-human-port' | 'failed-evidence' | 'stale-against-head' | 'discovery-only' | 'blocked' | 'rejected' | 'unknown' | string;
+export type FrontierSwarmParityOracleStatus = 'pending' | 'passed' | 'failed' | 'blocked' | 'skipped' | string;
+export type FrontierSwarmDivergenceSeverity = 'info' | 'warning' | 'error' | 'critical' | string;
+export type FrontierSwarmWatchpointAction = 'break' | 'log' | 'capture' | 'handoff' | string;
+export type FrontierSwarmBottleneckKind = 'correctness' | 'performance' | 'instrumentation-overhead' | 'missing-oracle' | 'flaky-harness' | 'blocked-dependency' | 'merge-review' | 'resource-capacity' | 'budget' | 'queue' | string;
+export type FrontierSwarmConfidence = 'low' | 'medium' | 'high' | string;
+export type FrontierSwarmBlackboardEntryKind = 'fact' | 'divergence' | 'rejected-theory' | 'ownership' | 'decision' | string;
+export type FrontierSwarmProgressStatus = 'not-started' | 'declared' | 'implemented' | 'structure-verified' | 'visual-verified' | 'functional-verified' | 'collaboration-verified' | 'accepted' | 'rejected' | 'blocked' | string;
+export type FrontierSwarmAutoReviewFindingKind = 'stub-risk' | 'missing-evidence' | 'ownership-violation' | 'overlarge-patch' | 'weak-evidence' | 'strict-source-policy' | string;
+export type FrontierSwarmRebaseStatus = 'clean-apply' | 'textual-conflict' | 'semantic-overlap' | 'stale-evidence' | 'needs-rerun' | string;
 export interface FrontierSwarmComputeInput {
     id: string;
     kind?: FrontierSwarmComputeKind;
@@ -404,6 +473,7 @@ export interface FrontierSwarmPlanInput extends FrontierSwarmPlanFilter {
     maxLaneConcurrency?: Record<string, number>;
     maxConcurrencyKeyConcurrency?: Record<string, number>;
     maxComputeConcurrency?: Record<string, number>;
+    resourceQuotas?: Record<string, number>;
     metadata?: unknown;
 }
 export interface FrontierSwarmPlan {
@@ -426,6 +496,7 @@ export interface FrontierSwarmScheduleLimits {
     maxLaneConcurrency: Record<string, number>;
     maxConcurrencyKeyConcurrency: Record<string, number>;
     maxComputeConcurrency: Record<string, number>;
+    resourceQuotas: Record<string, number>;
 }
 export interface FrontierSwarmJob {
     id: string;
@@ -532,6 +603,7 @@ export interface FrontierSwarmScheduleInput {
     maxLaneConcurrency?: Record<string, number>;
     maxConcurrencyKeyConcurrency?: Record<string, number>;
     maxComputeConcurrency?: Record<string, number>;
+    resourceQuotas?: Record<string, number>;
 }
 export interface FrontierSwarmReviewPlanInput {
     plan: FrontierSwarmPlan;
@@ -1028,6 +1100,1262 @@ export interface FrontierSwarmMergeBundle {
     reasons: string[];
     metadata?: JsonObject;
 }
+export interface FrontierSwarmQueueOverlayInput {
+    id?: string;
+    runId?: string;
+    bundles?: readonly FrontierSwarmMergeBundle[];
+    results?: readonly (FrontierSwarmJobResult | FrontierSwarmJobResultInput)[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmQueueOverlay {
+    kind: typeof FRONTIER_SWARM_QUEUE_OVERLAY_KIND;
+    version: typeof FRONTIER_SWARM_QUEUE_OVERLAY_VERSION;
+    id: string;
+    runId?: string;
+    generatedAt: number;
+    entries: FrontierSwarmQueueOverlayEntry[];
+    byQueueItemId: Record<string, FrontierSwarmQueueOverlayEntry[]>;
+    summary: {
+        entryCount: number;
+        queueItemCount: number;
+        readyToApplyCount: number;
+        needsHumanPortCount: number;
+        failedEvidenceCount: number;
+        staleAgainstHeadCount: number;
+        discoveryOnlyCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmQueueOverlayEntry {
+    queueItemId: string;
+    jobId: string;
+    status: FrontierSwarmQueueOverlayStatus;
+    mergeReadiness: FrontierSwarmMergeReadiness;
+    disposition: FrontierSwarmMergeDisposition;
+    riskLevel: FrontierSwarmRiskLevel;
+    patchPath?: string;
+    evidencePaths: string[];
+    changedPaths: string[];
+    changedRegions: string[];
+    reasons: string[];
+    generatedAt: number;
+}
+export interface FrontierSwarmDerivedQueueStatusInput {
+    snapshot: FrontierSwarmQueueSnapshot;
+    overlays?: readonly FrontierSwarmQueueOverlay[];
+    generatedAt?: number;
+}
+export interface FrontierSwarmDerivedQueueStatus {
+    generatedAt: number;
+    jobs: FrontierSwarmQueueJob[];
+    byStatus: Record<string, string[]>;
+    summary: FrontierSwarmQueueSnapshot['summary'];
+}
+export interface FrontierSwarmMergeIndexInput {
+    id?: string;
+    runId?: string;
+    planId?: string;
+    bundles: readonly FrontierSwarmMergeBundle[];
+    patchStatuses?: Record<string, FrontierSwarmPatchStatus>;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmMergeIndex {
+    kind: typeof FRONTIER_SWARM_MERGE_INDEX_KIND;
+    version: typeof FRONTIER_SWARM_MERGE_INDEX_VERSION;
+    id: string;
+    runId?: string;
+    planId?: string;
+    generatedAt: number;
+    entries: FrontierSwarmMergeIndexEntry[];
+    conflicts: FrontierSwarmMergeConflict[];
+    byDisposition: Record<string, string[]>;
+    byPath: Record<string, string[]>;
+    byRegion: Record<string, string[]>;
+    summary: {
+        entryCount: number;
+        readyToApplyCount: number;
+        needsHumanPortCount: number;
+        failedEvidenceCount: number;
+        staleAgainstHeadCount: number;
+        discoveryOnlyCount: number;
+        conflictCount: number;
+        conflictedJobCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmMergeIndexEntry {
+    jobId: string;
+    taskId?: string;
+    lane?: string;
+    title?: string;
+    status: FrontierSwarmJobStatus;
+    mergeReadiness: FrontierSwarmMergeReadiness;
+    disposition: FrontierSwarmMergeDisposition;
+    riskLevel: FrontierSwarmRiskLevel;
+    patchStatus: FrontierSwarmPatchStatus;
+    staleAgainstHead: boolean;
+    autoMergeable: boolean;
+    changedPaths: string[];
+    changedRegions: string[];
+    conflictKeys: string[];
+    conflictingJobIds: string[];
+    ownedFilesTouched: string[];
+    ownershipViolations: string[];
+    patchPath?: string;
+    patchHash?: string;
+    evidencePaths: string[];
+    queueItemIds: string[];
+    reasons: string[];
+    generatedAt: number;
+}
+export interface FrontierSwarmMergeConflict {
+    jobIds: string[];
+    key: string;
+    kind: 'path' | 'region';
+    path?: string;
+    region?: string;
+}
+export interface FrontierSwarmRegionOwnershipInput {
+    changedPaths?: readonly string[];
+    changedRegions?: readonly string[];
+}
+export interface FrontierSwarmRegionOwnershipReport {
+    ok: boolean;
+    jobId: string;
+    changedPaths: string[];
+    changedRegions: string[];
+    ownedRegions: string[];
+    regionViolations: string[];
+    unclassifiedChangedPaths: string[];
+}
+export interface FrontierSwarmHotspotReportInput {
+    id?: string;
+    bundles?: readonly FrontierSwarmMergeBundle[];
+    results?: readonly (FrontierSwarmJobResult | FrontierSwarmJobResultInput)[];
+    threshold?: number;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmHotspotReport {
+    kind: typeof FRONTIER_SWARM_HOTSPOT_REPORT_KIND;
+    version: typeof FRONTIER_SWARM_HOTSPOT_REPORT_VERSION;
+    id: string;
+    generatedAt: number;
+    threshold: number;
+    entries: FrontierSwarmHotspotEntry[];
+    recommendations: FrontierSwarmHotspotRecommendation[];
+    summary: {
+        pathCount: number;
+        hotspotCount: number;
+        recommendationCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmHotspotEntry {
+    path: string;
+    touchCount: number;
+    jobIds: string[];
+    regions: string[];
+    dispositions: string[];
+    riskLevels: string[];
+}
+export interface FrontierSwarmHotspotRecommendation {
+    path: string;
+    reason: 'repeated-conflicts' | 'hot-file' | 'region-overlap';
+    suggestedModuleId: string;
+    suggestedOwnershipRegions: string[];
+    jobIds: string[];
+}
+export interface FrontierSwarmReviewerLanePlanInput {
+    id?: string;
+    index: FrontierSwarmMergeIndex;
+    admission?: FrontierSwarmMergeAdmission;
+    reviewerLane?: string;
+    reviewers?: readonly string[];
+    includeAutoMergeable?: boolean;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmReviewerLanePlan {
+    kind: typeof FRONTIER_SWARM_REVIEWER_LANE_PLAN_KIND;
+    version: typeof FRONTIER_SWARM_REVIEWER_LANE_PLAN_VERSION;
+    id: string;
+    mergeIndexId: string;
+    generatedAt: number;
+    reviewerLane: string;
+    assignments: FrontierSwarmReviewerLaneAssignment[];
+    tasks: FrontierSwarmTaskInput[];
+    summary: {
+        assignmentCount: number;
+        taskCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmReviewerLaneAssignment {
+    jobId: string;
+    reviewers: string[];
+    required: boolean;
+    reasons: string[];
+}
+export interface FrontierSwarmRunStoreShardsInput {
+    id?: string;
+    run?: FrontierSwarmRun;
+    plan?: FrontierSwarmPlan;
+    root?: string;
+    shardSize?: number;
+    groupBy?: 'lane' | 'hash' | 'none';
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmRunStoreShards {
+    kind: typeof FRONTIER_SWARM_RUN_STORE_SHARDS_KIND;
+    version: typeof FRONTIER_SWARM_RUN_STORE_SHARDS_VERSION;
+    id: string;
+    runId?: string;
+    planId?: string;
+    root: string;
+    generatedAt: number;
+    groupBy: 'lane' | 'hash' | 'none';
+    shardSize: number;
+    shards: FrontierSwarmRunStoreShard[];
+    summary: {
+        shardCount: number;
+        jobCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmRunStoreShard {
+    id: string;
+    lane?: string;
+    path: string;
+    eventPath: string;
+    resultPath: string;
+    checkpointPath: string;
+    jobIds: string[];
+}
+export interface FrontierSwarmMergeAdmissionInput {
+    id?: string;
+    index: FrontierSwarmMergeIndex;
+    maxReady?: number;
+    maxChangedPaths?: number;
+    maxChangedRegions?: number;
+    maxHighRisk?: number;
+    allowRisks?: readonly FrontierSwarmRiskLevel[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmMergeAdmission {
+    kind: typeof FRONTIER_SWARM_MERGE_ADMISSION_KIND;
+    version: typeof FRONTIER_SWARM_MERGE_ADMISSION_VERSION;
+    id: string;
+    mergeIndexId: string;
+    generatedAt: number;
+    admitted: string[];
+    deferred: FrontierSwarmMergeAdmissionDeferral[];
+    budget: {
+        maxReady: number;
+        maxChangedPaths?: number;
+        maxChangedRegions?: number;
+        maxHighRisk?: number;
+        allowRisks: string[];
+    };
+    summary: {
+        admittedCount: number;
+        deferredCount: number;
+        changedPathCount: number;
+        changedRegionCount: number;
+        highRiskCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmMergeAdmissionDeferral {
+    jobId: string;
+    reasons: string[];
+}
+export interface FrontierSwarmContextPackInput {
+    id?: string;
+    job?: FrontierSwarmJob;
+    task?: FrontierSwarmTask | FrontierSwarmTaskInput;
+    title?: string;
+    files?: readonly string[];
+    apiMap?: Record<string, readonly string[]>;
+    knownFailures?: readonly string[];
+    commands?: readonly (string | FrontierSwarmCommandInput)[];
+    oracleCommands?: readonly (string | FrontierSwarmCommandInput)[];
+    evidenceSchema?: unknown;
+    expectedEvidence?: readonly string[];
+    exclusions?: readonly string[];
+    avoidInvestigating?: readonly string[];
+    playbookIds?: readonly string[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmContextPack {
+    kind: typeof FRONTIER_SWARM_CONTEXT_PACK_KIND;
+    version: typeof FRONTIER_SWARM_CONTEXT_PACK_VERSION;
+    id: string;
+    jobId?: string;
+    taskId?: string;
+    lane?: string;
+    title: string;
+    generatedAt: number;
+    files: string[];
+    apiMap: Record<string, string[]>;
+    knownFailures: string[];
+    commands: FrontierSwarmCommand[];
+    oracleCommands: FrontierSwarmCommand[];
+    evidenceSchema?: JsonValue;
+    expectedEvidence: string[];
+    exclusions: string[];
+    avoidInvestigating: string[];
+    playbookIds: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmOracleArtifactInput {
+    id: string;
+    path: string;
+    kind?: string;
+    command?: string | FrontierSwarmCommandInput;
+    hash?: string;
+    sourceRef?: string;
+    tags?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmOracleArtifact {
+    id: string;
+    path: string;
+    kind: string;
+    command?: FrontierSwarmCommand;
+    hash?: string;
+    sourceRef?: string;
+    tags: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmOracleCorpusInput {
+    id?: string;
+    title?: string;
+    artifacts?: readonly FrontierSwarmOracleArtifactInput[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmOracleCorpus {
+    kind: typeof FRONTIER_SWARM_ORACLE_CORPUS_KIND;
+    version: typeof FRONTIER_SWARM_ORACLE_CORPUS_VERSION;
+    id: string;
+    title: string;
+    generatedAt: number;
+    artifacts: FrontierSwarmOracleArtifact[];
+    byKind: Record<string, string[]>;
+    byTag: Record<string, string[]>;
+    summary: {
+        artifactCount: number;
+        kindCount: number;
+        tagCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmNamedRefInput {
+    id?: string;
+    path?: string;
+    uri?: string;
+    kind?: string;
+    role?: string;
+    hash?: string;
+    bytes?: number;
+    tags?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmNamedRef {
+    id: string;
+    kind: string;
+    path?: string;
+    uri?: string;
+    role?: string;
+    hash?: string;
+    bytes?: number;
+    tags: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmObservabilityPointInput {
+    id?: string;
+    subject?: string;
+    scope?: string;
+    operationIndex?: number;
+    at?: number;
+    path?: string;
+    selector?: string;
+    before?: unknown;
+    after?: unknown;
+    eventRefs?: readonly (string | FrontierSwarmNamedRefInput)[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmObservabilityPoint {
+    kind: typeof FRONTIER_SWARM_OBSERVABILITY_POINT_KIND;
+    version: typeof FRONTIER_SWARM_OBSERVABILITY_POINT_VERSION;
+    id: string;
+    subject?: string;
+    scope?: string;
+    operationIndex?: number;
+    at?: number;
+    path?: string;
+    selector?: string;
+    before?: JsonValue;
+    after?: JsonValue;
+    eventRefs: FrontierSwarmNamedRef[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmReplayBundleInput {
+    id?: string;
+    title?: string;
+    subject?: string;
+    commands?: readonly (string | FrontierSwarmCommandInput)[];
+    inputs?: readonly FrontierSwarmNamedRefInput[];
+    artifacts?: readonly FrontierSwarmNamedRefInput[];
+    sourceRefs?: readonly (string | FrontierSwarmNamedRefInput)[];
+    seeds?: readonly (string | number | FrontierSwarmNamedRefInput)[];
+    environment?: unknown;
+    expectedEvidence?: readonly string[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmReplayBundle {
+    kind: typeof FRONTIER_SWARM_REPLAY_BUNDLE_KIND;
+    version: typeof FRONTIER_SWARM_REPLAY_BUNDLE_VERSION;
+    id: string;
+    title: string;
+    subject?: string;
+    generatedAt: number;
+    commands: FrontierSwarmCommand[];
+    inputs: FrontierSwarmNamedRef[];
+    artifacts: FrontierSwarmNamedRef[];
+    sourceRefs: FrontierSwarmNamedRef[];
+    seeds: FrontierSwarmNamedRef[];
+    environment?: JsonObject;
+    expectedEvidence: string[];
+    summary: {
+        commandCount: number;
+        inputCount: number;
+        artifactCount: number;
+        sourceRefCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmParityComparatorInput {
+    id?: string;
+    title?: string;
+    status?: FrontierSwarmParityOracleStatus;
+    expected?: unknown;
+    actual?: unknown;
+    path?: string;
+    operationIndex?: number;
+    evidenceRefs?: readonly (string | FrontierSwarmNamedRefInput)[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmParityComparator {
+    id: string;
+    title: string;
+    status: FrontierSwarmParityOracleStatus;
+    expected?: JsonValue;
+    actual?: JsonValue;
+    path?: string;
+    operationIndex?: number;
+    evidenceRefs: FrontierSwarmNamedRef[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmParityOracleInput {
+    id?: string;
+    title?: string;
+    status?: FrontierSwarmParityOracleStatus;
+    subject?: string;
+    referenceCommands?: readonly (string | FrontierSwarmCommandInput)[];
+    testCommands?: readonly (string | FrontierSwarmCommandInput)[];
+    comparators?: readonly FrontierSwarmParityComparatorInput[];
+    artifacts?: readonly FrontierSwarmNamedRefInput[];
+    replayBundleIds?: readonly string[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmParityOracle {
+    kind: typeof FRONTIER_SWARM_PARITY_ORACLE_KIND;
+    version: typeof FRONTIER_SWARM_PARITY_ORACLE_VERSION;
+    id: string;
+    title: string;
+    status: FrontierSwarmParityOracleStatus;
+    subject?: string;
+    generatedAt: number;
+    referenceCommands: FrontierSwarmCommand[];
+    testCommands: FrontierSwarmCommand[];
+    comparators: FrontierSwarmParityComparator[];
+    artifacts: FrontierSwarmNamedRef[];
+    replayBundleIds: string[];
+    summary: {
+        comparatorCount: number;
+        passedCount: number;
+        failedCount: number;
+        blockedCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmDivergenceReportInput {
+    id?: string;
+    title?: string;
+    status?: FrontierSwarmParityOracleStatus;
+    severity?: FrontierSwarmDivergenceSeverity;
+    subject?: string;
+    confidence?: FrontierSwarmConfidence;
+    divergesAt?: string;
+    operationIndex?: number;
+    expected?: unknown;
+    actual?: unknown;
+    observabilityPoints?: readonly (FrontierSwarmObservabilityPoint | FrontierSwarmObservabilityPointInput)[];
+    traceRefs?: readonly (string | FrontierSwarmNamedRefInput)[];
+    replayBundleIds?: readonly string[];
+    evidenceRefs?: readonly (string | FrontierSwarmNamedRefInput)[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmDivergenceReport {
+    kind: typeof FRONTIER_SWARM_DIVERGENCE_REPORT_KIND;
+    version: typeof FRONTIER_SWARM_DIVERGENCE_REPORT_VERSION;
+    id: string;
+    title: string;
+    status: FrontierSwarmParityOracleStatus;
+    severity: FrontierSwarmDivergenceSeverity;
+    subject?: string;
+    confidence: FrontierSwarmConfidence;
+    divergesAt?: string;
+    operationIndex?: number;
+    expected?: JsonValue;
+    actual?: JsonValue;
+    observabilityPoints: FrontierSwarmObservabilityPoint[];
+    traceRefs: FrontierSwarmNamedRef[];
+    replayBundleIds: string[];
+    evidenceRefs: FrontierSwarmNamedRef[];
+    generatedAt: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmWatchpointInput {
+    id?: string;
+    title?: string;
+    target?: string;
+    path?: string;
+    selector?: string;
+    operator?: string;
+    value?: unknown;
+    action?: FrontierSwarmWatchpointAction;
+    metadata?: unknown;
+}
+export interface FrontierSwarmWatchpoint {
+    id: string;
+    title: string;
+    target?: string;
+    path?: string;
+    selector?: string;
+    operator: string;
+    value?: JsonValue;
+    action: FrontierSwarmWatchpointAction;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmWatchpointPlanInput {
+    id?: string;
+    title?: string;
+    subject?: string;
+    matchMode?: 'all' | 'any' | string;
+    watchpoints?: readonly FrontierSwarmWatchpointInput[];
+    commands?: readonly (string | FrontierSwarmCommandInput)[];
+    replayBundleIds?: readonly string[];
+    divergenceReportIds?: readonly string[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmWatchpointPlan {
+    kind: typeof FRONTIER_SWARM_WATCHPOINT_PLAN_KIND;
+    version: typeof FRONTIER_SWARM_WATCHPOINT_PLAN_VERSION;
+    id: string;
+    title: string;
+    subject?: string;
+    matchMode: string;
+    generatedAt: number;
+    watchpoints: FrontierSwarmWatchpoint[];
+    commands: FrontierSwarmCommand[];
+    replayBundleIds: string[];
+    divergenceReportIds: string[];
+    summary: {
+        watchpointCount: number;
+        commandCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmDebugHandoffInput {
+    id?: string;
+    title?: string;
+    status?: 'ready' | 'needs-review' | 'blocked' | 'failed' | string;
+    subject?: string;
+    focus?: FrontierSwarmObservabilityPointInput | FrontierSwarmObservabilityPoint;
+    replayBundleIds?: readonly string[];
+    divergenceReportIds?: readonly string[];
+    watchpointPlanIds?: readonly string[];
+    commands?: readonly (string | FrontierSwarmCommandInput)[];
+    files?: readonly FrontierSwarmNamedRefInput[];
+    artifacts?: readonly FrontierSwarmNamedRefInput[];
+    comparisons?: readonly FrontierSwarmParityComparatorInput[];
+    environment?: unknown;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmDebugHandoff {
+    kind: typeof FRONTIER_SWARM_DEBUG_HANDOFF_KIND;
+    version: typeof FRONTIER_SWARM_DEBUG_HANDOFF_VERSION;
+    id: string;
+    title: string;
+    status: string;
+    subject?: string;
+    focus?: FrontierSwarmObservabilityPoint;
+    replayBundleIds: string[];
+    divergenceReportIds: string[];
+    watchpointPlanIds: string[];
+    commands: FrontierSwarmCommand[];
+    files: FrontierSwarmNamedRef[];
+    artifacts: FrontierSwarmNamedRef[];
+    comparisons: FrontierSwarmParityComparator[];
+    environment?: JsonObject;
+    generatedAt: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmInstrumentationBudgetInput {
+    id?: string;
+    title?: string;
+    lane?: string;
+    maxEvents?: number;
+    maxBytes?: number;
+    maxDurationMs?: number;
+    maxOverheadRatio?: number;
+    captureKinds?: readonly string[];
+    sampling?: {
+        mode?: string;
+        rate?: number;
+        metadata?: unknown;
+    };
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmInstrumentationBudget {
+    kind: typeof FRONTIER_SWARM_INSTRUMENTATION_BUDGET_KIND;
+    version: typeof FRONTIER_SWARM_INSTRUMENTATION_BUDGET_VERSION;
+    id: string;
+    title: string;
+    lane?: string;
+    generatedAt: number;
+    maxEvents?: number;
+    maxBytes?: number;
+    maxDurationMs?: number;
+    maxOverheadRatio?: number;
+    captureKinds: string[];
+    sampling: {
+        mode: string;
+        rate?: number;
+        metadata?: JsonObject;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmInstrumentationUsageInput {
+    events?: number;
+    bytes?: number;
+    durationMs?: number;
+    overheadRatio?: number;
+    captureKinds?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmInstrumentationBudgetDecision {
+    ok: boolean;
+    budgetId: string;
+    usage: {
+        events: number;
+        bytes: number;
+        durationMs: number;
+        overheadRatio: number;
+        captureKinds: string[];
+        metadata?: JsonObject;
+    };
+    violations: string[];
+}
+export interface FrontierSwarmBottleneckSource {
+    jobId?: string;
+    lane?: string;
+    text?: string;
+    status?: string;
+    reasons?: readonly string[];
+    verification?: readonly FrontierSwarmVerificationResultInput[];
+    evidencePaths?: readonly string[];
+    changedPaths?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmBottleneckClassification {
+    kind: FrontierSwarmBottleneckKind;
+    confidence: FrontierSwarmConfidence;
+    reasons: string[];
+    route: {
+        lane?: string;
+        workKind?: string;
+        priority?: number;
+    };
+}
+export interface FrontierSwarmBottleneckReportInput {
+    id?: string;
+    sources?: readonly (FrontierSwarmBottleneckSource | FrontierSwarmJobResultInput | FrontierSwarmMergeBundle)[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmBottleneckReport {
+    kind: typeof FRONTIER_SWARM_BOTTLENECK_REPORT_KIND;
+    version: typeof FRONTIER_SWARM_BOTTLENECK_REPORT_VERSION;
+    id: string;
+    generatedAt: number;
+    classifications: FrontierSwarmBottleneckClassification[];
+    byKind: Record<string, FrontierSwarmBottleneckClassification[]>;
+    summary: {
+        sourceCount: number;
+        kindCount: number;
+    };
+    metadata?: JsonObject;
+}
+export type FrontierSwarmEvidenceFacetValue = string | number | boolean;
+export interface FrontierSwarmEvidenceIndexEntryInput {
+    id?: string;
+    jobId?: string;
+    queueItemId?: string;
+    lane?: string;
+    topic?: string;
+    path?: string;
+    kind?: string;
+    status?: string;
+    confidence?: number;
+    tags?: readonly string[];
+    facets?: Record<string, FrontierSwarmEvidenceFacetValue>;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmEvidenceIndexEntry {
+    id: string;
+    jobId?: string;
+    queueItemId?: string;
+    lane?: string;
+    topic?: string;
+    path?: string;
+    kind: string;
+    status: string;
+    confidence: number;
+    tags: string[];
+    facets: Record<string, FrontierSwarmEvidenceFacetValue>;
+    generatedAt: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmEvidenceIndexInput {
+    id?: string;
+    run?: FrontierSwarmRun;
+    entries?: readonly FrontierSwarmEvidenceIndexEntryInput[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmEvidenceIndex {
+    kind: typeof FRONTIER_SWARM_EVIDENCE_INDEX_KIND;
+    version: typeof FRONTIER_SWARM_EVIDENCE_INDEX_VERSION;
+    id: string;
+    runId?: string;
+    generatedAt: number;
+    entries: FrontierSwarmEvidenceIndexEntry[];
+    byJobId: Record<string, FrontierSwarmEvidenceIndexEntry[]>;
+    byTopic: Record<string, FrontierSwarmEvidenceIndexEntry[]>;
+    byPath: Record<string, FrontierSwarmEvidenceIndexEntry[]>;
+    summary: {
+        entryCount: number;
+        jobCount: number;
+        topicCount: number;
+        pathCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmEvidenceIndexQuery {
+    jobId?: string;
+    lane?: string;
+    topic?: string;
+    pathIncludes?: string;
+    kind?: string;
+    status?: string;
+    tag?: string;
+    minConfidence?: number;
+    facet?: Record<string, FrontierSwarmEvidenceFacetValue>;
+}
+export interface FrontierSwarmEvidenceIndexQueryResult {
+    entries: FrontierSwarmEvidenceIndexEntry[];
+    summary: {
+        entryCount: number;
+    };
+}
+export interface FrontierSwarmBlackboardEntryInput {
+    id?: string;
+    kind?: FrontierSwarmBlackboardEntryKind;
+    topic?: string;
+    status?: string;
+    text?: string;
+    lane?: string;
+    jobId?: string;
+    owner?: string;
+    confidence?: FrontierSwarmConfidence;
+    sourceIds?: readonly string[];
+    paths?: readonly string[];
+    tags?: readonly string[];
+    supersedes?: readonly string[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmBlackboardEntry {
+    id: string;
+    kind: FrontierSwarmBlackboardEntryKind;
+    topic: string;
+    status: string;
+    text: string;
+    lane?: string;
+    jobId?: string;
+    owner?: string;
+    confidence: FrontierSwarmConfidence;
+    sourceIds: string[];
+    paths: string[];
+    tags: string[];
+    supersedes: string[];
+    generatedAt: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmBlackboardInput {
+    id?: string;
+    runId?: string;
+    entries?: readonly FrontierSwarmBlackboardEntryInput[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmBlackboard {
+    kind: typeof FRONTIER_SWARM_BLACKBOARD_KIND;
+    version: typeof FRONTIER_SWARM_BLACKBOARD_VERSION;
+    id: string;
+    runId?: string;
+    generatedAt: number;
+    entries: FrontierSwarmBlackboardEntry[];
+    byTopic: Record<string, FrontierSwarmBlackboardEntry[]>;
+    byKind: Record<string, FrontierSwarmBlackboardEntry[]>;
+    summary: {
+        entryCount: number;
+        topicCount: number;
+        kindCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmBlackboardQuery {
+    kind?: FrontierSwarmBlackboardEntryKind;
+    topic?: string;
+    status?: string;
+    lane?: string;
+    jobId?: string;
+    owner?: string;
+    tag?: string;
+    textIncludes?: string;
+}
+export interface FrontierSwarmBlackboardQueryResult {
+    entries: FrontierSwarmBlackboardEntry[];
+    summary: {
+        entryCount: number;
+    };
+}
+export interface FrontierSwarmReferenceOraclePlanInput {
+    id?: string;
+    serviceId?: string;
+    subject?: string;
+    fixtureId?: string;
+    targets?: readonly {
+        id: string;
+        role?: string;
+        command?: string | FrontierSwarmCommandInput;
+        metadata?: unknown;
+    }[];
+    window?: {
+        start?: number;
+        end?: number;
+        focus?: string;
+        metadata?: unknown;
+    };
+    watchpoints?: readonly FrontierSwarmWatchpointInput[];
+    artifactKinds?: readonly string[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmReferenceOraclePlan {
+    kind: typeof FRONTIER_SWARM_REFERENCE_ORACLE_PLAN_KIND;
+    version: typeof FRONTIER_SWARM_REFERENCE_ORACLE_PLAN_VERSION;
+    id: string;
+    serviceId?: string;
+    subject?: string;
+    fixtureId?: string;
+    generatedAt: number;
+    targets: {
+        id: string;
+        role: string;
+        command?: FrontierSwarmCommand;
+        metadata?: JsonObject;
+    }[];
+    window?: {
+        start?: number;
+        end?: number;
+        focus?: string;
+        metadata?: JsonObject;
+    };
+    watchpoints: FrontierSwarmWatchpoint[];
+    artifactKinds: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmReferenceOracleResponseInput {
+    id?: string;
+    planId?: string;
+    status?: FrontierSwarmParityOracleStatus;
+    subject?: string;
+    targetResults?: readonly {
+        targetId: string;
+        status?: FrontierSwarmParityOracleStatus;
+        artifacts?: readonly FrontierSwarmNamedRefInput[];
+        metadata?: unknown;
+    }[];
+    divergence?: FrontierSwarmDivergenceReportInput;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmReferenceOracleResponse {
+    kind: typeof FRONTIER_SWARM_REFERENCE_ORACLE_RESPONSE_KIND;
+    version: typeof FRONTIER_SWARM_REFERENCE_ORACLE_RESPONSE_VERSION;
+    id: string;
+    planId?: string;
+    status: FrontierSwarmParityOracleStatus;
+    subject?: string;
+    generatedAt: number;
+    targetResults: {
+        targetId: string;
+        status: FrontierSwarmParityOracleStatus;
+        artifacts: FrontierSwarmNamedRef[];
+        metadata?: JsonObject;
+    }[];
+    divergence?: FrontierSwarmDivergenceReport;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmRoutingHintInput {
+    artifactKind?: string;
+    pathPattern?: string;
+    lane?: string;
+    bucket?: FrontierSwarmQueueOverlayStatus;
+    reason?: string;
+    metadata?: unknown;
+}
+export interface FrontierSwarmRoutingHint {
+    artifactKind?: string;
+    pathPattern?: string;
+    lane?: string;
+    bucket: FrontierSwarmQueueOverlayStatus;
+    reason: string;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmArtifactRoutingPlanInput {
+    id?: string;
+    bundles?: readonly FrontierSwarmMergeBundle[];
+    artifacts?: readonly FrontierSwarmNamedRefInput[];
+    hints?: readonly FrontierSwarmRoutingHintInput[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmArtifactRoutingPlan {
+    kind: typeof FRONTIER_SWARM_ARTIFACT_ROUTING_PLAN_KIND;
+    version: typeof FRONTIER_SWARM_ARTIFACT_ROUTING_PLAN_VERSION;
+    id: string;
+    generatedAt: number;
+    routes: {
+        artifact: FrontierSwarmNamedRef;
+        bucket: FrontierSwarmQueueOverlayStatus;
+        lane?: string;
+        reasons: string[];
+    }[];
+    byBucket: Record<string, string[]>;
+    summary: {
+        routeCount: number;
+        bucketCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmSchedulerRecommendationsInput {
+    id?: string;
+    schedule: FrontierSwarmSchedule;
+    mergeIndex?: FrontierSwarmMergeIndex;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmSchedulerRecommendation {
+    id: string;
+    reason: string;
+    jobIds: string[];
+    resource?: string;
+    lane?: string;
+    action: string;
+    priority: number;
+}
+export interface FrontierSwarmSchedulerRecommendations {
+    kind: typeof FRONTIER_SWARM_SCHEDULER_RECOMMENDATIONS_KIND;
+    version: typeof FRONTIER_SWARM_SCHEDULER_RECOMMENDATIONS_VERSION;
+    id: string;
+    scheduleId: string;
+    generatedAt: number;
+    recommendations: FrontierSwarmSchedulerRecommendation[];
+    summary: {
+        recommendationCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmFixtureInput {
+    id: string;
+    title?: string;
+    description?: string;
+    state?: unknown;
+    artifacts?: readonly FrontierSwarmNamedRefInput[];
+    setupCommands?: readonly (string | FrontierSwarmCommandInput)[];
+    tags?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmFixture {
+    id: string;
+    title: string;
+    description?: string;
+    state?: JsonValue;
+    artifacts: FrontierSwarmNamedRef[];
+    setupCommands: FrontierSwarmCommand[];
+    tags: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmFixtureCatalogInput {
+    id?: string;
+    fixtures?: readonly FrontierSwarmFixtureInput[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmFixtureCatalog {
+    kind: typeof FRONTIER_SWARM_FIXTURE_CATALOG_KIND;
+    version: typeof FRONTIER_SWARM_FIXTURE_CATALOG_VERSION;
+    id: string;
+    generatedAt: number;
+    fixtures: FrontierSwarmFixture[];
+    byTag: Record<string, string[]>;
+    summary: {
+        fixtureCount: number;
+        tagCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmProgressItemInput {
+    id: string;
+    surface?: string;
+    status?: FrontierSwarmProgressStatus;
+    evidencePaths?: readonly string[];
+    blockers?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmProgressItem {
+    id: string;
+    surface?: string;
+    status: FrontierSwarmProgressStatus;
+    evidencePaths: string[];
+    blockers: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmProgressModelInput {
+    id?: string;
+    items?: readonly FrontierSwarmProgressItemInput[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmProgressModel {
+    kind: typeof FRONTIER_SWARM_PROGRESS_MODEL_KIND;
+    version: typeof FRONTIER_SWARM_PROGRESS_MODEL_VERSION;
+    id: string;
+    generatedAt: number;
+    items: FrontierSwarmProgressItem[];
+    byStatus: Record<string, string[]>;
+    summary: {
+        itemCount: number;
+        acceptedCount: number;
+        blockedCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmAutoReviewFindingInput {
+    id?: string;
+    jobId?: string;
+    kind?: FrontierSwarmAutoReviewFindingKind;
+    severity?: FrontierSwarmDivergenceSeverity;
+    message: string;
+    paths?: readonly string[];
+    evidencePaths?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmAutoReviewFinding {
+    id: string;
+    jobId?: string;
+    kind: FrontierSwarmAutoReviewFindingKind;
+    severity: FrontierSwarmDivergenceSeverity;
+    message: string;
+    paths: string[];
+    evidencePaths: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmAutoReviewReportInput {
+    id?: string;
+    bundles?: readonly FrontierSwarmMergeBundle[];
+    findings?: readonly FrontierSwarmAutoReviewFindingInput[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmAutoReviewReport {
+    kind: typeof FRONTIER_SWARM_AUTO_REVIEW_REPORT_KIND;
+    version: typeof FRONTIER_SWARM_AUTO_REVIEW_REPORT_VERSION;
+    id: string;
+    generatedAt: number;
+    findings: FrontierSwarmAutoReviewFinding[];
+    byKind: Record<string, FrontierSwarmAutoReviewFinding[]>;
+    summary: {
+        findingCount: number;
+        highSeverityCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmRebaseReportInput {
+    id?: string;
+    currentHead?: string;
+    mergeIndex?: FrontierSwarmMergeIndex;
+    bundles?: readonly FrontierSwarmMergeBundle[];
+    entries?: readonly {
+        jobId: string;
+        status?: FrontierSwarmRebaseStatus;
+        reasons?: readonly string[];
+        metadata?: unknown;
+    }[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmRebaseReport {
+    kind: typeof FRONTIER_SWARM_REBASE_REPORT_KIND;
+    version: typeof FRONTIER_SWARM_REBASE_REPORT_VERSION;
+    id: string;
+    currentHead?: string;
+    generatedAt: number;
+    entries: {
+        jobId: string;
+        status: FrontierSwarmRebaseStatus;
+        reasons: string[];
+        metadata?: JsonObject;
+    }[];
+    byStatus: Record<string, string[]>;
+    summary: {
+        entryCount: number;
+        cleanCount: number;
+        conflictCount: number;
+        staleCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmUsageGovernorInput {
+    id?: string;
+    maxWorkers?: number;
+    maxTokensByLane?: Record<string, number>;
+    maxCostUsd?: number;
+    retryBudget?: number;
+    stopConditions?: readonly string[];
+    preferStaticWhenLowBudget?: boolean;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmUsageGovernor {
+    kind: typeof FRONTIER_SWARM_USAGE_GOVERNOR_KIND;
+    version: typeof FRONTIER_SWARM_USAGE_GOVERNOR_VERSION;
+    id: string;
+    generatedAt: number;
+    maxWorkers?: number;
+    maxTokensByLane: Record<string, number>;
+    maxCostUsd?: number;
+    retryBudget: number;
+    stopConditions: string[];
+    preferStaticWhenLowBudget: boolean;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmUsageGovernorDecision {
+    ok: boolean;
+    reasons: string[];
+    recommendedMaxWorkers?: number;
+    preferStatic: boolean;
+}
+export interface FrontierSwarmLanePlaybookInput {
+    id?: string;
+    lane: string;
+    title?: string;
+    successfulBundles?: readonly FrontierSwarmMergeBundle[];
+    notes?: readonly string[];
+    commands?: readonly (string | FrontierSwarmCommandInput)[];
+    avoidInvestigating?: readonly string[];
+    evidencePatterns?: readonly string[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmLanePlaybook {
+    kind: typeof FRONTIER_SWARM_LANE_PLAYBOOK_KIND;
+    version: typeof FRONTIER_SWARM_LANE_PLAYBOOK_VERSION;
+    id: string;
+    lane: string;
+    title: string;
+    generatedAt: number;
+    notes: string[];
+    commands: FrontierSwarmCommand[];
+    avoidInvestigating: string[];
+    evidencePatterns: string[];
+    successfulJobIds: string[];
+    hotPaths: string[];
+    changedRegions: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmPatchStackPlanInput {
+    id?: string;
+    index: FrontierSwarmMergeIndex;
+    maxStackSize?: number;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmPatchStackPlan {
+    kind: typeof FRONTIER_SWARM_PATCH_STACK_PLAN_KIND;
+    version: typeof FRONTIER_SWARM_PATCH_STACK_PLAN_VERSION;
+    id: string;
+    mergeIndexId: string;
+    generatedAt: number;
+    stacks: FrontierSwarmPatchStack[];
+    summary: {
+        stackCount: number;
+        jobCount: number;
+        conflictedStackCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmPatchStack {
+    id: string;
+    title: string;
+    lane?: string;
+    jobIds: string[];
+    changedPaths: string[];
+    changedRegions: string[];
+    riskLevels: string[];
+    dispositions: string[];
+    conflicts: FrontierSwarmMergeConflict[];
+    gateHints: string[];
+}
 export interface FrontierSwarmProof {
     kind: typeof FRONTIER_SWARM_PROOF_KIND;
     version: typeof FRONTIER_SWARM_PROOF_VERSION;
@@ -1059,6 +2387,46 @@ export declare function classifySwarmMergeDisposition(result: FrontierSwarmJobRe
     staleAgainstHead?: boolean;
 }): FrontierSwarmMergeDisposition;
 export declare function createSwarmMergeBundle(input: FrontierSwarmMergeBundleInput): FrontierSwarmMergeBundle;
+export declare function createSwarmQueueOverlay(input?: FrontierSwarmQueueOverlayInput): FrontierSwarmQueueOverlay;
+export declare function deriveSwarmQueueStatus(input: FrontierSwarmDerivedQueueStatusInput): FrontierSwarmDerivedQueueStatus;
+export declare function createSwarmMergeIndex(input: FrontierSwarmMergeIndexInput): FrontierSwarmMergeIndex;
+export declare function checkSwarmRegionOwnership(job: FrontierSwarmJob, input?: FrontierSwarmRegionOwnershipInput): FrontierSwarmRegionOwnershipReport;
+export declare function createSwarmHotspotReport(input?: FrontierSwarmHotspotReportInput): FrontierSwarmHotspotReport;
+export declare function createSwarmReviewerLanePlan(input: FrontierSwarmReviewerLanePlanInput): FrontierSwarmReviewerLanePlan;
+export declare function createSwarmRunStoreShards(input?: FrontierSwarmRunStoreShardsInput): FrontierSwarmRunStoreShards;
+export declare function createSwarmMergeAdmission(input: FrontierSwarmMergeAdmissionInput): FrontierSwarmMergeAdmission;
+export declare function createSwarmContextPack(input?: FrontierSwarmContextPackInput): FrontierSwarmContextPack;
+export declare function createSwarmOracleCorpus(input?: FrontierSwarmOracleCorpusInput): FrontierSwarmOracleCorpus;
+export declare function createSwarmObservabilityPoint(input?: FrontierSwarmObservabilityPointInput): FrontierSwarmObservabilityPoint;
+export declare function createSwarmReplayBundle(input?: FrontierSwarmReplayBundleInput): FrontierSwarmReplayBundle;
+export declare function createSwarmParityOracle(input?: FrontierSwarmParityOracleInput): FrontierSwarmParityOracle;
+export declare function createSwarmDivergenceReport(input?: FrontierSwarmDivergenceReportInput): FrontierSwarmDivergenceReport;
+export declare function createSwarmWatchpointPlan(input?: FrontierSwarmWatchpointPlanInput): FrontierSwarmWatchpointPlan;
+export declare function createSwarmDebugHandoff(input?: FrontierSwarmDebugHandoffInput): FrontierSwarmDebugHandoff;
+export declare function createSwarmInstrumentationBudget(input?: FrontierSwarmInstrumentationBudgetInput): FrontierSwarmInstrumentationBudget;
+export declare function checkSwarmInstrumentationBudget(budgetInput: FrontierSwarmInstrumentationBudget | FrontierSwarmInstrumentationBudgetInput, usageInput?: FrontierSwarmInstrumentationUsageInput): FrontierSwarmInstrumentationBudgetDecision;
+export declare function classifySwarmBottleneck(input: FrontierSwarmBottleneckSource | FrontierSwarmJobResultInput | FrontierSwarmMergeBundle): FrontierSwarmBottleneckClassification;
+export declare function createSwarmBottleneckReport(input?: FrontierSwarmBottleneckReportInput): FrontierSwarmBottleneckReport;
+export declare function createSwarmEvidenceIndex(input?: FrontierSwarmRun | FrontierSwarmEvidenceIndexInput): FrontierSwarmEvidenceIndex;
+export declare function querySwarmEvidenceIndex(index: FrontierSwarmEvidenceIndex, query?: FrontierSwarmEvidenceIndexQuery): FrontierSwarmEvidenceIndexQueryResult;
+export declare function createSwarmBlackboard(input?: FrontierSwarmBlackboardInput): FrontierSwarmBlackboard;
+export declare function querySwarmBlackboard(blackboard: FrontierSwarmBlackboard, query?: FrontierSwarmBlackboardQuery): FrontierSwarmBlackboardQueryResult;
+export declare function createSwarmReferenceOraclePlan(input?: FrontierSwarmReferenceOraclePlanInput): FrontierSwarmReferenceOraclePlan;
+export declare function createSwarmReferenceOracleResponse(input?: FrontierSwarmReferenceOracleResponseInput): FrontierSwarmReferenceOracleResponse;
+export declare function createSwarmArtifactRoutingPlan(input?: FrontierSwarmArtifactRoutingPlanInput): FrontierSwarmArtifactRoutingPlan;
+export declare function createSwarmFixtureCatalog(input?: FrontierSwarmFixtureCatalogInput): FrontierSwarmFixtureCatalog;
+export declare function createSwarmProgressModel(input?: FrontierSwarmProgressModelInput): FrontierSwarmProgressModel;
+export declare function createSwarmAutoReviewReport(input?: FrontierSwarmAutoReviewReportInput): FrontierSwarmAutoReviewReport;
+export declare function createSwarmRebaseReport(input?: FrontierSwarmRebaseReportInput): FrontierSwarmRebaseReport;
+export declare function createSwarmUsageGovernor(input?: FrontierSwarmUsageGovernorInput): FrontierSwarmUsageGovernor;
+export declare function checkSwarmUsageGovernor(governorInput: FrontierSwarmUsageGovernor | FrontierSwarmUsageGovernorInput, usage?: {
+    activeWorkers?: number;
+    costUsd?: number;
+    tokensByLane?: Record<string, number>;
+    retriesUsed?: number;
+}): FrontierSwarmUsageGovernorDecision;
+export declare function createSwarmLanePlaybook(input: FrontierSwarmLanePlaybookInput): FrontierSwarmLanePlaybook;
+export declare function createSwarmPatchStackPlan(input: FrontierSwarmPatchStackPlanInput): FrontierSwarmPatchStackPlan;
 export declare function resolveSwarmCompute(manifestInput: FrontierSwarmManifest | FrontierSwarmManifestInput, taskInput: FrontierSwarmTask | FrontierSwarmTaskInput): FrontierSwarmCompute;
 export declare function createSwarmProof(input: FrontierSwarmManifest | FrontierSwarmPlan | FrontierSwarmRun, options?: {
     generatedAt?: number;
@@ -1066,6 +2434,7 @@ export declare function createSwarmProof(input: FrontierSwarmManifest | Frontier
     metadata?: unknown;
 }): FrontierSwarmProof;
 export declare function createSwarmSchedule(input: FrontierSwarmPlan | FrontierSwarmScheduleInput): FrontierSwarmSchedule;
+export declare function createSwarmSchedulerRecommendations(input: FrontierSwarmSchedulerRecommendationsInput): FrontierSwarmSchedulerRecommendations;
 export declare function createSwarmLeases(input: FrontierSwarmLeaseInput): FrontierSwarmLease[];
 export declare function renewSwarmLease(input: FrontierSwarmLeaseRenewalInput): FrontierSwarmLease;
 export declare function createSwarmQueueSnapshot(input: FrontierSwarmQueueSnapshotInput): FrontierSwarmQueueSnapshot;