@shapeshift-labs/frontier-swarm 0.5.20 → 0.5.22

package/dist/index.d.ts

@@ -1,42 +1,4802 @@
-export * from './constants.js';
-export { compileSwarm, createSwarmManifest, defineSwarmManifest, defineSwarmTasks, validateSwarmManifest } from './manifest.js';
-export type * from './types.js';
-export * from './plan.js';
-export * from './scheduler.js';
-export * from './leases.js';
-export { completeSwarmJob, createSwarmEventStream, createSwarmMailbox, createSwarmRun, recordSwarmEvent, routeSwarmEventToMailboxes } from './run-records.js';
-export { matchesGlob } from './internal.js';
-export { classifySwarmMergeDisposition, classifySwarmMergeReadiness } from './merge-bundles.js';
-export { createSwarmMergeAdmission } from './merge-admission.js';
-export { createSwarmMergeIndex } from './merge-index.js';
-export { createSwarmReviewerLanePlan } from './merge-review.js';
-export { deriveSwarmQueueStatus } from './queue-overlays.js';
-export { createSwarmBlackboard, querySwarmBlackboard } from './blackboard.js';
-export { createSwarmFixtureCatalog } from './fixtures.js';
-export { createSwarmProgressModel } from './progress.js';
-export { createSwarmAutoReviewReport } from './auto-review.js';
-export { createSwarmUsageGovernor, checkSwarmUsageGovernor } from './usage-governor.js';
-export { createSwarmAdaptiveLoadPlan, createSwarmScheduleInputFromAdaptiveLoadPlan } from './adaptive-load.js';
-export { createSwarmCoordinatorDashboard, querySwarmCoordinatorDashboard } from './coordinator-dashboard.js';
-export { normalizeScoringPolicy, scoreSwarmPayoffVector } from './tournament-scoring.js';
-export { createSwarmPayoffVector, createSwarmStrategyCertificate, createSwarmStrategyTournament, querySwarmStrategyTournament } from './tournament-runtime.js';
-export { createSwarmContextualBanditRecommendations, normalizeContextualBanditPolicy } from './tournament-bandit.js';
-export { createTournamentSampleQuality } from './tournament-sample-quality.js';
-export { createSwarmMergePayoffVector, createSwarmMergeTournament } from './tournament-merge.js';
-export { compareSwarmStrategyTournaments, createSwarmStrategyTournamentHistory, createSwarmTournamentAdaptiveFeedback } from './tournament-history.js';
-export * from './ownership-runtime.js';
-export * from './run-store-shards-runtime.js';
-export * from './merge-wrappers.js';
-export * from './context-pack-runtime.js';
-export * from './oracle-runtime.js';
-export * from './trace-runtime.js';
-export * from './debug-runtime.js';
-export * from './instrumentation-runtime.js';
-export * from './evidence-index.js';
-export * from './reference-oracle-runtime.js';
-export * from './artifact-routing-runtime.js';
-export * from './rebase-report.js';
-export * from './patch-stack-runtime.js';
-export * from './proof-runtime.js';
-export * from './merge-plans-runtime.js';
+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";
+export declare const FRONTIER_SWARM_TASK_VERSION = 1;
+export declare const FRONTIER_SWARM_PLAN_KIND = "frontier.swarm.plan";
+export declare const FRONTIER_SWARM_PLAN_VERSION = 1;
+export declare const FRONTIER_SWARM_RUN_KIND = "frontier.swarm.run";
+export declare const FRONTIER_SWARM_RUN_VERSION = 1;
+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";
+export declare const FRONTIER_SWARM_PROOF_VERSION = 1;
+export declare const FRONTIER_SWARM_SCHEDULE_KIND = "frontier.swarm.schedule";
+export declare const FRONTIER_SWARM_SCHEDULE_VERSION = 1;
+export declare const FRONTIER_SWARM_LEASE_KIND = "frontier.swarm.lease";
+export declare const FRONTIER_SWARM_LEASE_VERSION = 1;
+export declare const FRONTIER_SWARM_QUEUE_SNAPSHOT_KIND = "frontier.swarm.queue-snapshot";
+export declare const FRONTIER_SWARM_QUEUE_SNAPSHOT_VERSION = 1;
+export declare const FRONTIER_SWARM_RUN_CHECKPOINT_KIND = "frontier.swarm.run-checkpoint";
+export declare const FRONTIER_SWARM_RUN_CHECKPOINT_VERSION = 1;
+export declare const FRONTIER_SWARM_ARTIFACT_INDEX_KIND = "frontier.swarm.artifact-index";
+export declare const FRONTIER_SWARM_ARTIFACT_INDEX_VERSION = 1;
+export declare const FRONTIER_SWARM_REVIEW_PLAN_KIND = "frontier.swarm.review-plan";
+export declare const FRONTIER_SWARM_REVIEW_PLAN_VERSION = 1;
+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";
+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_HIERARCHICAL_MERGE_QUEUE_KIND = "frontier.swarm.hierarchical-merge-queue";
+export declare const FRONTIER_SWARM_HIERARCHICAL_MERGE_QUEUE_VERSION = 1;
+export declare const FRONTIER_SWARM_COORDINATOR_AGENT_DRAIN_WORK_KIND = "frontier.swarm.coordinator-agent-drain-work";
+export declare const FRONTIER_SWARM_COORDINATOR_AGENT_DRAIN_WORK_VERSION = 1;
+export declare const FRONTIER_SWARM_QUEUE_OUTCOME_MODEL_KIND = "frontier.swarm.queue-outcome-model";
+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";
+export declare const FRONTIER_SWARM_MODEL_ROUTE_VERSION = 1;
+export declare const FRONTIER_SWARM_PANEL_EVALUATION_KIND = "frontier.swarm.panel-evaluation";
+export declare const FRONTIER_SWARM_PANEL_EVALUATION_VERSION = 1;
+export declare const FRONTIER_SWARM_OPTIMIZATION_SUMMARY_KIND = "frontier.swarm.optimization-summary";
+export declare const FRONTIER_SWARM_OPTIMIZATION_SUMMARY_VERSION = 1;
+export declare const FRONTIER_SWARM_CONTINUOUS_POOL_STATE_KIND = "frontier.swarm.continuous-pool-state";
+export declare const FRONTIER_SWARM_CONTINUOUS_POOL_STATE_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";
+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;
+export type FrontierSwarmTaskStatus = 'open' | 'planned' | 'running' | 'blocked' | 'failed' | 'completed' | 'verified' | string;
+export type FrontierSwarmJobStatus = 'planned' | 'scheduled' | 'running' | 'blocked' | 'failed' | 'completed' | 'verified' | string;
+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 type FrontierSwarmModelRouteStrategy = 'single-cheap' | 'single-deep' | 'panel' | 'tournament' | string;
+export type FrontierSwarmPanelStrategy = 'panel' | 'tournament' | 'auto' | string;
+export type FrontierSwarmTimePressure = 'relaxed' | 'normal' | 'soon' | 'urgent' | string;
+export type FrontierSwarmTaskModelTier = 'cheap' | 'balanced' | 'deep' | 'panel' | string;
+export type FrontierSwarmTaskModelCostBand = 'low' | 'medium' | 'high' | string;
+export type FrontierSwarmContinuousPoolPhase = 'active' | 'queued' | 'review-drain' | 'rerun' | 'human-blocked' | 'conflicted' | 'capacity-blocked' | 'done' | string;
+export type FrontierSwarmContinuousPoolBucket = 'active' | 'queued' | 'review-drain' | 'rerun' | 'human-blocked' | 'conflicted' | 'capacity-blocked' | 'done' | string;
+export type FrontierSwarmContinuousPoolStopCondition = 'drained' | 'human-blocked' | 'conflicted' | 'capacity-blocked' | string;
+export type FrontierSwarmContinuousPoolRefillAction = 'drain-review' | 'rerun-stale' | 'lease-queued' | 'start-speculative-backlog' | string;
+export type FrontierSwarmVerificationCategory = (typeof FRONTIER_SWARM_VERIFICATION_CATEGORY_HINTS)[number] | string;
+export interface FrontierSwarmComputeInput {
+    id: string;
+    kind?: FrontierSwarmComputeKind;
+    title?: string;
+    model?: string;
+    reasoningEffort?: FrontierSwarmReasoningEffort;
+    serviceTier?: string;
+    profile?: string;
+    sandbox?: string;
+    approval?: string;
+    maxConcurrency?: number;
+    timeoutMs?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmCompute {
+    id: string;
+    kind: FrontierSwarmComputeKind;
+    title?: string;
+    model?: string;
+    reasoningEffort?: FrontierSwarmReasoningEffort;
+    serviceTier?: string;
+    profile?: string;
+    sandbox?: string;
+    approval?: string;
+    maxConcurrency?: number;
+    timeoutMs?: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmLayerInput {
+    id: string;
+    title?: string;
+    description?: string;
+    parentId?: string;
+    compute?: string;
+    defaultCompute?: string;
+    childCompute?: Record<string, string>;
+    tags?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmLayer {
+    id: string;
+    title: string;
+    description?: string;
+    parentId?: string;
+    compute?: string;
+    defaultCompute?: string;
+    childCompute: Record<string, string>;
+    tags: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmOwnershipRegionInput {
+    id: string;
+    title?: string;
+    description?: string;
+    globs?: readonly string[];
+    paths?: readonly string[];
+    selectors?: readonly string[];
+    owner?: string;
+    metadata?: unknown;
+}
+export interface FrontierSwarmOwnershipRegion {
+    id: string;
+    title: string;
+    description?: string;
+    globs: string[];
+    selectors: string[];
+    owner?: string;
+    metadata?: JsonObject;
+}
+export type FrontierSwarmSemanticOwnershipRegionKind = 'named-export' | 'default-export' | 're-export' | 'namespace-export' | 'exported-declaration' | 'type' | 'cli-command' | 'docs-section' | 'fixture-family' | 'test-case' | string;
+export interface FrontierSwarmSemanticOwnershipStableKeyInput {
+    kind: FrontierSwarmSemanticOwnershipRegionKind;
+    name?: string;
+    declarationKind?: string;
+    source?: string;
+    exportName?: string;
+    command?: string;
+    section?: string;
+    family?: string;
+    testCase?: string;
+}
+export interface FrontierSwarmSemanticOwnershipRegionIdInput {
+    file: string;
+    kind: FrontierSwarmSemanticOwnershipStableKeyInput['kind'];
+    name?: string;
+    declarationKind?: string;
+    source?: string;
+    exportName?: string;
+    command?: string;
+    section?: string;
+    family?: string;
+    testCase?: string;
+}
+export declare const FRONTIER_SWARM_SEMANTIC_OWNERSHIP_EXPORT_STABLE_KEY_KIND = "exported-declaration";
+export declare const FRONTIER_SWARM_SEMANTIC_OWNERSHIP_NAMESPACE_EXPORT_STABLE_KEY_KIND = "namespace-export";
+export declare const FRONTIER_SWARM_SEMANTIC_OWNERSHIP_TYPE_STABLE_KEY_KIND = "type-declaration";
+export declare const FRONTIER_SWARM_SEMANTIC_OWNERSHIP_CLI_COMMAND_STABLE_KEY_KIND = "cli-command";
+export declare const FRONTIER_SWARM_SEMANTIC_OWNERSHIP_DOCS_SECTION_STABLE_KEY_KIND = "docs-section";
+export declare const FRONTIER_SWARM_SEMANTIC_OWNERSHIP_FIXTURE_FAMILY_STABLE_KEY_KIND = "fixture-family";
+export declare const FRONTIER_SWARM_SEMANTIC_OWNERSHIP_TEST_CASE_STABLE_KEY_KIND = "test-case";
+export interface FrontierSwarmLaneInput {
+    id: string;
+    title?: string;
+    description?: string;
+    layer?: string;
+    compute?: string;
+    allowedWrites?: readonly string[];
+    allowedGlobs?: readonly string[];
+    sharedReadOnly?: readonly string[];
+    neverEdit?: readonly string[];
+    ownershipRegions?: readonly FrontierSwarmOwnershipRegionInput[];
+    capabilities?: readonly string[];
+    resourceRequirements?: FrontierSwarmResourceRequirementsInput;
+    worktreePath?: string;
+    evidencePrefix?: string;
+    evidenceOutDirPrefix?: string;
+    concurrencyKey?: string;
+    maxConcurrency?: number;
+    handoffCommands?: readonly (string | FrontierSwarmCommandInput)[];
+    tags?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmLane {
+    id: string;
+    title: string;
+    description?: string;
+    layer?: string;
+    compute?: string;
+    allowedWrites: string[];
+    sharedReadOnly: string[];
+    neverEdit: string[];
+    ownershipRegions: FrontierSwarmOwnershipRegion[];
+    capabilities: string[];
+    resourceRequirements?: FrontierSwarmResourceRequirements;
+    worktreePath?: string;
+    evidencePrefix?: string;
+    concurrencyKey: string;
+    maxConcurrency?: number;
+    handoffCommands: FrontierSwarmCommand[];
+    tags: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmCommandInput {
+    name?: string;
+    command: string;
+    args?: readonly string[];
+    required?: boolean;
+    cwd?: string;
+    metadata?: unknown;
+}
+export interface FrontierSwarmCommand {
+    name: string;
+    command: string;
+    args: string[];
+    required: boolean;
+    cwd?: string;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmBrowserResourceInput {
+    required?: boolean;
+    portPool?: readonly (string | number)[];
+    profileDir?: string;
+    profileDirPrefix?: string;
+    maxConcurrency?: number;
+    headless?: boolean;
+    metadata?: unknown;
+}
+export interface FrontierSwarmBrowserResource {
+    required: boolean;
+    portPool: string[];
+    profileDir?: string;
+    profileDirPrefix?: string;
+    maxConcurrency?: number;
+    headless?: boolean;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmResourceRequirementsInput {
+    capabilities?: readonly string[];
+    resources?: Record<string, number>;
+    browser?: FrontierSwarmBrowserResourceInput;
+    metadata?: unknown;
+}
+export interface FrontierSwarmResourceRequirements {
+    capabilities: string[];
+    resources: Record<string, number>;
+    browser?: FrontierSwarmBrowserResource;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmPolicyInput {
+    mode?: FrontierSwarmPolicyMode;
+    defaultConcurrency?: number;
+    defaultCompute?: string;
+    defaultLayer?: string;
+    completedStatuses?: readonly string[];
+    sharedReadOnly?: readonly string[];
+    neverEditWithoutParent?: readonly string[];
+    requireCleanWorktree?: boolean;
+    metadata?: unknown;
+}
+export interface FrontierSwarmPolicy {
+    mode: FrontierSwarmPolicyMode;
+    defaultConcurrency: number;
+    defaultCompute: string;
+    defaultLayer?: string;
+    completedStatuses: string[];
+    sharedReadOnly: string[];
+    neverEditWithoutParent: string[];
+    requireCleanWorktree: boolean;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmManifestInput {
+    id?: string;
+    title?: string;
+    description?: string;
+    package?: string;
+    feature?: string;
+    owner?: string;
+    compute?: readonly FrontierSwarmComputeInput[];
+    layers?: readonly FrontierSwarmLayerInput[];
+    lanes?: readonly FrontierSwarmLaneInput[];
+    policy?: FrontierSwarmPolicyInput;
+    resources?: readonly string[];
+    tags?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmManifest {
+    kind: typeof FRONTIER_SWARM_MANIFEST_KIND;
+    version: typeof FRONTIER_SWARM_MANIFEST_VERSION;
+    id: string;
+    title: string;
+    description?: string;
+    package?: string;
+    feature?: string;
+    owner?: string;
+    compute: FrontierSwarmCompute[];
+    layers: FrontierSwarmLayer[];
+    lanes: FrontierSwarmLane[];
+    policy: FrontierSwarmPolicy;
+    resources: string[];
+    tags: string[];
+    metadata?: JsonObject;
+    summary: FrontierSwarmSummary;
+}
+export interface FrontierSwarmSummary {
+    computeCount: number;
+    layerCount: number;
+    laneCount: number;
+    taskCount?: number;
+    jobCount?: number;
+    completedCount?: number;
+    blockedCount?: number;
+    failedCount?: number;
+    ownershipViolationCount?: number;
+}
+export interface FrontierSwarmTaskInput {
+    id: string;
+    title?: string;
+    objective?: string;
+    description?: string;
+    kind?: string;
+    status?: FrontierSwarmTaskStatus;
+    lane?: string;
+    layer?: string;
+    compute?: string;
+    parentTaskId?: string;
+    dependsOn?: readonly string[];
+    concurrencyKey?: string;
+    budget?: FrontierSwarmBudgetInput;
+    review?: FrontierSwarmReviewPolicyInput;
+    priority?: number;
+    sourceRefs?: readonly string[];
+    targetRefs?: readonly string[];
+    ownedFiles?: readonly string[];
+    allowedWrites?: readonly string[];
+    ownershipRegions?: readonly FrontierSwarmOwnershipRegionInput[];
+    ownedRegions?: readonly string[];
+    changedRegions?: readonly string[];
+    capabilities?: readonly string[];
+    resourceRequirements?: FrontierSwarmResourceRequirementsInput;
+    acceptance?: readonly string[];
+    acceptanceChecks?: readonly ({
+        id?: string;
+        description?: string;
+    } | string)[];
+    verification?: readonly (string | FrontierSwarmCommandInput)[];
+    evidenceCommand?: string;
+    shardCommand?: string;
+    tags?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmTask {
+    kind: typeof FRONTIER_SWARM_TASK_KIND;
+    version: typeof FRONTIER_SWARM_TASK_VERSION;
+    id: string;
+    title: string;
+    objective: string;
+    description?: string;
+    workKind: string;
+    status: FrontierSwarmTaskStatus;
+    lane?: string;
+    layer?: string;
+    compute?: string;
+    parentTaskId?: string;
+    dependsOn: string[];
+    concurrencyKey?: string;
+    budget?: FrontierSwarmBudget;
+    review?: FrontierSwarmReviewPolicy;
+    priority: number;
+    sourceRefs: string[];
+    targetRefs: string[];
+    allowedWrites: string[];
+    ownershipRegions: FrontierSwarmOwnershipRegion[];
+    ownedRegions: string[];
+    changedRegions: string[];
+    capabilities: string[];
+    resourceRequirements?: FrontierSwarmResourceRequirements;
+    acceptance: string[];
+    verification: FrontierSwarmCommand[];
+    evidenceCommand?: string;
+    shardCommand?: string;
+    tags: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmTaskSetInput {
+    tasks?: readonly FrontierSwarmTaskInput[];
+    items?: readonly FrontierSwarmTaskInput[];
+}
+export interface FrontierSwarmCompiled {
+    manifest: FrontierSwarmManifest;
+    validation: FrontierSwarmValidation;
+    computeById: ReadonlyMap<string, FrontierSwarmCompute>;
+    layersById: ReadonlyMap<string, FrontierSwarmLayer>;
+    lanesById: ReadonlyMap<string, FrontierSwarmLane>;
+}
+export interface FrontierSwarmValidation {
+    valid: boolean;
+    issues: FrontierSwarmValidationIssue[];
+}
+export interface FrontierSwarmValidationIssue {
+    code: string;
+    severity: 'error' | 'warning';
+    path: string;
+    message: string;
+}
+export interface FrontierSwarmPlanFilter {
+    lanes?: readonly string[];
+    layers?: readonly string[];
+    statuses?: readonly string[];
+    selectors?: readonly string[];
+    includeCompleted?: boolean;
+    limit?: number;
+    compute?: string;
+    spreadLanes?: boolean;
+}
+export type FrontierSwarmPriorityClass = 'coordinator-drain' | 'review' | 'standard' | 'speculative' | string;
+export interface FrontierSwarmPriorityPolicyClass {
+    className: FrontierSwarmPriorityClass;
+    rank: number;
+    description: string;
+    matchers: string[];
+}
+export interface FrontierSwarmPriorityPolicy {
+    kind: typeof FRONTIER_SWARM_PRIORITY_POLICY_KIND;
+    version: typeof FRONTIER_SWARM_PRIORITY_POLICY_VERSION;
+    id: string;
+    description: string;
+    classes: FrontierSwarmPriorityPolicyClass[];
+    laneFairness: {
+        strategy: 'round-robin-within-priority-class';
+        scope: 'ready-window' | string;
+        tieBreakers: string[];
+    };
+    concurrency: {
+        preservesLaneLimits: boolean;
+        preservesConcurrencyKeyLimits: boolean;
+        preservesComputeLimits: boolean;
+        preservesResourceQuotas: boolean;
+    };
+}
+export interface FrontierSwarmPriorityDecision {
+    policyId: string;
+    className: FrontierSwarmPriorityClass;
+    rank: number;
+    basePriority: number;
+    effectivePriority: number;
+    reasons: string[];
+}
+export declare const FRONTIER_SWARM_REVIEW_PRIORITY_POLICY: FrontierSwarmPriorityPolicy;
+export interface FrontierSwarmSelectionPriorityInput {
+    statuses?: Record<string, number>;
+    workKinds?: Record<string, number>;
+    defaultStatusRank?: number;
+    defaultWorkKindRank?: number;
+    statusWeight?: number;
+    workKindWeight?: number;
+}
+export interface FrontierSwarmTaskSelectionInput extends FrontierSwarmPlanFilter {
+    workKinds?: readonly string[];
+    spreadLanes?: boolean;
+    includeOwnershipWarnings?: boolean;
+    assignSelectionPriority?: boolean;
+    priority?: FrontierSwarmSelectionPriorityInput;
+}
+export interface FrontierSwarmTaskSelectionEntry {
+    task: FrontierSwarmTask;
+    lane?: FrontierSwarmLane;
+    ownershipWarnings: string[];
+    selectionPriority: number;
+}
+export interface FrontierSwarmTaskSelectionSummary {
+    total: number;
+    byLane: Record<string, number>;
+    byWorkKind: Record<string, number>;
+    ownershipWarningCount: number;
+}
+export interface FrontierSwarmTaskSelection {
+    tasks: FrontierSwarmTask[];
+    entries: FrontierSwarmTaskSelectionEntry[];
+    summary: FrontierSwarmTaskSelectionSummary;
+}
+export interface FrontierSwarmModelTokenEstimateInput {
+    inputTokens?: number;
+    cachedInputTokens?: number;
+    outputTokens?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmModelTokenEstimate {
+    inputTokens: number;
+    cachedInputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmModelPriceInput {
+    id?: string;
+    compute?: string;
+    model?: string;
+    inputUsdPerUnit?: number;
+    cachedInputUsdPerUnit?: number;
+    outputUsdPerUnit?: number;
+    unitTokens?: number;
+    latencyMs?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmModelPrice {
+    id: string;
+    compute?: string;
+    model?: string;
+    inputUsdPerUnit: number;
+    cachedInputUsdPerUnit: number;
+    outputUsdPerUnit: number;
+    unitTokens: number;
+    latencyMs?: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmModelOutcomeInput {
+    compute?: string;
+    model?: string;
+    attempts?: number;
+    successRate?: number;
+    failureRate?: number;
+    confidence?: number;
+    averageCostUsd?: number;
+    averageDurationMs?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmPanelRouteInput {
+    enabled?: boolean;
+    strategy?: FrontierSwarmPanelStrategy;
+    memberComputeIds?: readonly string[];
+    minMembers?: number;
+    maxMembers?: number;
+    fuserComputeId?: string;
+    fuserTokenEstimate?: FrontierSwarmModelTokenEstimateInput;
+    confidenceLift?: number;
+    minRiskScore?: number;
+    maxCostUsd?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmTaskModelProfile {
+    workKind: string;
+    modelTier: FrontierSwarmTaskModelTier;
+    costBand: FrontierSwarmTaskModelCostBand;
+    model?: string;
+    context: string;
+    strengths: string[];
+    failureModes: string[];
+    notes?: string[];
+}
+export interface FrontierSwarmModelRouterInput {
+    id?: string;
+    manifest?: FrontierSwarmManifest | FrontierSwarmManifestInput;
+    task: FrontierSwarmTask | FrontierSwarmTaskInput;
+    candidates?: readonly (string | FrontierSwarmComputeInput | FrontierSwarmCompute)[];
+    routingPolicy?: FrontierSwarmModelRoutingPolicyInput | FrontierSwarmModelRoutingPolicy | unknown;
+    routingMode?: FrontierSwarmModelRoutingMode;
+    priceCatalog?: Record<string, FrontierSwarmModelPriceInput> | readonly FrontierSwarmModelPriceInput[];
+    tokenEstimate?: FrontierSwarmModelTokenEstimateInput;
+    budget?: FrontierSwarmBudget | FrontierSwarmBudgetInput;
+    timePressure?: FrontierSwarmTimePressure | number;
+    outcomeHistory?: readonly FrontierSwarmModelOutcomeInput[];
+    requiredCapabilities?: readonly string[];
+    panel?: FrontierSwarmPanelRouteInput;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmModelRouteCandidate {
+    compute: FrontierSwarmCompute;
+    capable: boolean;
+    missingCapabilities: string[];
+    estimatedCostUsd: number;
+    estimatedLatencyMs: number;
+    priceKnown: boolean;
+    outcomeKnown: boolean;
+    budgetOk: boolean;
+    qualityScore: number;
+    costScore: number;
+    latencyScore: number;
+    historyScore: number;
+    riskFitScore: number;
+    score: number;
+    reasons: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmPanelEvaluationInput {
+    id?: string;
+    candidates?: readonly FrontierSwarmModelRouteCandidate[];
+    task?: FrontierSwarmTask | FrontierSwarmTaskInput;
+    budget?: FrontierSwarmBudget | FrontierSwarmBudgetInput;
+    panel?: FrontierSwarmPanelRouteInput;
+    riskScore?: number;
+    uncertaintyScore?: number;
+    impactScore?: number;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmPanelEvaluation {
+    kind: typeof FRONTIER_SWARM_PANEL_EVALUATION_KIND;
+    version: typeof FRONTIER_SWARM_PANEL_EVALUATION_VERSION;
+    id: string;
+    generatedAt: number;
+    strategy: FrontierSwarmPanelStrategy;
+    memberComputeIds: string[];
+    fuserComputeId?: string;
+    expectedCostUsd: number;
+    expectedLatencyMs: number;
+    confidenceLift: number;
+    confidenceScore: number;
+    residualRiskScore: number;
+    budgetOk: boolean;
+    recommended: boolean;
+    reasons: string[];
+    summary: {
+        memberCount: number;
+        costUsd: number;
+        latencyMs: number;
+        confidenceLift: number;
+        residualRiskScore: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmModelRoute {
+    kind: typeof FRONTIER_SWARM_MODEL_ROUTE_KIND;
+    version: typeof FRONTIER_SWARM_MODEL_ROUTE_VERSION;
+    id: string;
+    generatedAt: number;
+    taskId: string;
+    taskProfile?: FrontierSwarmTaskModelProfile;
+    route: FrontierSwarmModelRouteStrategy;
+    recommendedComputeIds: string[];
+    fuserComputeId?: string;
+    recommended: FrontierSwarmModelRouteCandidate;
+    candidates: FrontierSwarmModelRouteCandidate[];
+    panel?: FrontierSwarmPanelEvaluation;
+    tokenEstimate: FrontierSwarmModelTokenEstimate;
+    riskScore: number;
+    uncertaintyScore: number;
+    impactScore: number;
+    timePressureScore: number;
+    reasons: string[];
+    explanation: string;
+    summary: {
+        candidateCount: number;
+        capableCount: number;
+        priceKnownCount: number;
+        outcomeKnownCount: number;
+        cheapestCapableComputeId?: string;
+        recommendedCostUsd: number;
+        recommendedLatencyMs: number;
+        routingPolicyFeedbackCount: number;
+        routingPolicyOutcomeCount: number;
+        routingPolicyCostSignalCount: number;
+        routingPolicyPreferenceCount: number;
+        panelCostUsd?: number;
+        panelLatencyMs?: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmOptimizationSummaryCounts {
+    modelRouteDecisionCount: number;
+    panelDecisionCount: number;
+    fusionDecisionCount: number;
+    tournamentObservationCount: number;
+    routingFeedbackCount: number;
+    modelDiversityCount: number;
+    feedbackConsumed: boolean;
+}
+export interface FrontierSwarmOptimizationSummaryInput {
+    id?: string;
+    telemetryAvailable?: boolean;
+    modelRouteDecisionCount?: number;
+    panelDecisionCount?: number;
+    fusionDecisionCount?: number;
+    tournamentObservationCount?: number;
+    routingFeedbackCount?: number;
+    modelDiversityCount?: number;
+    feedbackConsumed?: boolean;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmOptimizationSummary {
+    kind: typeof FRONTIER_SWARM_OPTIMIZATION_SUMMARY_KIND;
+    version: typeof FRONTIER_SWARM_OPTIMIZATION_SUMMARY_VERSION;
+    id: string;
+    generatedAt: number;
+    telemetryAvailable: boolean;
+    summary?: FrontierSwarmOptimizationSummaryCounts;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmPlanInput extends FrontierSwarmPlanFilter {
+    id?: string;
+    runId?: string;
+    now?: number;
+    maxReadyJobs?: number;
+    maxLaneConcurrency?: Record<string, number>;
+    maxConcurrencyKeyConcurrency?: Record<string, number>;
+    maxComputeConcurrency?: Record<string, number>;
+    resourceQuotas?: Record<string, number>;
+    routingMode?: FrontierSwarmModelRoutingMode;
+    routingPolicy?: FrontierSwarmModelRoutingPolicyInput | FrontierSwarmModelRoutingPolicy | unknown;
+    routingContext?: unknown;
+    metadata?: unknown;
+}
+export interface FrontierSwarmPlan {
+    kind: typeof FRONTIER_SWARM_PLAN_KIND;
+    version: typeof FRONTIER_SWARM_PLAN_VERSION;
+    id: string;
+    runId: string;
+    manifestId: string;
+    createdAt: number;
+    filters: FrontierSwarmPlanFilter;
+    limits: FrontierSwarmScheduleLimits;
+    routingMode?: FrontierSwarmModelRoutingMode;
+    routingPolicy?: FrontierSwarmModelRoutingPolicy;
+    routingContext?: JsonValue;
+    validation: FrontierSwarmValidation;
+    jobs: FrontierSwarmJob[];
+    graph: FrontierSwarmJobGraph;
+    summary: FrontierSwarmSummary;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmScheduleLimits {
+    maxReadyJobs?: number;
+    maxLaneConcurrency: Record<string, number>;
+    maxConcurrencyKeyConcurrency: Record<string, number>;
+    maxComputeConcurrency: Record<string, number>;
+    resourceQuotas: Record<string, number>;
+}
+export interface FrontierSwarmJob {
+    id: string;
+    taskId: string;
+    title: string;
+    lane: string;
+    layer?: string;
+    compute: FrontierSwarmCompute;
+    status: FrontierSwarmJobStatus;
+    priority: number;
+    task: FrontierSwarmTask;
+    allowedWrites: string[];
+    sharedReadOnly: string[];
+    neverEdit: string[];
+    ownershipRegions: FrontierSwarmOwnershipRegion[];
+    ownedRegions: string[];
+    changedRegions: string[];
+    capabilities: string[];
+    resourceRequirements?: FrontierSwarmResourceRequirements;
+    worktreePath?: string;
+    evidencePrefix?: string;
+    concurrencyKey: string;
+    ownershipWarnings: string[];
+    verification: FrontierSwarmCommand[];
+    acceptance: string[];
+    dependsOn: string[];
+    budget?: FrontierSwarmBudget;
+    review: FrontierSwarmReviewPolicy;
+    tags: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmBudgetInput {
+    maxCostUsd?: number;
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+    maxDurationMs?: number;
+    maxRetries?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmBudget {
+    maxCostUsd?: number;
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+    maxDurationMs?: number;
+    maxRetries: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmUsageInput {
+    costUsd?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    durationMs?: number;
+    attempts?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmUsage {
+    costUsd: number;
+    inputTokens: number;
+    outputTokens: number;
+    durationMs: number;
+    attempts: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmBudgetDecision {
+    ok: boolean;
+    jobId: string;
+    usage: FrontierSwarmUsage;
+    budget?: FrontierSwarmBudget;
+    violations: string[];
+}
+export interface FrontierSwarmReviewPolicyInput {
+    requiredReviewers?: number;
+    sampleRate?: number;
+    alwaysReview?: boolean;
+    reviewerPool?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmReviewPolicy {
+    requiredReviewers: number;
+    sampleRate: number;
+    alwaysReview: boolean;
+    reviewerPool: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmJobGraph {
+    nodes: string[];
+    edges: FrontierSwarmJobGraphEdge[];
+    dependentsByJobId: Record<string, string[]>;
+    dependenciesByJobId: Record<string, string[]>;
+    roots: string[];
+    leaves: string[];
+    issues: FrontierSwarmValidationIssue[];
+}
+export interface FrontierSwarmJobGraphEdge {
+    from: string;
+    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;
+    now?: number;
+    maxReadyJobs?: number;
+    maxLaneConcurrency?: Record<string, number>;
+    maxConcurrencyKeyConcurrency?: Record<string, number>;
+    maxComputeConcurrency?: Record<string, number>;
+    resourceQuotas?: Record<string, number>;
+}
+export interface FrontierSwarmReviewPlanInput {
+    plan: FrontierSwarmPlan;
+    run?: FrontierSwarmRun;
+    budgetDecisions?: readonly FrontierSwarmBudgetDecision[];
+    reviewers?: readonly string[];
+    generatedAt?: number;
+    sampleSalt?: string;
+}
+export interface FrontierSwarmMergePlanInput {
+    plan: FrontierSwarmPlan;
+    run: FrontierSwarmRun;
+    reviewPlan?: FrontierSwarmReviewPlan;
+    generatedAt?: number;
+}
+export interface FrontierSwarmSchedule {
+    kind: typeof FRONTIER_SWARM_SCHEDULE_KIND;
+    version: typeof FRONTIER_SWARM_SCHEDULE_VERSION;
+    id: string;
+    planId: string;
+    runId?: string;
+    createdAt: number;
+    ready: FrontierSwarmScheduledJob[];
+    blocked: FrontierSwarmBlockedJob[];
+    running: FrontierSwarmRunningJob[];
+    completed: string[];
+    failed: string[];
+    summary: FrontierSwarmScheduleSummary;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmScheduledJob {
+    jobId: string;
+    taskId: string;
+    lane: string;
+    compute: string;
+    concurrencyKey: string;
+    priority: number;
+    dependsOn: string[];
+    capabilities: string[];
+    resourceRequirements?: FrontierSwarmResourceRequirements;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmBlockedJob extends FrontierSwarmScheduledJob {
+    reasons: string[];
+    waitingFor: string[];
+}
+export interface FrontierSwarmRunningJob {
+    jobId: string;
+    lane: string;
+    compute: string;
+    concurrencyKey: string;
+    capabilities: string[];
+    resourceRequirements?: FrontierSwarmResourceRequirements;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmScheduleSummary {
+    jobCount: number;
+    readyCount: number;
+    blockedCount: number;
+    runningCount: number;
+    completedCount: number;
+    failedCount: number;
+}
+export interface FrontierSwarmLeaseInput {
+    schedule: FrontierSwarmSchedule;
+    workerId: string;
+    now?: number;
+    leaseMs?: number;
+    count?: number;
+    existingLeases?: readonly FrontierSwarmLease[];
+}
+export interface FrontierSwarmLease {
+    kind: typeof FRONTIER_SWARM_LEASE_KIND;
+    version: typeof FRONTIER_SWARM_LEASE_VERSION;
+    id: string;
+    jobId: string;
+    workerId: string;
+    token: string;
+    leasedAt: number;
+    expiresAt: number;
+    fencingToken: number;
+    status: 'active' | 'expired' | 'released';
+}
+export type FrontierSwarmQueueJobStatus = 'ready' | 'leased' | 'running' | 'completed' | 'failed' | 'blocked' | 'retrying' | 'dead-letter' | string;
+export interface FrontierSwarmQueueJobInput {
+    jobId: string;
+    taskId?: string;
+    runId?: string;
+    status?: FrontierSwarmQueueJobStatus;
+    lane?: string;
+    compute?: string;
+    concurrencyKey?: string;
+    priority?: number;
+    attempts?: number;
+    maxAttempts?: number;
+    availableAt?: number;
+    lease?: FrontierSwarmLease;
+    lastError?: string;
+    metadata?: unknown;
+}
+export interface FrontierSwarmQueueJob {
+    jobId: string;
+    taskId?: string;
+    runId?: string;
+    status: FrontierSwarmQueueJobStatus;
+    lane?: string;
+    compute?: string;
+    concurrencyKey?: string;
+    priority: number;
+    attempts: number;
+    maxAttempts: number;
+    availableAt?: number;
+    lease?: FrontierSwarmLease;
+    lastError?: string;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmQueueSnapshotInput {
+    id?: string;
+    plan: FrontierSwarmPlan;
+    run?: FrontierSwarmRun;
+    jobs?: readonly FrontierSwarmQueueJobInput[];
+    leases?: readonly FrontierSwarmLease[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmQueueSnapshot {
+    kind: typeof FRONTIER_SWARM_QUEUE_SNAPSHOT_KIND;
+    version: typeof FRONTIER_SWARM_QUEUE_SNAPSHOT_VERSION;
+    id: string;
+    planId: string;
+    runId: string;
+    generatedAt: number;
+    jobs: FrontierSwarmQueueJob[];
+    byStatus: Record<string, string[]>;
+    byLane: Record<string, string[]>;
+    leases: FrontierSwarmLease[];
+    metadata?: JsonObject;
+    summary: {
+        jobCount: number;
+        leaseCount: number;
+        readyCount: number;
+        leasedCount: number;
+        completedCount: number;
+        failedCount: number;
+        deadLetterCount: number;
+    };
+}
+export interface FrontierSwarmLeaseRenewalInput {
+    lease: FrontierSwarmLease;
+    now?: number;
+    leaseMs?: number;
+    status?: FrontierSwarmLease['status'];
+}
+export interface FrontierSwarmQueueAdapter {
+    snapshot(): FrontierSwarmQueueSnapshot | Promise<FrontierSwarmQueueSnapshot>;
+    enqueue?(snapshot: FrontierSwarmQueueSnapshot): FrontierSwarmQueueSnapshot | Promise<FrontierSwarmQueueSnapshot>;
+    lease?(input: FrontierSwarmLeaseInput): readonly FrontierSwarmLease[] | Promise<readonly FrontierSwarmLease[]>;
+    renew?(input: FrontierSwarmLeaseRenewalInput): FrontierSwarmLease | Promise<FrontierSwarmLease>;
+    complete?(result: FrontierSwarmJobResultInput): FrontierSwarmQueueSnapshot | Promise<FrontierSwarmQueueSnapshot>;
+}
+export interface FrontierSwarmRunCheckpointInput {
+    run: FrontierSwarmRun;
+    sequence?: number;
+    savedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmRunCheckpoint {
+    kind: typeof FRONTIER_SWARM_RUN_CHECKPOINT_KIND;
+    version: typeof FRONTIER_SWARM_RUN_CHECKPOINT_VERSION;
+    id: string;
+    runId: string;
+    planId: string;
+    sequence: number;
+    savedAt: number;
+    status: FrontierSwarmJobStatus;
+    eventCount: number;
+    resultCount: number;
+    hash: string;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmRunStoreAdapter {
+    loadRun(runId: string): FrontierSwarmRun | undefined | Promise<FrontierSwarmRun | undefined>;
+    saveRun(run: FrontierSwarmRun, checkpoint?: FrontierSwarmRunCheckpoint): void | Promise<void>;
+    appendEvents?(runId: string, events: readonly FrontierSwarmEventInput[]): void | Promise<void>;
+    appendResults?(runId: string, results: readonly FrontierSwarmJobResultInput[]): void | Promise<void>;
+    checkpoint?(run: FrontierSwarmRun): FrontierSwarmRunCheckpoint | Promise<FrontierSwarmRunCheckpoint>;
+}
+export interface FrontierSwarmArtifactInput {
+    jobId: string;
+    path: string;
+    kind?: string;
+    bytes?: number;
+    hash?: string;
+    producedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmArtifact {
+    jobId: string;
+    path: string;
+    kind: string;
+    bytes?: number;
+    hash?: string;
+    producedAt?: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmArtifactIndex {
+    kind: typeof FRONTIER_SWARM_ARTIFACT_INDEX_KIND;
+    version: typeof FRONTIER_SWARM_ARTIFACT_INDEX_VERSION;
+    id: string;
+    generatedAt: number;
+    artifacts: FrontierSwarmArtifact[];
+    byJobId: Record<string, FrontierSwarmArtifact[]>;
+    byKind: Record<string, FrontierSwarmArtifact[]>;
+    summary: {
+        artifactCount: number;
+        jobCount: number;
+        kindCount: number;
+        totalBytes: number;
+    };
+}
+export interface FrontierSwarmReviewPlan {
+    kind: typeof FRONTIER_SWARM_REVIEW_PLAN_KIND;
+    version: typeof FRONTIER_SWARM_REVIEW_PLAN_VERSION;
+    id: string;
+    planId: string;
+    generatedAt: number;
+    assignments: FrontierSwarmReviewAssignment[];
+    summary: {
+        assignmentCount: number;
+        requiredCount: number;
+        sampledCount: number;
+    };
+}
+export interface FrontierSwarmReviewAssignment {
+    jobId: string;
+    taskId: string;
+    reviewers: string[];
+    required: boolean;
+    reason: 'always-review' | 'sampled' | 'violations' | 'failed' | 'budget';
+}
+export interface FrontierSwarmMergePlan {
+    kind: typeof FRONTIER_SWARM_MERGE_PLAN_KIND;
+    version: typeof FRONTIER_SWARM_MERGE_PLAN_VERSION;
+    id: string;
+    planId: string;
+    generatedAt: number;
+    ready: string[];
+    blocked: FrontierSwarmMergeBlocker[];
+    groups: FrontierSwarmMergeGroup[];
+    summary: {
+        readyCount: number;
+        blockedCount: number;
+        groupCount: number;
+    };
+}
+export interface FrontierSwarmMergeBlocker {
+    jobId: string;
+    reasons: string[];
+    conflictingJobIds: string[];
+}
+export interface FrontierSwarmMergeGroup {
+    id: string;
+    jobIds: string[];
+    changedPaths: string[];
+}
+export interface FrontierSwarmDecomposeInput {
+    featureId: string;
+    objective: string;
+    lanes: readonly string[];
+    files?: readonly string[];
+    checks?: readonly (string | FrontierSwarmCommandInput)[];
+    reviewers?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmRunInput {
+    id?: string;
+    plan: FrontierSwarmPlan;
+    startedAt?: number;
+    status?: FrontierSwarmJobStatus;
+    events?: readonly FrontierSwarmEventInput[];
+    results?: readonly FrontierSwarmJobResultInput[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmRun {
+    kind: typeof FRONTIER_SWARM_RUN_KIND;
+    version: typeof FRONTIER_SWARM_RUN_VERSION;
+    id: string;
+    planId: string;
+    manifestId: string;
+    startedAt: number;
+    finishedAt?: number;
+    status: FrontierSwarmJobStatus;
+    jobs: FrontierSwarmJob[];
+    events: FrontierSwarmEvent[];
+    results: FrontierSwarmJobResult[];
+    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;
+    runId?: string;
+    jobId?: string;
+    taskId?: string;
+    lane?: string;
+    layer?: string;
+    compute?: string;
+    at?: number;
+    message?: string;
+    data?: unknown;
+    metadata?: unknown;
+}
+export interface FrontierSwarmEvent {
+    kind: typeof FRONTIER_SWARM_EVENT_KIND;
+    version: typeof FRONTIER_SWARM_EVENT_VERSION;
+    id: string;
+    type: string;
+    runId?: string;
+    jobId?: string;
+    taskId?: string;
+    lane?: string;
+    layer?: string;
+    compute?: string;
+    at: number;
+    message?: string;
+    data?: JsonValue;
+    metadata?: JsonObject;
+}
+export type FrontierSwarmMailboxScope = 'global' | 'lane' | 'job' | string;
+export interface FrontierSwarmMailboxInput {
+    id?: string;
+    runId?: string;
+    scope?: FrontierSwarmMailboxScope;
+    lane?: string;
+    jobId?: string;
+    path?: string;
+    eventTypes?: readonly string[];
+    appendOnly?: boolean;
+    metadata?: unknown;
+}
+export interface FrontierSwarmMailbox {
+    kind: typeof FRONTIER_SWARM_MAILBOX_KIND;
+    version: typeof FRONTIER_SWARM_MAILBOX_VERSION;
+    id: string;
+    runId?: string;
+    scope: FrontierSwarmMailboxScope;
+    lane?: string;
+    jobId?: string;
+    path?: string;
+    eventTypes: string[];
+    appendOnly: boolean;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmEventStreamInput {
+    id?: string;
+    runId?: string;
+    root?: string;
+    lanes?: readonly (string | FrontierSwarmLaneInput | FrontierSwarmLane)[];
+    eventTypes?: readonly string[];
+    appendOnly?: boolean;
+    metadata?: unknown;
+}
+export interface FrontierSwarmEventStream {
+    kind: typeof FRONTIER_SWARM_EVENT_STREAM_KIND;
+    version: typeof FRONTIER_SWARM_EVENT_STREAM_VERSION;
+    id: string;
+    runId?: string;
+    root?: string;
+    appendOnly: boolean;
+    global: FrontierSwarmMailbox;
+    lanes: Record<string, FrontierSwarmMailbox>;
+    eventTypes: string[];
+    metadata?: JsonObject;
+    summary: {
+        mailboxCount: number;
+        laneCount: number;
+        eventTypeCount: number;
+    };
+}
+export interface FrontierSwarmJobResultInput {
+    jobId: string;
+    status?: FrontierSwarmJobStatus;
+    mergeReadiness?: FrontierSwarmMergeReadiness;
+    startedAt?: number;
+    finishedAt?: number;
+    exitCode?: number;
+    signal?: string;
+    changedPaths?: readonly string[];
+    changedRegions?: readonly string[];
+    ownershipViolations?: readonly string[];
+    evidencePaths?: readonly string[];
+    patchPath?: string;
+    queueItemIds?: readonly string[];
+    riskLevel?: FrontierSwarmRiskLevel;
+    mergeDisposition?: FrontierSwarmMergeDisposition;
+    verification?: readonly FrontierSwarmVerificationResultInput[];
+    semanticImport?: FrontierSwarmSemanticImportSummary;
+    traceShards?: readonly JsonValue[];
+    lastMessage?: string;
+    error?: unknown;
+    metadata?: unknown;
+}
+export interface FrontierSwarmVerificationResultInput {
+    name?: string;
+    command?: readonly string[];
+    commandLine?: string;
+    cwd?: string;
+    status?: number;
+    durationMs?: number;
+    stdoutTail?: readonly string[];
+    stderrTail?: readonly string[];
+    required?: boolean;
+    category?: FrontierSwarmVerificationCategory;
+    metadata?: unknown;
+}
+export interface FrontierSwarmVerificationResult {
+    name: string;
+    command: string[];
+    commandLine?: string;
+    cwd?: string;
+    status?: number;
+    durationMs?: number;
+    stdoutTail: string[];
+    stderrTail: string[];
+    required: boolean;
+    category?: FrontierSwarmVerificationCategory;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmSemanticImportSummary {
+    total: number;
+    candidates?: number;
+    selected: number;
+    eligible?: number;
+    imported: number;
+    errors: number;
+    selection?: unknown;
+    omitted?: unknown;
+    maxFiles?: number;
+    skipped?: unknown;
+    sourceMapMappingCount: number;
+    readiness?: Record<string, unknown>;
+    lossesBySeverity?: Record<string, unknown>;
+    semanticIndex?: {
+        symbols?: number;
+        [key: string]: unknown;
+    };
+    semanticSidecars?: {
+        ownershipRegions?: number;
+        patchHints?: number;
+        [key: string]: unknown;
+    };
+    semanticChanges?: readonly FrontierSwarmSemanticChange[];
+    mergeCandidates?: readonly FrontierSwarmMergeCandidate[];
+    dependencies?: unknown;
+    semanticEditScripts?: unknown;
+    semanticEditProjection?: unknown;
+    semanticEditReplay?: unknown;
+    [key: string]: unknown;
+}
+export interface FrontierSwarmJobResult {
+    jobId: string;
+    status: FrontierSwarmJobStatus;
+    mergeReadiness: FrontierSwarmMergeReadiness;
+    startedAt?: number;
+    finishedAt?: number;
+    durationMs?: number;
+    exitCode?: number;
+    signal?: string;
+    changedPaths: string[];
+    changedRegions: string[];
+    ownershipViolations: string[];
+    evidencePaths: string[];
+    patchPath?: string;
+    queueItemIds: string[];
+    riskLevel: FrontierSwarmRiskLevel;
+    mergeDisposition: FrontierSwarmMergeDisposition;
+    verification: FrontierSwarmVerificationResult[];
+    semanticImport?: FrontierSwarmSemanticImportSummary;
+    traceShards?: JsonValue[];
+    lastMessage?: string;
+    error?: string;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmOwnershipReport {
+    ok: boolean;
+    changedPaths: string[];
+    allowedWrites: string[];
+    violations: string[];
+}
+export interface FrontierSwarmMergeBundleInput {
+    id?: string;
+    runId?: string;
+    planId?: string;
+    job?: FrontierSwarmJob;
+    result: FrontierSwarmJobResult | FrontierSwarmJobResultInput;
+    patchPath?: string;
+    patchHash?: string;
+    evidencePaths?: readonly string[];
+    queueItemIds?: readonly string[];
+    riskLevel?: FrontierSwarmRiskLevel;
+    disposition?: FrontierSwarmMergeDisposition;
+    staleAgainstHead?: boolean;
+    branchName?: string;
+    commit?: string;
+    semanticImport?: FrontierSwarmSemanticImportSummary;
+    traceShards?: readonly JsonValue[];
+    metadata?: unknown;
+    generatedAt?: number;
+}
+export interface FrontierSwarmMergeBundle {
+    kind: typeof FRONTIER_SWARM_MERGE_BUNDLE_KIND;
+    version: typeof FRONTIER_SWARM_MERGE_BUNDLE_VERSION;
+    id: string;
+    runId?: string;
+    planId?: string;
+    jobId: string;
+    taskId?: string;
+    lane?: string;
+    title?: string;
+    generatedAt: number;
+    status: FrontierSwarmJobStatus;
+    mergeReadiness: FrontierSwarmMergeReadiness;
+    disposition: FrontierSwarmMergeDisposition;
+    riskLevel: FrontierSwarmRiskLevel;
+    autoMergeable: boolean;
+    changedPaths: string[];
+    changedRegions: string[];
+    ownedFilesTouched: string[];
+    allowedWrites: string[];
+    ownershipViolations: string[];
+    patchPath?: string;
+    patchHash?: string;
+    evidencePaths: string[];
+    commandsPassed: FrontierSwarmVerificationResult[];
+    commandsFailed: FrontierSwarmVerificationResult[];
+    queueItemIds: string[];
+    semanticImport?: FrontierSwarmSemanticImportSummary;
+    traceShards?: JsonValue[];
+    branchName?: string;
+    commit?: string;
+    staleAgainstHead: boolean;
+    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;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmMergeConflict {
+    jobIds: string[];
+    key: string;
+    kind: 'path' | 'region' | 'symbol' | 'public-contract';
+    path?: string;
+    region?: string;
+    symbol?: string;
+    publicContract?: 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 type FrontierSwarmMergeQueueScopeKind = 'root' | 'parent' | 'child' | 'lane' | 'semantic-region' | 'path' | 'custom' | string;
+export type FrontierSwarmMergeQueueAssignmentAction = 'apply-local' | 'queue-local' | 'promote' | 'rerun' | 'reject' | 'record-only' | 'block' | string;
+export interface FrontierSwarmMergeAdmissionPressure {
+    applyLocalCount: number;
+    applyLocalQueueItemCount: number;
+    queueLocalCount: number;
+    queueLocalQueueItemCount: number;
+    promoteUpwardCount: number;
+    promoteUpwardQueueItemCount: number;
+    rerunCount: number;
+    rerunQueueItemCount: number;
+    rejectedCount: number;
+    rejectedQueueItemCount: number;
+    recordOnlyCount: number;
+    recordOnlyQueueItemCount: number;
+    trueBlockCount: number;
+    trueBlockQueueItemCount: number;
+}
+export interface FrontierSwarmMergeQueueScopeInput {
+    id: string;
+    kind?: FrontierSwarmMergeQueueScopeKind;
+    parentId?: string;
+    title?: string;
+    lane?: string;
+    changedPaths?: readonly string[];
+    changedRegions?: readonly string[];
+    leaseKey?: string;
+    metadata?: unknown;
+}
+export interface FrontierSwarmMergeQueueScope {
+    id: string;
+    kind: FrontierSwarmMergeQueueScopeKind;
+    parentId?: string;
+    title: string;
+    lane?: string;
+    changedPaths: string[];
+    changedRegions: string[];
+    leaseKey: string;
+    jobIds: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmMergeQueueRetrySlice {
+    id: string;
+    scopeId: string;
+    kind: FrontierSwarmMergeQueueScopeKind;
+    parentScopeIds: string[];
+    leaseKey: string;
+    requiredLeaseScopeIds?: string[];
+    requiredLeaseKeys?: string[];
+    lane?: string;
+    changedPaths: string[];
+    changedRegions: string[];
+    reasons: string[];
+}
+export type FrontierSwarmHierarchicalQueueLeaseScopeClass = 'root' | 'parent' | 'child' | 'lane' | 'semantic' | 'path' | 'custom' | string;
+export type FrontierSwarmHierarchicalQueueLeasePromotionState = 'local' | 'terminal' | 'promoted-to-parent' | 'receiving-promoted' | string;
+export interface FrontierSwarmHierarchicalQueueLocalLeaderInput {
+    id?: string;
+    coordinatorId?: string;
+    workerId?: string;
+    role?: string;
+    electedAt?: number;
+    leaseId?: string;
+    leaseKey?: string;
+    metadata?: unknown;
+}
+export interface FrontierSwarmHierarchicalQueueLocalLeader {
+    id: string;
+    coordinatorId?: string;
+    workerId?: string;
+    role?: string;
+    electedAt?: number;
+    leaseId?: string;
+    leaseKey?: string;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmHierarchicalQueuePromotionState {
+    state: FrontierSwarmHierarchicalQueueLeasePromotionState;
+    parentQueueId?: string;
+    promotionIds: string[];
+    promotedFromQueueIds: string[];
+    promotedToQueueIds: string[];
+    promotedJobIds: string[];
+    promotedQueueItemIds: string[];
+}
+export interface FrontierSwarmHierarchicalQueueTerminalDecisionLink {
+    id: string;
+    jobId: string;
+    taskId?: string;
+    queueId: string;
+    queueItemIds: string[];
+    action: FrontierSwarmMergeQueueAssignmentAction;
+    decision: FrontierSwarmCoordinatorAgentDrainDecision;
+    reasons: string[];
+}
+export interface FrontierSwarmHierarchicalQueueLeaseRecord {
+    id: string;
+    queueId: string;
+    scopeId: string;
+    scopeKind: FrontierSwarmMergeQueueScopeKind;
+    scopeClass: FrontierSwarmHierarchicalQueueLeaseScopeClass;
+    rootQueueId: string;
+    parentQueueId?: string;
+    lane?: string;
+    title: string;
+    leaseKey: string;
+    localLeader?: FrontierSwarmHierarchicalQueueLocalLeader;
+    promotion: FrontierSwarmHierarchicalQueuePromotionState;
+    conflictReasons: string[];
+    retryReasons: string[];
+    reasons: string[];
+    jobIds: string[];
+    queueItemIds: string[];
+    activeJobIds: string[];
+    activeQueueItemIds: string[];
+    terminalJobIds: string[];
+    terminalQueueItemIds: string[];
+    terminalDecisionIds: string[];
+    terminalDecisionLinks: FrontierSwarmHierarchicalQueueTerminalDecisionLink[];
+    changedPaths: string[];
+    changedRegions: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmHierarchicalQueueScopeTree {
+    rootScopeId: string;
+    scopeIdsByKind: Record<string, string[]>;
+    ancestorScopeIdsByScopeId: Record<string, string[]>;
+    childScopeIdsByScopeId: Record<string, string[]>;
+    leafScopeIds: string[];
+}
+export interface FrontierSwarmHierarchicalMergeQueueInput {
+    id?: string;
+    index: FrontierSwarmMergeIndex;
+    admission?: FrontierSwarmMergeAdmission;
+    rootScopeId?: string;
+    scopes?: readonly FrontierSwarmMergeQueueScopeInput[];
+    localLeader?: FrontierSwarmHierarchicalQueueLocalLeaderInput;
+    localLeaders?: Readonly<Record<string, FrontierSwarmHierarchicalQueueLocalLeaderInput | undefined>>;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmHierarchicalMergeQueue {
+    kind: typeof FRONTIER_SWARM_HIERARCHICAL_MERGE_QUEUE_KIND;
+    version: typeof FRONTIER_SWARM_HIERARCHICAL_MERGE_QUEUE_VERSION;
+    id: string;
+    mergeIndexId: string;
+    admissionId?: string;
+    generatedAt: number;
+    rootScopeId: string;
+    scopeTree: FrontierSwarmHierarchicalQueueScopeTree;
+    scopes: FrontierSwarmMergeQueueScope[];
+    leaseRecords: FrontierSwarmHierarchicalQueueLeaseRecord[];
+    assignments: FrontierSwarmMergeQueueAssignment[];
+    promotions: FrontierSwarmMergeQueuePromotion[];
+    byScope: Record<string, string[]>;
+    byLeaseKey: Record<string, string[]>;
+    byAction: Record<string, string[]>;
+    summary: {
+        scopeCount: number;
+        assignmentCount: number;
+        applyLocalCount: number;
+        queueLocalCount: number;
+        promoteCount: number;
+        rerunCount: number;
+        rejectCount: number;
+        blockCount: number;
+        recordOnlyCount: number;
+        admissionPressure: FrontierSwarmMergeAdmissionPressure;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmMergeQueueAssignment {
+    jobId: string;
+    taskId?: string;
+    lane?: string;
+    title?: string;
+    queueItemIds: string[];
+    scopeId: string;
+    parentScopeIds: string[];
+    action: FrontierSwarmMergeQueueAssignmentAction;
+    reasons: string[];
+    admitted: boolean;
+    riskLevel: FrontierSwarmRiskLevel;
+    disposition: FrontierSwarmMergeDisposition;
+    mergeReadiness: FrontierSwarmMergeReadiness;
+    changedPaths: string[];
+    changedRegions: string[];
+    conflictingJobIds: string[];
+    leaseKey: string;
+    requiredLeaseScopeIds?: string[];
+    requiredLeaseKeys?: string[];
+    promoteToScopeId?: string;
+    terminalDecisionId?: string;
+    terminalDecisionQueueItemIds?: string[];
+    retrySlices?: FrontierSwarmMergeQueueRetrySlice[];
+    semanticSliceScopeIds?: string[];
+    semanticSliceLeaseKeys?: string[];
+    parentDecisionRegions?: string[];
+    unknownRegions?: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmMergeQueuePromotion {
+    jobId: string;
+    fromScopeId: string;
+    toScopeId: string;
+    reasons: string[];
+}
+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' | '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", "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;
+    status?: string;
+    decision?: string;
+    generatedByCollector?: boolean;
+    evidenceOnly?: boolean;
+    noChange?: boolean;
+    patchMissing?: boolean;
+    bundleMissing?: boolean;
+    conflictBlocked?: boolean;
+    humanQuestion?: boolean;
+    humanBlocked?: boolean;
+    coordinatorReview?: boolean;
+    reasons?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmTerminalOutcome {
+    label: FrontierSwarmTerminalOutcomeLabel;
+    category: FrontierSwarmTerminalOutcomeCategory;
+    terminal: true;
+    success: boolean;
+    incomplete: boolean;
+    blocker: boolean;
+    review: boolean;
+    generatedByCollector: boolean;
+    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;
+    terminal: boolean;
+    closesSubject: boolean;
+    coordinatorReview: boolean;
+    humanBlocked: boolean;
+    staleOrRerun: boolean;
+    conflict: boolean;
+    reviewDebt: boolean;
+}
+export interface FrontierSwarmQueueOutcomeDecisionInput {
+    id?: string;
+    subjectId?: string;
+    subjectAliases?: readonly string[];
+    jobId?: string;
+    taskId?: string;
+    queueItemId?: string;
+    queueItemIds?: readonly string[];
+    queueId?: string;
+    lane?: string;
+    action?: FrontierSwarmMergeQueueAssignmentAction;
+    assignedAction?: FrontierSwarmMergeQueueAssignmentAction;
+    decision?: FrontierSwarmCoordinatorAgentDrainDecision | string;
+    category?: FrontierSwarmQueueOutcomeCategory;
+    outcome?: FrontierSwarmQueueOutcome;
+    terminal?: boolean;
+    reasons?: readonly string[];
+    disposition?: FrontierSwarmMergeDisposition;
+    mergeReadiness?: FrontierSwarmMergeReadiness;
+    status?: string;
+    conflictingJobIds?: readonly string[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmQueueOutcomeDecision {
+    id: string;
+    subjectId: string;
+    subjectAliases: string[];
+    jobId?: string;
+    taskId?: string;
+    queueItemIds: string[];
+    queueId?: string;
+    lane?: string;
+    action?: FrontierSwarmMergeQueueAssignmentAction;
+    assignedAction?: FrontierSwarmMergeQueueAssignmentAction;
+    decision?: FrontierSwarmCoordinatorAgentDrainDecision | string;
+    category: FrontierSwarmQueueOutcomeCategory;
+    outcome: FrontierSwarmQueueOutcome;
+    terminal: boolean;
+    closesSubject: boolean;
+    coordinatorReview: boolean;
+    humanBlocked: boolean;
+    staleOrRerun: boolean;
+    conflict: boolean;
+    reviewDebt: boolean;
+    reasons: string[];
+    disposition?: FrontierSwarmMergeDisposition;
+    mergeReadiness?: FrontierSwarmMergeReadiness;
+    status?: string;
+    conflictingJobIds: string[];
+    generatedAt: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmQueueOutcomeModelInput {
+    id?: string;
+    decisions?: readonly (FrontierSwarmQueueOutcomeDecisionInput | FrontierSwarmQueueOutcomeDecision)[];
+    queue?: FrontierSwarmHierarchicalMergeQueue;
+    drainWork?: FrontierSwarmCoordinatorAgentDrainWork;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmQueueOutcomeSubject {
+    subjectId: string;
+    aliases: string[];
+    latestDecision: FrontierSwarmQueueOutcomeDecision;
+    supersededDecisions: FrontierSwarmQueueOutcomeDecision[];
+}
+export interface FrontierSwarmQueueOutcomeModel {
+    kind: typeof FRONTIER_SWARM_QUEUE_OUTCOME_MODEL_KIND;
+    version: typeof FRONTIER_SWARM_QUEUE_OUTCOME_MODEL_VERSION;
+    id: string;
+    generatedAt: number;
+    decisions: FrontierSwarmQueueOutcomeDecision[];
+    subjects: FrontierSwarmQueueOutcomeSubject[];
+    latestDecisions: FrontierSwarmQueueOutcomeDecision[];
+    supersededDecisions: FrontierSwarmQueueOutcomeDecision[];
+    visibleReviewDebt: FrontierSwarmQueueOutcomeDecision[];
+    visibleHumanBlockers: FrontierSwarmQueueOutcomeDecision[];
+    visibleReruns: FrontierSwarmQueueOutcomeDecision[];
+    visibleConflicts: FrontierSwarmQueueOutcomeDecision[];
+    bySubjectId: Record<string, string>;
+    subjectIdByAlias: Record<string, string>;
+    latestDecisionIdByAlias: Record<string, string>;
+    byCategory: Record<string, string[]>;
+    byOutcome: Record<string, string[]>;
+    summary: {
+        decisionCount: number;
+        subjectCount: number;
+        latestDecisionCount: number;
+        supersededDecisionCount: number;
+        terminalCount: number;
+        continuationCount: number;
+        coordinatorReviewCount: number;
+        humanBlockedCount: number;
+        staleRerunCount: number;
+        conflictCount: number;
+        visibleReviewDebtCount: number;
+        visibleHumanBlockedCount: number;
+        visibleRerunCount: number;
+        visibleConflictCount: number;
+    };
+    metadata?: JsonObject;
+}
+export type FrontierSwarmTerminalStateBucket = 'ready' | 'review' | 'stale' | 'failed' | 'done' | 'terminal' | string;
+export interface FrontierSwarmTerminalStateItemInput {
+    id?: string;
+    subjectId?: string;
+    subjectAliases?: readonly string[];
+    jobId?: string;
+    taskId?: string;
+    queueItemId?: string;
+    queueItemIds?: readonly string[];
+    bucket?: FrontierSwarmTerminalStateBucket;
+    status?: string;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmTerminalStateCollectionInput {
+    bucket: FrontierSwarmTerminalStateBucket;
+    items: readonly (string | FrontierSwarmTerminalStateItemInput)[];
+}
+export type FrontierSwarmTerminalStateCollectionsInput = Record<string, readonly (string | FrontierSwarmTerminalStateItemInput)[]> | readonly FrontierSwarmTerminalStateCollectionInput[];
+export interface FrontierSwarmTerminalStateItem {
+    id: string;
+    subjectId: string;
+    subjectAliases: string[];
+    jobId?: string;
+    taskId?: string;
+    queueItemIds: string[];
+    bucket: FrontierSwarmTerminalStateBucket;
+    status?: string;
+    generatedAt: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmTerminalStateResolution {
+    id: string;
+    subjectId: string;
+    subjectAliases: string[];
+    jobId?: string;
+    taskId?: string;
+    queueItemIds: string[];
+    bucket: FrontierSwarmTerminalStateBucket;
+    sourceItemIds: string[];
+    sourceBuckets: FrontierSwarmTerminalStateBucket[];
+    decisionId: string;
+    decisionCategory: FrontierSwarmQueueOutcomeCategory;
+    decisionOutcome: FrontierSwarmQueueOutcome;
+    decisionTerminal: boolean;
+    decisionGeneratedAt: number;
+    resolved: boolean;
+    terminal: boolean;
+    failedWorkerOutput: false;
+    reasons: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmTerminalStateReconciliationInput {
+    id?: string;
+    collections?: FrontierSwarmTerminalStateCollectionsInput;
+    decisions?: readonly (FrontierSwarmQueueOutcomeDecisionInput | FrontierSwarmQueueOutcomeDecision)[];
+    outcomeModel?: FrontierSwarmQueueOutcomeModel;
+    generatedAt?: number;
+    doneBucket?: FrontierSwarmTerminalStateBucket;
+    terminalBucket?: FrontierSwarmTerminalStateBucket;
+    metadata?: unknown;
+}
+export interface FrontierSwarmTerminalStateReconciliation {
+    kind: typeof FRONTIER_SWARM_TERMINAL_STATE_RECONCILIATION_KIND;
+    version: typeof FRONTIER_SWARM_TERMINAL_STATE_RECONCILIATION_VERSION;
+    id: string;
+    generatedAt: number;
+    outcomeModelId: string;
+    items: FrontierSwarmTerminalStateItem[];
+    active: FrontierSwarmTerminalStateItem[];
+    failedWorkerOutput: FrontierSwarmTerminalStateItem[];
+    resolved: FrontierSwarmTerminalStateResolution[];
+    terminal: FrontierSwarmTerminalStateResolution[];
+    terminalUnresolved: FrontierSwarmTerminalStateResolution[];
+    collapsed: FrontierSwarmTerminalStateResolution[];
+    collections: Record<string, FrontierSwarmTerminalStateItem[]>;
+    byBucket: Record<string, string[]>;
+    latestDecisionIdByAlias: Record<string, string>;
+    summary: {
+        inputItemCount: number;
+        decisionCount: number;
+        latestDecisionCount: number;
+        supersededDecisionCount: number;
+        activeItemCount: number;
+        collapsedItemCount: number;
+        resolvedCount: number;
+        terminalCount: number;
+        terminalUnresolvedCount: number;
+        failedWorkerOutputCount: number;
+        visibleReviewDebtCount: number;
+        visibleHumanBlockedCount: number;
+        visibleRerunCount: number;
+        visibleConflictCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmCoordinatorAgentDrainWorkInput {
+    id?: string;
+    queue: FrontierSwarmHierarchicalMergeQueue;
+    coordinatorId?: string;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmCoordinatorAgentDrainWorkConsumerSummary {
+    leaseCount: number;
+    assignmentCount: number;
+    activeAssignmentCount: number;
+    terminalCount: number;
+    promotedWorkCount: number;
+    blockerCount: number;
+    queueItemCount: number;
+    activeQueueItemCount: number;
+    terminalQueueItemCount: number;
+    promotedQueueItemCount: number;
+    blockerQueueItemCount: number;
+    admissionPressure: FrontierSwarmMergeAdmissionPressure;
+    rootQueueSelectionPressure: FrontierSwarmCoordinatorAgentRootQueueSelectionPressure;
+}
+export interface FrontierSwarmCoordinatorAgentRootQueueSelectionPressure {
+    rootQueueId: string;
+    leaseId?: string;
+    leaseScope?: string;
+    promotedWorkCount: number;
+    promotedQueueItemCount: number;
+    promotedJobIds: string[];
+    promotedQueueItemIds: string[];
+    bySourceQueueId: Record<string, string[]>;
+    byReason: Record<string, string[]>;
+    admissionPressure: FrontierSwarmMergeAdmissionPressure;
+}
+export interface FrontierSwarmCoordinatorAgentDrainWork {
+    kind: typeof FRONTIER_SWARM_COORDINATOR_AGENT_DRAIN_WORK_KIND;
+    version: typeof FRONTIER_SWARM_COORDINATOR_AGENT_DRAIN_WORK_VERSION;
+    id: string;
+    queueId: string;
+    mergeIndexId: string;
+    admissionId?: string;
+    coordinatorId?: string;
+    generatedAt: number;
+    rootQueueId: string;
+    leases: FrontierSwarmCoordinatorAgentDrainLease[];
+    assignments: FrontierSwarmCoordinatorAgentDrainAssignment[];
+    activeAssignments: FrontierSwarmCoordinatorAgentDrainAssignment[];
+    terminalDecisions: FrontierSwarmCoordinatorAgentDrainTerminalDecision[];
+    promotedWork: FrontierSwarmCoordinatorAgentPromotedWork[];
+    blockers: FrontierSwarmCoordinatorAgentDrainTerminalDecision[];
+    byAction: Record<string, string[]>;
+    byDecision: Record<string, string[]>;
+    byClassification: Record<string, string[]>;
+    byQueueId: Record<string, string[]>;
+    byLeaseScope: Record<string, string[]>;
+    summary: {
+        leaseCount: number;
+        assignmentCount: number;
+        activeAssignmentCount?: number;
+        terminalCount: number;
+        nonTerminalCount: number;
+        promotedWorkCount: number;
+        blockerCount?: number;
+        queueItemCount?: number;
+        activeQueueItemCount?: number;
+        terminalQueueItemCount?: number;
+        promotedQueueItemCount?: number;
+        blockerQueueItemCount?: number;
+        appliedCount: number;
+        queuedCount: number;
+        escalatedCount: number;
+        rerunCount: number;
+        rejectedCount: number;
+        recordedCount: number;
+        blockedCount: number;
+        admissionPressure: FrontierSwarmMergeAdmissionPressure;
+        rootQueueSelectionPressure: FrontierSwarmCoordinatorAgentRootQueueSelectionPressure;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmCoordinatorAgentDrainLease {
+    id: string;
+    queueId: string;
+    scopeId: string;
+    scopeKind: FrontierSwarmMergeQueueScopeKind;
+    title: string;
+    leaseScope: string;
+    leaseKey: string;
+    parentQueueId?: string;
+    lane?: string;
+    changedPaths: string[];
+    changedRegions: string[];
+    jobIds: string[];
+    actions: Record<string, string[]>;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmCoordinatorAgentDrainAssignment {
+    id: string;
+    jobId: string;
+    taskId?: string;
+    lane?: string;
+    title?: string;
+    queueItemIds: string[];
+    queueId: string;
+    queueKind: FrontierSwarmMergeQueueScopeKind;
+    rootQueueId: string;
+    parentQueueIds: string[];
+    parentQueueId?: string;
+    promoteToQueueId?: string;
+    leaseId: string;
+    leaseScope: string;
+    assignedAction: FrontierSwarmMergeQueueAssignmentAction;
+    decision: FrontierSwarmCoordinatorAgentDrainDecision;
+    classification: FrontierSwarmCoordinatorAgentDrainClassification;
+    terminal: boolean;
+    terminalDecisionId?: string;
+    terminalDecisionQueueItemIds?: string[];
+    reasons: string[];
+    admitted: boolean;
+    riskLevel: FrontierSwarmRiskLevel;
+    disposition: FrontierSwarmMergeDisposition;
+    mergeReadiness: FrontierSwarmMergeReadiness;
+    changedPaths: string[];
+    changedRegions: string[];
+    conflictingJobIds: string[];
+    retrySlices?: FrontierSwarmMergeQueueRetrySlice[];
+    semanticSliceScopeIds?: string[];
+    semanticSliceLeaseKeys?: string[];
+    requiredLeaseScopeIds?: string[];
+    requiredLeaseKeys?: string[];
+    parentDecisionRegions?: string[];
+    unknownRegions?: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmCoordinatorAgentDrainTerminalDecision {
+    id: string;
+    jobId: string;
+    queueItemIds: string[];
+    queueId: string;
+    leaseId: string;
+    leaseScope: string;
+    assignedAction: FrontierSwarmMergeQueueAssignmentAction;
+    decision: FrontierSwarmCoordinatorAgentDrainDecision;
+    classification: 'terminal';
+    terminal: true;
+    reasons: string[];
+    retrySlices?: FrontierSwarmMergeQueueRetrySlice[];
+    semanticSliceScopeIds?: string[];
+    semanticSliceLeaseKeys?: string[];
+    requiredLeaseScopeIds?: string[];
+    requiredLeaseKeys?: string[];
+    parentDecisionRegions?: string[];
+    unknownRegions?: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmCoordinatorAgentPromotedWork {
+    id: string;
+    jobId: string;
+    taskId?: string;
+    lane?: string;
+    queueItemIds: string[];
+    fromQueueId: string;
+    parentQueueId: string;
+    leaseId: string;
+    leaseScope: string;
+    assignedAction: FrontierSwarmMergeQueueAssignmentAction;
+    decision: FrontierSwarmCoordinatorAgentDrainDecision;
+    classification: 'non-terminal';
+    terminal: false;
+    reasons: string[];
+    requiredLeaseScopeIds?: string[];
+    requiredLeaseKeys?: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmContinuousPoolWorkItemInput {
+    id?: string;
+    jobId?: string;
+    taskId?: string;
+    queueItemId?: string;
+    queueItemIds?: readonly string[];
+    lane?: string;
+    bucket?: FrontierSwarmContinuousPoolBucket;
+    source?: string;
+    status?: string;
+    priority?: number;
+    priorityClass?: FrontierSwarmPriorityClass;
+    reasons?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmContinuousPoolWorkItem {
+    id: string;
+    jobId?: string;
+    taskId?: string;
+    queueItemIds: string[];
+    lane?: string;
+    bucket: FrontierSwarmContinuousPoolBucket;
+    source: string;
+    status?: string;
+    priority?: number;
+    priorityClass: FrontierSwarmPriorityClass;
+    reasons: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmContinuousPoolStateInput {
+    id?: string;
+    maxWorkers?: number;
+    active?: readonly (string | FrontierSwarmContinuousPoolWorkItemInput)[];
+    queued?: readonly (string | FrontierSwarmContinuousPoolWorkItemInput)[];
+    reviewDrain?: readonly (string | FrontierSwarmContinuousPoolWorkItemInput)[];
+    rerun?: readonly (string | FrontierSwarmContinuousPoolWorkItemInput)[];
+    humanBlocked?: readonly (string | FrontierSwarmContinuousPoolWorkItemInput)[];
+    conflicted?: readonly (string | FrontierSwarmContinuousPoolWorkItemInput)[];
+    conflicts?: readonly (string | FrontierSwarmContinuousPoolWorkItemInput)[];
+    capacityBlocked?: readonly (string | FrontierSwarmContinuousPoolWorkItemInput)[];
+    done?: readonly (string | FrontierSwarmContinuousPoolWorkItemInput)[];
+    activeLeases?: readonly FrontierSwarmLease[];
+    queueSnapshot?: FrontierSwarmQueueSnapshot;
+    schedule?: FrontierSwarmSchedule;
+    drainWork?: FrontierSwarmCoordinatorAgentDrainWork;
+    outcomeModel?: FrontierSwarmQueueOutcomeModel;
+    decisions?: readonly (FrontierSwarmQueueOutcomeDecisionInput | FrontierSwarmQueueOutcomeDecision)[];
+    terminalState?: FrontierSwarmTerminalStateReconciliation;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmContinuousPoolRefillSlot {
+    id: string;
+    index: number;
+    state: 'fillable' | 'idle' | string;
+    recommendationId?: string;
+}
+export interface FrontierSwarmContinuousPoolRefillRecommendation {
+    id: string;
+    slotId: string;
+    action: FrontierSwarmContinuousPoolRefillAction;
+    bucket: FrontierSwarmContinuousPoolBucket;
+    itemIds: string[];
+    jobIds: string[];
+    priority: number;
+    priorityClass: FrontierSwarmPriorityClass;
+    reasons: string[];
+}
+export interface FrontierSwarmContinuousPoolState {
+    kind: typeof FRONTIER_SWARM_CONTINUOUS_POOL_STATE_KIND;
+    version: typeof FRONTIER_SWARM_CONTINUOUS_POOL_STATE_VERSION;
+    id: string;
+    generatedAt: number;
+    phase: FrontierSwarmContinuousPoolPhase;
+    maxWorkers?: number;
+    activeLeases: FrontierSwarmLease[];
+    buckets: {
+        active: FrontierSwarmContinuousPoolWorkItem[];
+        queued: FrontierSwarmContinuousPoolWorkItem[];
+        reviewDrain: FrontierSwarmContinuousPoolWorkItem[];
+        rerun: FrontierSwarmContinuousPoolWorkItem[];
+        humanBlocked: FrontierSwarmContinuousPoolWorkItem[];
+        conflicted: FrontierSwarmContinuousPoolWorkItem[];
+        capacityBlocked: FrontierSwarmContinuousPoolWorkItem[];
+        done: FrontierSwarmContinuousPoolWorkItem[];
+    };
+    byBucket: Record<string, string[]>;
+    refillSlots: FrontierSwarmContinuousPoolRefillSlot[];
+    refillRecommendations: FrontierSwarmContinuousPoolRefillRecommendation[];
+    stopCondition?: FrontierSwarmContinuousPoolStopCondition;
+    stopConditions: FrontierSwarmContinuousPoolStopCondition[];
+    stopped: boolean;
+    drained: boolean;
+    summary: {
+        activeCount: number;
+        queuedCount: number;
+        reviewDrainCount: number;
+        rerunCount: number;
+        humanBlockedCount: number;
+        conflictedCount: number;
+        capacityBlockedCount: number;
+        doneCount: number;
+        pendingCount: number;
+        terminalUnresolvedCount: number;
+        refillSlotCount: number;
+        idleRefillSlotCount: number;
+        refillRecommendationCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmProof {
+    kind: typeof FRONTIER_SWARM_PROOF_KIND;
+    version: typeof FRONTIER_SWARM_PROOF_VERSION;
+    id: string;
+    manifestId: string;
+    generatedAt: number;
+    hash: string;
+    summary: FrontierSwarmSummary;
+    validation?: FrontierSwarmValidation;
+    metadata?: JsonObject;
+}
+export declare function defineSwarmManifest(input?: FrontierSwarmManifestInput): FrontierSwarmManifest;
+export declare function createSwarmManifest(input?: FrontierSwarmManifestInput): FrontierSwarmManifest;
+export declare function defineSwarmTasks(input?: readonly FrontierSwarmTaskInput[] | FrontierSwarmTaskSetInput): FrontierSwarmTask[];
+export declare function compileSwarm(input: FrontierSwarmManifest | FrontierSwarmManifestInput): FrontierSwarmCompiled;
+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;
+export declare function routeSwarmEventToMailboxes(stream: FrontierSwarmEventStream, eventInput: FrontierSwarmEvent | FrontierSwarmEventInput): FrontierSwarmMailbox[];
+export declare function completeSwarmJob(runInput: FrontierSwarmRun, resultInput: FrontierSwarmJobResultInput): FrontierSwarmRun;
+export declare function checkSwarmOwnership(job: FrontierSwarmJob, changedPaths: readonly string[]): FrontierSwarmOwnershipReport;
+export declare function createSwarmSemanticOwnershipStableKey(input: FrontierSwarmSemanticOwnershipStableKeyInput): string;
+export declare function createSwarmSemanticOwnershipRegionId(input: FrontierSwarmSemanticOwnershipRegionIdInput): string;
+export declare function resolveSwarmChangedRegions(job: FrontierSwarmJob, changedPaths: readonly string[], semanticImport?: FrontierSwarmSemanticImportSummary): string[];
+export declare function classifySwarmMergeReadiness(result: FrontierSwarmJobResultInput | FrontierSwarmJobResult): FrontierSwarmMergeReadiness;
+export declare function classifySwarmMergeDisposition(result: FrontierSwarmJobResultInput | FrontierSwarmJobResult, input?: {
+    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 createSwarmHierarchicalMergeQueue(input: FrontierSwarmHierarchicalMergeQueueInput): FrontierSwarmHierarchicalMergeQueue;
+export declare function createSwarmCoordinatorAgentDrainWork(input: FrontierSwarmCoordinatorAgentDrainWorkInput): FrontierSwarmCoordinatorAgentDrainWork;
+export declare function summarizeSwarmCoordinatorAgentDrainWork(work: Pick<FrontierSwarmCoordinatorAgentDrainWork, 'leases' | 'assignments' | 'terminalDecisions' | 'promotedWork'>): FrontierSwarmCoordinatorAgentDrainWorkConsumerSummary;
+export declare function createSwarmContinuousPoolState(input?: FrontierSwarmContinuousPoolStateInput): FrontierSwarmContinuousPoolState;
+export declare function classifySwarmQueueOutcome(input: FrontierSwarmQueueOutcomeDecisionInput): FrontierSwarmQueueOutcomeClassification;
+export declare function createSwarmQueueOutcomeDecision(input: FrontierSwarmQueueOutcomeDecisionInput | FrontierSwarmQueueOutcomeDecision): FrontierSwarmQueueOutcomeDecision;
+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?: {
+    generatedAt?: number;
+    validation?: FrontierSwarmValidation;
+    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;
+export declare function createSwarmRunCheckpoint(input: FrontierSwarmRun | FrontierSwarmRunCheckpointInput): FrontierSwarmRunCheckpoint;
+export declare function checkSwarmBudget(job: FrontierSwarmJob, usageInput: FrontierSwarmUsageInput): FrontierSwarmBudgetDecision;
+export declare function createSwarmArtifactIndex(input: FrontierSwarmRun | {
+    run?: FrontierSwarmRun;
+    artifacts?: readonly FrontierSwarmArtifactInput[];
+    generatedAt?: number;
+}): FrontierSwarmArtifactIndex;
+export declare function createSwarmReviewPlan(input: FrontierSwarmReviewPlanInput): FrontierSwarmReviewPlan;
+export declare function createSwarmMergePlan(input: FrontierSwarmMergePlanInput): FrontierSwarmMergePlan;
+export declare function decomposeSwarmFeature(input: FrontierSwarmDecomposeInput): FrontierSwarmTaskInput[];
+export declare function encodeSwarmJsonl(records: readonly unknown[]): string;
+export declare function decodeSwarmJsonl(jsonl: string): JsonValue[];
+export declare function matchesGlob(file: string, glob: string): boolean;
+export declare function mergeSwarmMetadata(metadataInputs?: readonly unknown[], verificationGates?: readonly (string | FrontierSwarmCommandInput)[]): JsonObject | undefined;
+export type FrontierSwarmBacklogStatus = 'open' | 'ready' | 'running' | 'blocked' | 'completed' | 'verified' | string;
+export type FrontierSwarmBacklogEntryKind = 'task' | 'bug' | 'feature' | 'chore' | 'research' | 'spike' | 'decision' | string;
+export type FrontierSwarmCycleType = 'milestone' | 'iteration' | 'wave' | string;
+export interface FrontierSwarmBacklogEntryInput {
+    id: string;
+    title?: string;
+    objective?: string;
+    entryKind?: FrontierSwarmBacklogEntryKind;
+    status?: FrontierSwarmBacklogStatus;
+    lane?: string;
+    layer?: string;
+    workKind?: string;
+    epicId?: string;
+    groupId?: string;
+    cycleId?: string;
+    parentEntryId?: string;
+    childEntryIds?: readonly string[];
+    taskId?: string;
+    dependsOn?: readonly string[];
+    blockedBy?: readonly string[];
+    sourceRefs?: readonly string[];
+    targetRefs?: readonly string[];
+    allowedWrites?: readonly string[];
+    acceptance?: readonly string[];
+    tags?: readonly string[];
+    priority?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmBacklogEntry extends FrontierSwarmBacklogEntryInput {
+    title: string;
+    entryKind: FrontierSwarmBacklogEntryKind;
+    status: FrontierSwarmBacklogStatus;
+    childEntryIds: string[];
+    dependsOn: string[];
+    blockedBy: string[];
+    sourceRefs: string[];
+    targetRefs: string[];
+    allowedWrites: string[];
+    acceptance: string[];
+    tags: string[];
+    priority: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmBacklogInput {
+    id?: string;
+    title?: string;
+    package?: string;
+    epics?: readonly Record<string, unknown>[];
+    taskGroups?: readonly Record<string, unknown>[];
+    cycles?: readonly Record<string, unknown>[];
+    entries?: readonly FrontierSwarmBacklogEntryInput[];
+    tasks?: readonly (FrontierSwarmTaskInput | FrontierSwarmTask)[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmBacklog {
+    kind: 'frontier.swarm.backlog';
+    version: 1;
+    id: string;
+    title: string;
+    package?: string;
+    generatedAt: number;
+    epics: Record<string, unknown>[];
+    taskGroups: Record<string, unknown>[];
+    cycles: Record<string, unknown>[];
+    entries: FrontierSwarmBacklogEntry[];
+    tasks: FrontierSwarmTask[];
+    summary: {
+        epicCount: number;
+        groupCount: number;
+        cycleCount: number;
+        entryCount: number;
+        taskCount: number;
+        readyCount: number;
+        runningCount: number;
+        blockedCount: number;
+        completedCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmBacklogTaskPlanInput {
+    backlog: FrontierSwarmBacklog | FrontierSwarmBacklogInput;
+    tasks?: readonly (FrontierSwarmTaskInput | FrontierSwarmTask)[];
+    backlogPath?: string;
+    recursive?: boolean;
+    maxDepth?: number;
+    childArtifactPath?: string;
+    decomposeLane?: string;
+    decomposeCompute?: string;
+    decomposeWorkKind?: string;
+    metadata?: unknown;
+}
+export interface FrontierSwarmBacklogDecompositionMetadata {
+    sourceId: string;
+    sourceKind: string;
+    remainingDepth: number;
+    childArtifactPath?: string;
+}
+export interface FrontierSwarmBacklogContinuationTaskPlanMetadata extends FrontierSwarmBacklogDecompositionMetadata {
+    parentTaskId?: string;
+}
+export type FrontierSwarmBacklogTaskPlanMetadata = JsonObject & {
+    sourceId?: string;
+    sourceKind?: string;
+    remainingDepth?: number;
+    childArtifactPath?: string;
+    parentTaskId?: string;
+    source?: {
+        kind?: string;
+        id?: string;
+        taskId?: string;
+    };
+    continuation?: {
+        remainingDepth?: number;
+        childArtifactPath?: string;
+    };
+};
+export interface FrontierSwarmBacklogTaskPlan {
+    kind: 'frontier.swarm.backlog-task-plan';
+    version: 1;
+    id: string;
+    backlogId: string;
+    generatedAt: number;
+    backlogPath?: string;
+    childArtifactPath?: string;
+    tasks: FrontierSwarmTask[];
+    runnableTaskIds: string[];
+    decompositionTaskIds: string[];
+    summary: {
+        taskCount: number;
+        runnableCount: number;
+        decompositionCount: number;
+    };
+    metadata?: FrontierSwarmBacklogTaskPlanMetadata;
+}
+export declare function createSwarmBacklog(input?: FrontierSwarmBacklogInput): FrontierSwarmBacklog;
+export declare function querySwarmBacklog(backlogInput: FrontierSwarmBacklog | FrontierSwarmBacklogInput, query?: Partial<FrontierSwarmBacklogEntryInput>): FrontierSwarmBacklog;
+export declare function mergeSwarmBacklogs(input: {
+    base: FrontierSwarmBacklog | FrontierSwarmBacklogInput;
+    backlogs?: readonly (FrontierSwarmBacklog | FrontierSwarmBacklogInput)[];
+    entries?: readonly FrontierSwarmBacklogEntryInput[];
+    tasks?: readonly FrontierSwarmTaskInput[];
+    generatedAt?: number;
+    metadata?: unknown;
+}): FrontierSwarmBacklog;
+export declare function createSwarmBacklogTaskPlan(input: FrontierSwarmBacklogTaskPlanInput): FrontierSwarmBacklogTaskPlan;
+export type FrontierSwarmModelRoutingMode = 'fill' | 'observe' | 'override' | string;
+export type FrontierSwarmModelRoutingScope = 'global' | 'repository' | 'package' | 'lane' | 'task' | string;
+export type FrontierSwarmEvidenceQualityBand = 'missing' | 'weak' | 'adequate' | 'strong' | string;
+export interface FrontierSwarmModelRoutingEvidenceQuality {
+    band: FrontierSwarmEvidenceQualityBand | string;
+    score?: number;
+    confidence?: FrontierSwarmConfidence | string;
+    evidencePaths?: readonly string[];
+    verifierKinds?: readonly string[];
+    missingEvidence?: readonly string[];
+    deterministic?: boolean;
+    humanReviewed?: boolean;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmModelRoutingFeedbackInput {
+    id?: string;
+    scope?: FrontierSwarmModelRoutingScope;
+    policyId?: string;
+    repository?: string;
+    package?: string;
+    runId?: string;
+    planId?: string;
+    jobId?: string;
+    taskId?: string;
+    taskKind?: string;
+    lane?: string;
+    layer?: string;
+    workKind?: string;
+    computeId?: string;
+    computeKind?: string;
+    model?: string;
+    modelTier?: string;
+    reasoningEffort?: string;
+    serviceTier?: string;
+    resultStatus?: string;
+    mergeReadiness?: FrontierSwarmMergeReadiness | string;
+    mergeDisposition?: FrontierSwarmMergeDisposition;
+    riskLevel?: FrontierSwarmRiskLevel | string;
+    evidenceQuality?: FrontierSwarmModelRoutingEvidenceQuality;
+    selected?: boolean;
+    tags?: readonly string[];
+    generatedAt?: number;
+    metadata?: unknown;
+    [key: string]: unknown;
+}
+export interface FrontierSwarmModelRoutingFeedback extends FrontierSwarmModelRoutingFeedbackInput {
+    kind: 'frontier.swarm.model-routing-feedback';
+    version: 1;
+    id: string;
+    scope: FrontierSwarmModelRoutingScope;
+    lane: string;
+    model: string;
+    taskKind: string;
+    tags: string[];
+    generatedAt: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmModelRoutingPolicySignalInput {
+    mode?: FrontierSwarmModelRoutingMode;
+    lane?: string;
+    layer?: string;
+    workKind?: string;
+    taskKind?: string;
+    computeId?: string;
+    model?: string;
+    modelTier?: string;
+    confidence?: FrontierSwarmConfidence;
+    reason?: string;
+    metadata?: unknown;
+}
+export interface FrontierSwarmModelRoutingPolicySignal extends FrontierSwarmModelRoutingPolicySignalInput {
+    id: string;
+}
+export interface FrontierSwarmModelRoutingPolicyInput {
+    id?: string;
+    defaultMode?: FrontierSwarmModelRoutingMode;
+    signals?: readonly FrontierSwarmModelRoutingPolicySignalInput[];
+    feedback?: readonly FrontierSwarmModelRoutingFeedbackInput[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmModelRoutingPolicy {
+    kind: 'frontier.swarm.model-routing-policy';
+    version: 1;
+    id: string;
+    defaultMode: FrontierSwarmModelRoutingMode;
+    signals: FrontierSwarmModelRoutingPolicySignal[];
+    feedback: FrontierSwarmModelRoutingFeedback[];
+    preferences: FrontierSwarmModelRoutingPolicySignal[];
+    generatedAt: number;
+    summary: {
+        signalCount: number;
+        feedbackCount: number;
+        selectedCount: number;
+        preferenceCount: number;
+        preferCount: number;
+        avoidCount: number;
+    };
+    metadata?: JsonObject;
+}
+export declare function createSwarmModelRoutingFeedback(input?: FrontierSwarmModelRoutingFeedbackInput): FrontierSwarmModelRoutingFeedback;
+export declare function createSwarmModelRoutingPolicy(input?: FrontierSwarmModelRoutingPolicyInput): FrontierSwarmModelRoutingPolicy;
+export declare function createSwarmModelRoutingFeedbackFromBoard(input?: {
+    board?: unknown;
+    generatedAt?: number;
+    metadata?: unknown;
+}): FrontierSwarmModelRoutingFeedback;
+export declare function createSwarmModelRoutingFeedbackFromPanel(input?: {
+    panel?: unknown;
+    generatedAt?: number;
+    metadata?: unknown;
+}): FrontierSwarmModelRoutingFeedback;
+export interface FrontierSwarmAdaptiveObservationInput {
+    kind?: string;
+    severity?: 'info' | 'warning' | 'error' | string;
+    at?: number;
+    jobId?: string;
+    lane?: string;
+    score?: number;
+    value?: number;
+    reason?: string;
+    reasons?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmTournamentAdaptiveRecommendation {
+    id?: string;
+    action?: 'increase' | 'decrease' | 'hold' | 'observe' | string;
+    target?: string;
+    key?: string;
+    model?: string;
+    computeId?: string;
+    score?: number;
+    reason?: string;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmTournamentAdaptiveFeedback {
+    kind: 'frontier.swarm.tournament-adaptive-feedback';
+    version: 1;
+    id: string;
+    tournamentId?: string;
+    historyId?: string;
+    observations: FrontierSwarmAdaptiveObservationInput[];
+    recommendations: FrontierSwarmTournamentAdaptiveRecommendation[];
+    summary: {
+        observationCount: number;
+        recommendationCount: number;
+        reduceSignals: number;
+        increaseSignals: number;
+        holdSignals: number;
+    };
+    generatedAt: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmStrategyTournamentStanding {
+    id: string;
+    strategyId: string;
+    score: number;
+    rank: number;
+    samples: number;
+    outcomeCounts: Record<string, number>;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmStrategyTournamentMatch {
+    id: string;
+    strategyId: string;
+    gameId: string;
+    outcome: string;
+    score: number;
+    tags: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmStrategyTournamentSummary {
+    strategyCount: number;
+    gameCount: number;
+    matchCount: number;
+    verifiedCount: number;
+    rejectedCount: number;
+    undefinedCount: number;
+    sampleConfidence: FrontierSwarmConfidence;
+    decisionGrade: string;
+    topStrategyId?: string;
+    topScore?: number;
+    outcomeCounts: Record<string, number>;
+}
+export interface FrontierSwarmStrategyTournament {
+    kind: 'frontier.swarm.strategy-tournament';
+    version: 1;
+    id: string;
+    title?: string;
+    candidates: Record<string, unknown>[];
+    standings: FrontierSwarmStrategyTournamentStanding[];
+    matches: FrontierSwarmStrategyTournamentMatch[];
+    summary: FrontierSwarmStrategyTournamentSummary;
+    winnerId?: string;
+    generatedAt: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmStrategyTournamentHistory {
+    kind: 'frontier.swarm.strategy-tournament-history';
+    version: 1;
+    id: string;
+    tournaments: FrontierSwarmStrategyTournament[];
+    generatedAt: number;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmStrategyTournamentComparison {
+    winnerId?: string;
+    tournamentCount: number;
+    candidateCount: number;
+    baselineId?: string;
+    currentId?: string;
+    scoreDelta?: number;
+    regression?: boolean;
+    metadata?: JsonObject;
+}
+export declare function createSwarmTournamentAdaptiveFeedback(input?: {
+    tournament?: FrontierSwarmStrategyTournament;
+    history?: FrontierSwarmStrategyTournamentHistory;
+    comparison?: FrontierSwarmStrategyTournamentComparison;
+    observations?: readonly FrontierSwarmAdaptiveObservationInput[];
+    recommendations?: readonly Partial<FrontierSwarmTournamentAdaptiveRecommendation>[];
+    scoreFloor?: number;
+    regressionThreshold?: number;
+    generatedAt?: number;
+    metadata?: unknown;
+}): FrontierSwarmTournamentAdaptiveFeedback;
+export declare function createSwarmMergeTournament(input?: {
+    id?: string;
+    title?: string;
+    candidates?: readonly Record<string, unknown>[];
+    bundles?: readonly FrontierSwarmMergeBundle[];
+    mergeIndex?: FrontierSwarmMergeIndex;
+    strategyMode?: string;
+    winnerId?: string;
+    generatedAt?: number;
+    metadata?: unknown;
+}): FrontierSwarmStrategyTournament;
+export declare function createSwarmStrategyTournamentHistory(input?: {
+    id?: string;
+    tournaments?: readonly FrontierSwarmStrategyTournament[];
+    generatedAt?: number;
+    metadata?: unknown;
+}): FrontierSwarmStrategyTournamentHistory;
+export declare function querySwarmStrategyTournament(tournament: FrontierSwarmStrategyTournament, query?: {
+    strategyId?: string;
+    gameId?: string;
+    outcome?: string;
+    tag?: string;
+    payoffTag?: string;
+    strategyTag?: string;
+    gameTag?: string;
+    minScore?: number;
+    maxScore?: number;
+}): FrontierSwarmStrategyTournament;
+export declare function compareSwarmStrategyTournaments(input: FrontierSwarmStrategyTournamentHistory | readonly FrontierSwarmStrategyTournament[] | {
+    baseline: FrontierSwarmStrategyTournament;
+    current: FrontierSwarmStrategyTournament;
+    scoreThreshold?: number;
+}): FrontierSwarmStrategyTournamentComparison;
+export interface FrontierSwarmAdaptiveLoadDecision {
+    action: 'increase' | 'decrease' | 'hold' | string;
+    target: string;
+    key?: string;
+    previous?: number;
+    next?: number;
+    reason: string;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmAdaptiveLoadPlan {
+    kind: 'frontier.swarm.adaptive-load-plan';
+    version: 1;
+    id: string;
+    planId?: string;
+    mode: string;
+    observations: FrontierSwarmAdaptiveObservationInput[];
+    decisions: FrontierSwarmAdaptiveLoadDecision[];
+    generatedAt: number;
+    limits: FrontierSwarmScheduleLimits;
+    effectiveLimits: FrontierSwarmScheduleLimits;
+    summary: {
+        observationCount: number;
+        decisionCount: number;
+        bottleneckCount: number;
+    };
+    metadata?: JsonObject;
+}
+export declare function createSwarmAdaptiveLoadPlan(input?: {
+    plan?: FrontierSwarmPlan;
+    run?: FrontierSwarmRun;
+    mode?: string;
+    observations?: readonly FrontierSwarmAdaptiveObservationInput[];
+    currentLimits?: Partial<FrontierSwarmScheduleLimits>;
+    minLimits?: Partial<FrontierSwarmScheduleLimits>;
+    maxLimits?: Partial<FrontierSwarmScheduleLimits>;
+    generatedAt?: number;
+    metadata?: unknown;
+}): FrontierSwarmAdaptiveLoadPlan;
+export declare function createSwarmScheduleInputFromAdaptiveLoadPlan(plan: FrontierSwarmPlan, adaptivePlan: FrontierSwarmAdaptiveLoadPlan, extra?: Omit<FrontierSwarmScheduleInput, 'plan'>): FrontierSwarmScheduleInput;
+export interface FrontierSwarmCoordinatorProcessInput {
+    id?: string;
+    role?: string;
+    lane?: string;
+    status?: string;
+    metadata?: unknown;
+}
+export interface FrontierSwarmCoordinatorDashboardJob {
+    jobId: string;
+    taskId?: string;
+    lane?: string;
+    status: FrontierSwarmJobStatus | string;
+    liveness: 'running' | 'finished' | 'unknown' | string;
+    disposition: FrontierSwarmMergeDisposition | string;
+    mergeReadiness?: FrontierSwarmMergeReadiness | string;
+    mergeScore: number;
+    changedPaths: string[];
+    changedRegions: string[];
+    ownershipViolations: string[];
+    tests: {
+        passed: number;
+        failed: number;
+        requiredFailed: number;
+    };
+    semanticImport?: FrontierSwarmSemanticImportSummary;
+    traceShards?: JsonValue[];
+    staleAgainstHead: boolean;
+    duplicateGroupId?: string;
+    evidencePaths: string[];
+    contextBudget?: unknown;
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmCoordinatorDashboardSummary {
+    processCount: number;
+    activeCount: number;
+    jobCount: number;
+    staleAgainstHeadCount: number;
+    readyToApplyCount: number;
+    needsHumanPortCount: number;
+    failedEvidenceCount: number;
+    averageMergeScore: number;
+    [key: string]: unknown;
+}
+export interface FrontierSwarmCoordinatorDashboard {
+    kind: 'frontier.swarm.coordinator-dashboard';
+    version: 1;
+    id: string;
+    generatedAt: number;
+    processes: FrontierSwarmCoordinatorProcessInput[];
+    jobs: FrontierSwarmCoordinatorDashboardJob[];
+    duplicateGroups: Array<{
+        id: string;
+        jobIds: string[];
+    }>;
+    evidenceIndex?: FrontierSwarmEvidenceIndex;
+    summary: FrontierSwarmCoordinatorDashboardSummary;
+    metadata?: JsonObject;
+}
+export declare function createSwarmCoordinatorDashboard(input?: {
+    plan?: FrontierSwarmPlan;
+    run?: FrontierSwarmRun;
+    bundles?: readonly FrontierSwarmMergeBundle[];
+    mergeIndex?: FrontierSwarmMergeIndex;
+    queueOverlay?: FrontierSwarmQueueOverlay;
+    evidenceIndex?: FrontierSwarmEvidenceIndex;
+    admission?: FrontierSwarmMergeAdmission;
+    processes?: readonly FrontierSwarmCoordinatorProcessInput[];
+    generatedAt?: number;
+    metadata?: unknown;
+}): FrontierSwarmCoordinatorDashboard;
+export declare function querySwarmCoordinatorDashboard(dashboard: FrontierSwarmCoordinatorDashboard): FrontierSwarmCoordinatorDashboard;
 //# sourceMappingURL=index.d.ts.map