@shapeshift-labs/frontier-swarm 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -9,18 +9,48 @@ 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_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_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_LANE_PLAYBOOK_KIND = "frontier.swarm.lane-playbook";
+export declare const FRONTIER_SWARM_LANE_PLAYBOOK_VERSION = 1;
+export declare const FRONTIER_SWARM_PATCH_STACK_PLAN_KIND = "frontier.swarm.patch-stack-plan";
+export declare const FRONTIER_SWARM_PATCH_STACK_PLAN_VERSION = 1;
 export declare const FRONTIER_SWARM_DEFAULT_CODEX_COMPUTE_ID = "codex.gpt-5.5.xhigh";
 export declare const FRONTIER_SWARM_DEFAULT_MODEL = "gpt-5.5";
 export declare const FRONTIER_SWARM_DEFAULT_REASONING_EFFORT = "xhigh";
@@ -29,6 +59,11 @@ export type FrontierSwarmReasoningEffort = 'minimal' | 'low' | 'medium' | 'high'
 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 interface FrontierSwarmComputeInput {
     id: string;
     kind?: FrontierSwarmComputeKind;
@@ -79,6 +114,25 @@ export interface FrontierSwarmLayer {
     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 interface FrontierSwarmLaneInput {
     id: string;
     title?: string;
@@ -89,6 +143,9 @@ export interface FrontierSwarmLaneInput {
     allowedGlobs?: readonly string[];
     sharedReadOnly?: readonly string[];
     neverEdit?: readonly string[];
+    ownershipRegions?: readonly FrontierSwarmOwnershipRegionInput[];
+    capabilities?: readonly string[];
+    resourceRequirements?: FrontierSwarmResourceRequirementsInput;
     worktreePath?: string;
     evidencePrefix?: string;
     evidenceOutDirPrefix?: string;
@@ -107,6 +164,9 @@ export interface FrontierSwarmLane {
     allowedWrites: string[];
     sharedReadOnly: string[];
     neverEdit: string[];
+    ownershipRegions: FrontierSwarmOwnershipRegion[];
+    capabilities: string[];
+    resourceRequirements?: FrontierSwarmResourceRequirements;
     worktreePath?: string;
     evidencePrefix?: string;
     concurrencyKey: string;
@@ -131,6 +191,36 @@ export interface FrontierSwarmCommand {
     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;
@@ -217,6 +307,11 @@ export interface FrontierSwarmTaskInput {
     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;
@@ -249,6 +344,11 @@ export interface FrontierSwarmTask {
     sourceRefs: string[];
     targetRefs: string[];
     allowedWrites: string[];
+    ownershipRegions: FrontierSwarmOwnershipRegion[];
+    ownedRegions: string[];
+    changedRegions: string[];
+    capabilities: string[];
+    resourceRequirements?: FrontierSwarmResourceRequirements;
     acceptance: string[];
     verification: FrontierSwarmCommand[];
     evidenceCommand?: string;
@@ -286,6 +386,38 @@ export interface FrontierSwarmPlanFilter {
     limit?: number;
     compute?: string;
 }
+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 FrontierSwarmPlanInput extends FrontierSwarmPlanFilter {
     id?: string;
     runId?: string;
@@ -330,6 +462,11 @@ export interface FrontierSwarmJob {
     allowedWrites: string[];
     sharedReadOnly: string[];
     neverEdit: string[];
+    ownershipRegions: FrontierSwarmOwnershipRegion[];
+    ownedRegions: string[];
+    changedRegions: string[];
+    capabilities: string[];
+    resourceRequirements?: FrontierSwarmResourceRequirements;
     worktreePath?: string;
     evidencePrefix?: string;
     concurrencyKey: string;
@@ -454,6 +591,8 @@ export interface FrontierSwarmScheduledJob {
     concurrencyKey: string;
     priority: number;
     dependsOn: string[];
+    capabilities: string[];
+    resourceRequirements?: FrontierSwarmResourceRequirements;
 }
 export interface FrontierSwarmBlockedJob extends FrontierSwarmScheduledJob {
     reasons: string[];
@@ -464,6 +603,8 @@ export interface FrontierSwarmRunningJob {
     lane: string;
     compute: string;
     concurrencyKey: string;
+    capabilities: string[];
+    resourceRequirements?: FrontierSwarmResourceRequirements;
 }
 export interface FrontierSwarmScheduleSummary {
     jobCount: number;
@@ -493,6 +634,110 @@ export interface FrontierSwarmLease {
     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;
@@ -634,16 +879,73 @@ export interface FrontierSwarmEvent {
     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[];
     lastMessage?: string;
     error?: unknown;
@@ -672,14 +974,20 @@ export interface FrontierSwarmVerificationResult {
 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[];
     lastMessage?: string;
     error?: string;
@@ -691,6 +999,474 @@ export interface FrontierSwarmOwnershipReport {
     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;
+    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[];
+    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;
+}
+export interface FrontierSwarmMergeConflict {
+    jobIds: string[];
+    key: string;
+    kind: 'path' | 'region';
+    path?: string;
+    region?: string;
+}
+export interface FrontierSwarmRegionOwnershipInput {
+    changedPaths?: readonly string[];
+    changedRegions?: readonly string[];
+}
+export interface FrontierSwarmRegionOwnershipReport {
+    ok: boolean;
+    jobId: string;
+    changedPaths: string[];
+    changedRegions: string[];
+    ownedRegions: string[];
+    regionViolations: string[];
+    unclassifiedChangedPaths: string[];
+}
+export interface FrontierSwarmHotspotReportInput {
+    id?: string;
+    bundles?: readonly FrontierSwarmMergeBundle[];
+    results?: readonly (FrontierSwarmJobResult | FrontierSwarmJobResultInput)[];
+    threshold?: number;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmHotspotReport {
+    kind: typeof FRONTIER_SWARM_HOTSPOT_REPORT_KIND;
+    version: typeof FRONTIER_SWARM_HOTSPOT_REPORT_VERSION;
+    id: string;
+    generatedAt: number;
+    threshold: number;
+    entries: FrontierSwarmHotspotEntry[];
+    recommendations: FrontierSwarmHotspotRecommendation[];
+    summary: {
+        pathCount: number;
+        hotspotCount: number;
+        recommendationCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmHotspotEntry {
+    path: string;
+    touchCount: number;
+    jobIds: string[];
+    regions: string[];
+    dispositions: string[];
+    riskLevels: string[];
+}
+export interface FrontierSwarmHotspotRecommendation {
+    path: string;
+    reason: 'repeated-conflicts' | 'hot-file' | 'region-overlap';
+    suggestedModuleId: string;
+    suggestedOwnershipRegions: string[];
+    jobIds: string[];
+}
+export interface FrontierSwarmReviewerLanePlanInput {
+    id?: string;
+    index: FrontierSwarmMergeIndex;
+    admission?: FrontierSwarmMergeAdmission;
+    reviewerLane?: string;
+    reviewers?: readonly string[];
+    includeAutoMergeable?: boolean;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmReviewerLanePlan {
+    kind: typeof FRONTIER_SWARM_REVIEWER_LANE_PLAN_KIND;
+    version: typeof FRONTIER_SWARM_REVIEWER_LANE_PLAN_VERSION;
+    id: string;
+    mergeIndexId: string;
+    generatedAt: number;
+    reviewerLane: string;
+    assignments: FrontierSwarmReviewerLaneAssignment[];
+    tasks: FrontierSwarmTaskInput[];
+    summary: {
+        assignmentCount: number;
+        taskCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmReviewerLaneAssignment {
+    jobId: string;
+    reviewers: string[];
+    required: boolean;
+    reasons: string[];
+}
+export interface FrontierSwarmRunStoreShardsInput {
+    id?: string;
+    run?: FrontierSwarmRun;
+    plan?: FrontierSwarmPlan;
+    root?: string;
+    shardSize?: number;
+    groupBy?: 'lane' | 'hash' | 'none';
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmRunStoreShards {
+    kind: typeof FRONTIER_SWARM_RUN_STORE_SHARDS_KIND;
+    version: typeof FRONTIER_SWARM_RUN_STORE_SHARDS_VERSION;
+    id: string;
+    runId?: string;
+    planId?: string;
+    root: string;
+    generatedAt: number;
+    groupBy: 'lane' | 'hash' | 'none';
+    shardSize: number;
+    shards: FrontierSwarmRunStoreShard[];
+    summary: {
+        shardCount: number;
+        jobCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmRunStoreShard {
+    id: string;
+    lane?: string;
+    path: string;
+    eventPath: string;
+    resultPath: string;
+    checkpointPath: string;
+    jobIds: string[];
+}
+export interface FrontierSwarmMergeAdmissionInput {
+    id?: string;
+    index: FrontierSwarmMergeIndex;
+    maxReady?: number;
+    maxChangedPaths?: number;
+    maxChangedRegions?: number;
+    maxHighRisk?: number;
+    allowRisks?: readonly FrontierSwarmRiskLevel[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmMergeAdmission {
+    kind: typeof FRONTIER_SWARM_MERGE_ADMISSION_KIND;
+    version: typeof FRONTIER_SWARM_MERGE_ADMISSION_VERSION;
+    id: string;
+    mergeIndexId: string;
+    generatedAt: number;
+    admitted: string[];
+    deferred: FrontierSwarmMergeAdmissionDeferral[];
+    budget: {
+        maxReady: number;
+        maxChangedPaths?: number;
+        maxChangedRegions?: number;
+        maxHighRisk?: number;
+        allowRisks: string[];
+    };
+    summary: {
+        admittedCount: number;
+        deferredCount: number;
+        changedPathCount: number;
+        changedRegionCount: number;
+        highRiskCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmMergeAdmissionDeferral {
+    jobId: string;
+    reasons: string[];
+}
+export interface FrontierSwarmContextPackInput {
+    id?: string;
+    job?: FrontierSwarmJob;
+    task?: FrontierSwarmTask | FrontierSwarmTaskInput;
+    title?: string;
+    files?: readonly string[];
+    apiMap?: Record<string, readonly string[]>;
+    knownFailures?: readonly string[];
+    commands?: readonly (string | FrontierSwarmCommandInput)[];
+    oracleCommands?: readonly (string | FrontierSwarmCommandInput)[];
+    evidenceSchema?: unknown;
+    expectedEvidence?: readonly string[];
+    exclusions?: readonly string[];
+    avoidInvestigating?: readonly string[];
+    playbookIds?: readonly string[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmContextPack {
+    kind: typeof FRONTIER_SWARM_CONTEXT_PACK_KIND;
+    version: typeof FRONTIER_SWARM_CONTEXT_PACK_VERSION;
+    id: string;
+    jobId?: string;
+    taskId?: string;
+    lane?: string;
+    title: string;
+    generatedAt: number;
+    files: string[];
+    apiMap: Record<string, string[]>;
+    knownFailures: string[];
+    commands: FrontierSwarmCommand[];
+    oracleCommands: FrontierSwarmCommand[];
+    evidenceSchema?: JsonValue;
+    expectedEvidence: string[];
+    exclusions: string[];
+    avoidInvestigating: string[];
+    playbookIds: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmOracleArtifactInput {
+    id: string;
+    path: string;
+    kind?: string;
+    command?: string | FrontierSwarmCommandInput;
+    hash?: string;
+    sourceRef?: string;
+    tags?: readonly string[];
+    metadata?: unknown;
+}
+export interface FrontierSwarmOracleArtifact {
+    id: string;
+    path: string;
+    kind: string;
+    command?: FrontierSwarmCommand;
+    hash?: string;
+    sourceRef?: string;
+    tags: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmOracleCorpusInput {
+    id?: string;
+    title?: string;
+    artifacts?: readonly FrontierSwarmOracleArtifactInput[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmOracleCorpus {
+    kind: typeof FRONTIER_SWARM_ORACLE_CORPUS_KIND;
+    version: typeof FRONTIER_SWARM_ORACLE_CORPUS_VERSION;
+    id: string;
+    title: string;
+    generatedAt: number;
+    artifacts: FrontierSwarmOracleArtifact[];
+    byKind: Record<string, string[]>;
+    byTag: Record<string, string[]>;
+    summary: {
+        artifactCount: number;
+        kindCount: number;
+        tagCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmLanePlaybookInput {
+    id?: string;
+    lane: string;
+    title?: string;
+    successfulBundles?: readonly FrontierSwarmMergeBundle[];
+    notes?: readonly string[];
+    commands?: readonly (string | FrontierSwarmCommandInput)[];
+    avoidInvestigating?: readonly string[];
+    evidencePatterns?: readonly string[];
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmLanePlaybook {
+    kind: typeof FRONTIER_SWARM_LANE_PLAYBOOK_KIND;
+    version: typeof FRONTIER_SWARM_LANE_PLAYBOOK_VERSION;
+    id: string;
+    lane: string;
+    title: string;
+    generatedAt: number;
+    notes: string[];
+    commands: FrontierSwarmCommand[];
+    avoidInvestigating: string[];
+    evidencePatterns: string[];
+    successfulJobIds: string[];
+    hotPaths: string[];
+    changedRegions: string[];
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmPatchStackPlanInput {
+    id?: string;
+    index: FrontierSwarmMergeIndex;
+    maxStackSize?: number;
+    generatedAt?: number;
+    metadata?: unknown;
+}
+export interface FrontierSwarmPatchStackPlan {
+    kind: typeof FRONTIER_SWARM_PATCH_STACK_PLAN_KIND;
+    version: typeof FRONTIER_SWARM_PATCH_STACK_PLAN_VERSION;
+    id: string;
+    mergeIndexId: string;
+    generatedAt: number;
+    stacks: FrontierSwarmPatchStack[];
+    summary: {
+        stackCount: number;
+        jobCount: number;
+        conflictedStackCount: number;
+    };
+    metadata?: JsonObject;
+}
+export interface FrontierSwarmPatchStack {
+    id: string;
+    title: string;
+    lane?: string;
+    jobIds: string[];
+    changedPaths: string[];
+    changedRegions: string[];
+    riskLevels: string[];
+    dispositions: string[];
+    conflicts: FrontierSwarmMergeConflict[];
+    gateHints: string[];
+}
 export interface FrontierSwarmProof {
     kind: typeof FRONTIER_SWARM_PROOF_KIND;
     version: typeof FRONTIER_SWARM_PROOF_VERSION;
@@ -708,10 +1484,32 @@ export declare function defineSwarmTasks(input?: readonly FrontierSwarmTaskInput
 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 createSwarmRun(input: FrontierSwarmRunInput): FrontierSwarmRun;
 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 resolveSwarmChangedRegions(job: FrontierSwarmJob, changedPaths: readonly string[]): 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 createSwarmLanePlaybook(input: FrontierSwarmLanePlaybookInput): FrontierSwarmLanePlaybook;
+export declare function createSwarmPatchStackPlan(input: FrontierSwarmPatchStackPlanInput): FrontierSwarmPatchStackPlan;
 export declare function resolveSwarmCompute(manifestInput: FrontierSwarmManifest | FrontierSwarmManifestInput, taskInput: FrontierSwarmTask | FrontierSwarmTaskInput): FrontierSwarmCompute;
 export declare function createSwarmProof(input: FrontierSwarmManifest | FrontierSwarmPlan | FrontierSwarmRun, options?: {
     generatedAt?: number;
@@ -720,6 +1518,9 @@ export declare function createSwarmProof(input: FrontierSwarmManifest | Frontier
 }): FrontierSwarmProof;
 export declare function createSwarmSchedule(input: FrontierSwarmPlan | FrontierSwarmScheduleInput): FrontierSwarmSchedule;
 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;