@shapeshift-labs/frontier-swarm 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -9,8 +9,28 @@ 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_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";
@@ -19,6 +39,9 @@ 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 interface FrontierSwarmComputeInput {
     id: string;
     kind?: FrontierSwarmComputeKind;
@@ -69,6 +92,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;
@@ -79,6 +121,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;
@@ -97,6 +142,9 @@ export interface FrontierSwarmLane {
     allowedWrites: string[];
     sharedReadOnly: string[];
     neverEdit: string[];
+    ownershipRegions: FrontierSwarmOwnershipRegion[];
+    capabilities: string[];
+    resourceRequirements?: FrontierSwarmResourceRequirements;
     worktreePath?: string;
     evidencePrefix?: string;
     concurrencyKey: string;
@@ -121,6 +169,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;
@@ -198,11 +276,20 @@ export interface FrontierSwarmTaskInput {
     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;
@@ -227,10 +314,19 @@ export interface FrontierSwarmTask {
     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;
@@ -268,10 +364,46 @@ 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;
     now?: number;
+    maxReadyJobs?: number;
+    maxLaneConcurrency?: Record<string, number>;
+    maxConcurrencyKeyConcurrency?: Record<string, number>;
+    maxComputeConcurrency?: Record<string, number>;
     metadata?: unknown;
 }
 export interface FrontierSwarmPlan {
@@ -282,11 +414,19 @@ export interface FrontierSwarmPlan {
     manifestId: string;
     createdAt: number;
     filters: FrontierSwarmPlanFilter;
+    limits: FrontierSwarmScheduleLimits;
     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>;
+}
 export interface FrontierSwarmJob {
     id: string;
     taskId: string;
@@ -300,15 +440,369 @@ 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;
     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 interface FrontierSwarmScheduleInput {
+    plan: FrontierSwarmPlan;
+    run?: FrontierSwarmRun;
+    now?: number;
+    maxReadyJobs?: number;
+    maxLaneConcurrency?: Record<string, number>;
+    maxConcurrencyKeyConcurrency?: Record<string, number>;
+    maxComputeConcurrency?: 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;
+}
+export interface FrontierSwarmScheduledJob {
+    jobId: string;
+    taskId: string;
+    lane: string;
+    compute: string;
+    concurrencyKey: string;
+    priority: number;
+    dependsOn: string[];
+    capabilities: string[];
+    resourceRequirements?: FrontierSwarmResourceRequirements;
+}
+export interface FrontierSwarmBlockedJob extends FrontierSwarmScheduledJob {
+    reasons: string[];
+    waitingFor: string[];
+}
+export interface FrontierSwarmRunningJob {
+    jobId: string;
+    lane: string;
+    compute: string;
+    concurrencyKey: string;
+    capabilities: string[];
+    resourceRequirements?: FrontierSwarmResourceRequirements;
+}
+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;
@@ -363,16 +857,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;
@@ -401,14 +952,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;
@@ -420,6 +977,57 @@ 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 FrontierSwarmProof {
     kind: typeof FRONTIER_SWARM_PROOF_KIND;
     version: typeof FRONTIER_SWARM_PROOF_VERSION;
@@ -437,16 +1045,40 @@ 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 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 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;