@shapeshift-labs/frontier-swarm 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -47,6 +47,44 @@ export declare const FRONTIER_SWARM_CONTEXT_PACK_KIND = "frontier.swarm.context-
 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";
@@ -64,6 +102,15 @@ export type FrontierSwarmMergeDisposition = 'auto-mergeable' | 'needs-port' | 'd
 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;
@@ -426,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 {
@@ -448,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;
@@ -554,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;
@@ -1406,6 +1456,845 @@ export interface FrontierSwarmOracleCorpus {
     };
     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;
@@ -1508,6 +2397,34 @@ export declare function createSwarmRunStoreShards(input?: FrontierSwarmRunStoreS
 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;
@@ -1517,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;