@shapeshift-labs/frontier-swarm 0.1.0 → 0.3.0

package/dist/index.js

@@ -8,12 +8,45 @@ export const FRONTIER_SWARM_RUN_KIND = 'frontier.swarm.run';
 export const FRONTIER_SWARM_RUN_VERSION = 1;
 export const FRONTIER_SWARM_EVENT_KIND = 'frontier.swarm.event';
 export const FRONTIER_SWARM_EVENT_VERSION = 1;
+export const FRONTIER_SWARM_EVENT_STREAM_KIND = 'frontier.swarm.event-stream';
+export const FRONTIER_SWARM_EVENT_STREAM_VERSION = 1;
+export const FRONTIER_SWARM_MAILBOX_KIND = 'frontier.swarm.mailbox';
+export const FRONTIER_SWARM_MAILBOX_VERSION = 1;
 export const FRONTIER_SWARM_PROOF_KIND = 'frontier.swarm.proof';
 export const FRONTIER_SWARM_PROOF_VERSION = 1;
+export const FRONTIER_SWARM_SCHEDULE_KIND = 'frontier.swarm.schedule';
+export const FRONTIER_SWARM_SCHEDULE_VERSION = 1;
+export const FRONTIER_SWARM_LEASE_KIND = 'frontier.swarm.lease';
+export const FRONTIER_SWARM_LEASE_VERSION = 1;
+export const FRONTIER_SWARM_QUEUE_SNAPSHOT_KIND = 'frontier.swarm.queue-snapshot';
+export const FRONTIER_SWARM_QUEUE_SNAPSHOT_VERSION = 1;
+export const FRONTIER_SWARM_RUN_CHECKPOINT_KIND = 'frontier.swarm.run-checkpoint';
+export const FRONTIER_SWARM_RUN_CHECKPOINT_VERSION = 1;
+export const FRONTIER_SWARM_ARTIFACT_INDEX_KIND = 'frontier.swarm.artifact-index';
+export const FRONTIER_SWARM_ARTIFACT_INDEX_VERSION = 1;
+export const FRONTIER_SWARM_REVIEW_PLAN_KIND = 'frontier.swarm.review-plan';
+export const FRONTIER_SWARM_REVIEW_PLAN_VERSION = 1;
+export const FRONTIER_SWARM_MERGE_PLAN_KIND = 'frontier.swarm.merge-plan';
+export const FRONTIER_SWARM_MERGE_PLAN_VERSION = 1;
+export const FRONTIER_SWARM_MERGE_BUNDLE_KIND = 'frontier.swarm.merge-bundle';
+export const FRONTIER_SWARM_MERGE_BUNDLE_VERSION = 1;
 export const FRONTIER_SWARM_DEFAULT_CODEX_COMPUTE_ID = 'codex.gpt-5.5.xhigh';
 export const FRONTIER_SWARM_DEFAULT_MODEL = 'gpt-5.5';
 export const FRONTIER_SWARM_DEFAULT_REASONING_EFFORT = 'xhigh';
 const DEFAULT_COMPLETED_STATUSES = ['completed', 'verified', 'done', 'verified-local-harness'];
+const DEFAULT_SWARM_EVENT_TYPES = [
+    'swarm.started',
+    'swarm.finished',
+    'agent.scheduled',
+    'agent.finished',
+    'agent.handoff',
+    'agent.blocked',
+    'agent.ownership-request',
+    'agent.evidence',
+    'review.requested',
+    'review.completed',
+    'merge.proposed'
+];
 export function defineSwarmManifest(input = {}) {
     return createSwarmManifest(input);
 }
@@ -122,6 +155,8 @@ export function createSwarmPlan(manifestInput, taskInput, options = {}) {
     const tasks = normalizeTaskList(taskInput);
     const jobs = selectSwarmTasks(compiled.manifest, tasks, options).map((task) => createJob(compiled, task, options));
     const id = options.id ?? 'swarm-plan:' + stableHash([compiled.manifest.id, jobs.map((job) => job.id), options]);
+    const graph = createSwarmJobGraph(jobs);
+    const validation = validateTasksForManifest(compiled, tasks, graph);
     return {
         kind: FRONTIER_SWARM_PLAN_KIND,
         version: FRONTIER_SWARM_PLAN_VERSION,
@@ -138,12 +173,49 @@ export function createSwarmPlan(manifestInput, taskInput, options = {}) {
             limit: options.limit,
             compute: options.compute
         },
-        validation: validateTasksForManifest(compiled, tasks),
+        limits: normalizeScheduleLimits(compiled.manifest, options),
+        validation,
         jobs,
+        graph,
         summary: summarizeJobs(jobs),
         ...(toJsonObject(options.metadata) ? { metadata: toJsonObject(options.metadata) } : {})
     };
 }
+export function createSwarmTaskSelection(manifestInput, taskInput, options = {}) {
+    const manifest = compileSwarm(manifestInput).manifest;
+    const tasks = normalizeTaskList(taskInput);
+    const lanes = new Set(options.lanes ?? []);
+    const layers = new Set(options.layers ?? []);
+    const statuses = new Set(options.statuses ?? []);
+    const workKinds = new Set(options.workKinds ?? []);
+    const selectors = (options.selectors ?? []).map((selector) => selector.toLowerCase());
+    const completed = new Set(manifest.policy.completedStatuses);
+    const limit = options.limit === undefined ? tasks.length : Math.max(0, Math.floor(options.limit));
+    const candidates = tasks
+        .filter((task) => !task.lane || manifest.lanes.some((lane) => lane.id === task.lane))
+        .filter((task) => lanes.size === 0 || (task.lane !== undefined && lanes.has(task.lane)))
+        .filter((task) => layers.size === 0 || taskLayer(manifest, task) !== undefined && layers.has(taskLayer(manifest, task)))
+        .filter((task) => statuses.size === 0 || statuses.has(task.status))
+        .filter((task) => workKinds.size === 0 || workKinds.has(task.workKind))
+        .filter((task) => options.includeCompleted || !completed.has(task.status))
+        .filter((task) => selectors.length === 0 || selectors.some((selector) => searchableTask(task).includes(selector)))
+        .map((task) => createSelectionEntry(manifest, task, options.priority))
+        .filter((entry) => options.includeOwnershipWarnings || entry.ownershipWarnings.length === 0)
+        .sort((left, right) => (left.selectionPriority - right.selectionPriority
+        || left.task.priority - right.task.priority
+        || left.task.id.localeCompare(right.task.id)));
+    const ordered = options.spreadLanes ? roundRobinSelectionByLane(candidates) : candidates;
+    const entries = ordered.slice(0, limit).map((entry, index) => {
+        if (!options.assignSelectionPriority)
+            return entry;
+        return { ...entry, task: { ...entry.task, priority: index } };
+    });
+    return {
+        tasks: entries.map((entry) => entry.task),
+        entries,
+        summary: summarizeTaskSelection(entries)
+    };
+}
 export function createSwarmRun(input) {
     const results = (input.results ?? []).map(normalizeResult);
     const events = (input.events ?? []).map((event) => normalizeEvent({ ...event, runId: event.runId ?? input.id ?? input.plan.runId }));
@@ -168,6 +240,67 @@ export function recordSwarmEvent(runInput, eventInput) {
     run.events = run.events.concat(normalizeEvent({ ...eventInput, runId: eventInput.runId ?? run.id }));
     return run;
 }
+export function createSwarmMailbox(input = {}) {
+    const scope = input.scope ?? (input.lane ? 'lane' : input.jobId ? 'job' : 'global');
+    const eventTypes = uniqueStrings(input.eventTypes ?? DEFAULT_SWARM_EVENT_TYPES);
+    return {
+        kind: FRONTIER_SWARM_MAILBOX_KIND,
+        version: FRONTIER_SWARM_MAILBOX_VERSION,
+        id: input.id ?? 'swarm-mailbox:' + stableHash([input.runId, scope, input.lane, input.jobId, input.path, eventTypes]),
+        ...(input.runId ? { runId: input.runId } : {}),
+        scope,
+        ...(input.lane ? { lane: input.lane } : {}),
+        ...(input.jobId ? { jobId: input.jobId } : {}),
+        ...(input.path ? { path: input.path } : {}),
+        eventTypes,
+        appendOnly: input.appendOnly ?? true,
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function createSwarmEventStream(input = {}) {
+    const laneIds = uniqueStrings((input.lanes ?? []).map(readLaneId));
+    const eventTypes = uniqueStrings(input.eventTypes ?? DEFAULT_SWARM_EVENT_TYPES);
+    const appendOnly = input.appendOnly ?? true;
+    const global = createSwarmMailbox({
+        runId: input.runId,
+        scope: 'global',
+        path: input.root ? joinPathParts(input.root, 'global.jsonl') : undefined,
+        eventTypes,
+        appendOnly
+    });
+    const lanes = Object.fromEntries(laneIds.map((lane) => [lane, createSwarmMailbox({
+            runId: input.runId,
+            scope: 'lane',
+            lane,
+            path: input.root ? joinPathParts(input.root, 'lanes', `${lane}.jsonl`) : undefined,
+            eventTypes,
+            appendOnly
+        })]));
+    return {
+        kind: FRONTIER_SWARM_EVENT_STREAM_KIND,
+        version: FRONTIER_SWARM_EVENT_STREAM_VERSION,
+        id: input.id ?? 'swarm-event-stream:' + stableHash([input.runId, input.root, laneIds, eventTypes]),
+        ...(input.runId ? { runId: input.runId } : {}),
+        ...(input.root ? { root: input.root } : {}),
+        appendOnly,
+        global,
+        lanes,
+        eventTypes,
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {}),
+        summary: {
+            mailboxCount: 1 + laneIds.length,
+            laneCount: laneIds.length,
+            eventTypeCount: eventTypes.length
+        }
+    };
+}
+export function routeSwarmEventToMailboxes(stream, eventInput) {
+    const event = isSwarmEvent(eventInput) ? eventInput : normalizeEvent(eventInput);
+    const mailboxes = [stream.global];
+    if (event.lane && stream.lanes[event.lane])
+        mailboxes.push(stream.lanes[event.lane]);
+    return mailboxes;
+}
 export function completeSwarmJob(runInput, resultInput) {
     const run = cloneJsonValue(runInput);
     const result = normalizeResult(resultInput);
@@ -197,6 +330,102 @@ export function checkSwarmOwnership(job, changedPaths) {
         violations
     };
 }
+export function resolveSwarmChangedRegions(job, changedPaths) {
+    const changed = uniqueStrings(changedPaths);
+    const regions = new Set(job.changedRegions);
+    for (const region of job.ownershipRegions) {
+        if (region.globs.some((glob) => changed.some((file) => matchesGlob(file, glob))))
+            regions.add(region.id);
+        for (const selector of region.selectors) {
+            if (changed.includes(selector))
+                regions.add(region.id);
+        }
+    }
+    return Array.from(regions).sort();
+}
+export function classifySwarmMergeReadiness(result) {
+    if (result.mergeReadiness)
+        return result.mergeReadiness;
+    if (result.status === 'blocked')
+        return 'blocked';
+    if (result.status === 'failed' || result.exitCode !== undefined && result.exitCode !== 0)
+        return 'rejected';
+    const changedPaths = result.changedPaths ?? [];
+    if (changedPaths.length === 0)
+        return 'discovery-only';
+    const ownershipViolations = result.ownershipViolations ?? [];
+    if (ownershipViolations.length)
+        return 'rejected';
+    const verification = result.verification ?? [];
+    const failedRequired = verification.some((entry) => entry.required !== false && entry.status !== 0);
+    if (failedRequired)
+        return 'patch-candidate';
+    return verification.length > 0 || result.status === 'verified' ? 'verified-patch' : 'patch-candidate';
+}
+export function classifySwarmMergeDisposition(result, input = {}) {
+    if (result.mergeDisposition)
+        return result.mergeDisposition;
+    if (input.staleAgainstHead)
+        return 'stale-against-head';
+    const readiness = classifySwarmMergeReadiness(result);
+    if (readiness === 'discovery-only')
+        return 'discovery-only';
+    if (readiness === 'blocked')
+        return 'blocked';
+    if (readiness === 'rejected')
+        return 'rejected';
+    if (readiness === 'verified-patch')
+        return 'auto-mergeable';
+    return 'needs-port';
+}
+export function createSwarmMergeBundle(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const result = isSwarmJobResult(input.result) ? cloneJsonValue(input.result) : normalizeResult(input.result);
+    const job = input.job;
+    const changedPaths = uniqueStrings(result.changedPaths);
+    const changedRegions = uniqueStrings([
+        ...result.changedRegions,
+        ...(job ? resolveSwarmChangedRegions(job, changedPaths) : [])
+    ]);
+    const evidencePaths = uniqueStrings([...(result.evidencePaths ?? []), ...(input.evidencePaths ?? [])]);
+    const queueItemIds = uniqueStrings([...(result.queueItemIds ?? []), ...(input.queueItemIds ?? []), ...(job ? [job.taskId] : [])]);
+    const disposition = input.disposition ?? classifySwarmMergeDisposition(result, { staleAgainstHead: input.staleAgainstHead });
+    const commandsPassed = result.verification.filter((entry) => entry.status === 0 || entry.required === false && entry.status === undefined);
+    const commandsFailed = result.verification.filter((entry) => entry.status !== undefined && entry.status !== 0 && entry.required !== false);
+    const ownedFilesTouched = job ? changedPaths.filter((file) => job.allowedWrites.some((glob) => matchesGlob(file, glob))) : changedPaths;
+    const reasons = mergeBundleReasons(result, disposition, input.staleAgainstHead ?? false);
+    return {
+        kind: FRONTIER_SWARM_MERGE_BUNDLE_KIND,
+        version: FRONTIER_SWARM_MERGE_BUNDLE_VERSION,
+        id: input.id ?? 'swarm-merge-bundle:' + stableHash([input.runId, input.planId, result.jobId, changedPaths, changedRegions, disposition, generatedAt]),
+        ...(input.runId ? { runId: input.runId } : {}),
+        ...(input.planId ? { planId: input.planId } : {}),
+        jobId: result.jobId,
+        ...(job ? { taskId: job.taskId, lane: job.lane, title: job.title } : {}),
+        generatedAt,
+        status: result.status,
+        mergeReadiness: result.mergeReadiness,
+        disposition,
+        riskLevel: input.riskLevel ?? result.riskLevel ?? inferMergeRisk(result, disposition),
+        autoMergeable: disposition === 'auto-mergeable' && reasons.length === 0,
+        changedPaths,
+        changedRegions,
+        ownedFilesTouched,
+        allowedWrites: job ? [...job.allowedWrites] : [],
+        ownershipViolations: [...result.ownershipViolations],
+        ...(input.patchPath ?? result.patchPath ? { patchPath: input.patchPath ?? result.patchPath } : {}),
+        ...(input.patchHash ? { patchHash: input.patchHash } : {}),
+        evidencePaths,
+        commandsPassed,
+        commandsFailed,
+        queueItemIds,
+        ...(input.branchName ? { branchName: input.branchName } : {}),
+        ...(input.commit ? { commit: input.commit } : {}),
+        staleAgainstHead: input.staleAgainstHead ?? false,
+        reasons,
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
 export function resolveSwarmCompute(manifestInput, taskInput) {
     const compiled = compileSwarm(manifestInput);
     const task = isSwarmTask(taskInput) ? taskInput : normalizeTask(taskInput);
@@ -218,6 +447,304 @@ export function createSwarmProof(input, options = {}) {
         ...(toJsonObject(options.metadata) ? { metadata: toJsonObject(options.metadata) } : {})
     };
 }
+export function createSwarmSchedule(input) {
+    const plan = 'plan' in input ? input.plan : input;
+    const run = 'plan' in input ? input.run : undefined;
+    const createdAt = 'plan' in input ? input.now ?? Date.now() : Date.now();
+    const limits = mergeScheduleLimits(plan.limits, 'plan' in input ? input : {});
+    const resultsByJob = new Map((run?.results ?? []).map((result) => [result.jobId, result]));
+    const completed = new Set();
+    const failed = new Set();
+    for (const result of resultsByJob.values()) {
+        if (result.status === 'completed' || result.status === 'verified')
+            completed.add(result.jobId);
+        if (result.status === 'failed' || result.exitCode !== undefined && result.exitCode !== 0)
+            failed.add(result.jobId);
+    }
+    const runningJobs = (run?.jobs ?? plan.jobs)
+        .filter((job) => job.status === 'running')
+        .map((job) => ({
+        jobId: job.id,
+        lane: job.lane,
+        compute: job.compute.id,
+        concurrencyKey: job.concurrencyKey,
+        capabilities: [...job.capabilities],
+        ...(job.resourceRequirements ? { resourceRequirements: cloneJsonValue(job.resourceRequirements) } : {})
+    }));
+    const runningByLane = countBy(runningJobs.map((job) => job.lane));
+    const runningByKey = countBy(runningJobs.map((job) => job.concurrencyKey));
+    const runningByCompute = countBy(runningJobs.map((job) => job.compute));
+    const ready = [];
+    const blocked = [];
+    const sortedJobs = [...plan.jobs].sort((left, right) => left.priority - right.priority || left.id.localeCompare(right.id));
+    for (const job of sortedJobs) {
+        if (completed.has(job.id) || failed.has(job.id) || runningJobs.some((running) => running.jobId === job.id))
+            continue;
+        const dependencyIds = plan.graph.dependenciesByJobId[job.id] ?? [];
+        const waitingFor = dependencyIds.filter((dep) => !completed.has(dep));
+        const reasons = [];
+        if (waitingFor.length)
+            reasons.push('waiting-for-dependencies');
+        const laneMax = limits.maxLaneConcurrency[job.lane] ?? Number.POSITIVE_INFINITY;
+        const keyMax = limits.maxConcurrencyKeyConcurrency[job.concurrencyKey] ?? Number.POSITIVE_INFINITY;
+        const computeMax = limits.maxComputeConcurrency[job.compute.id] ?? job.compute.maxConcurrency ?? Number.POSITIVE_INFINITY;
+        if ((runningByLane[job.lane] ?? 0) >= laneMax)
+            reasons.push('lane-capacity');
+        if ((runningByKey[job.concurrencyKey] ?? 0) >= keyMax)
+            reasons.push('concurrency-key-capacity');
+        if ((runningByCompute[job.compute.id] ?? 0) >= computeMax)
+            reasons.push('compute-capacity');
+        const scheduled = scheduleJob(job, dependencyIds);
+        if (reasons.length) {
+            blocked.push({ ...scheduled, reasons, waitingFor });
+            continue;
+        }
+        if (limits.maxReadyJobs !== undefined && ready.length >= limits.maxReadyJobs) {
+            blocked.push({ ...scheduled, reasons: ['ready-capacity'], waitingFor: [] });
+            continue;
+        }
+        ready.push(scheduled);
+        runningByLane[job.lane] = (runningByLane[job.lane] ?? 0) + 1;
+        runningByKey[job.concurrencyKey] = (runningByKey[job.concurrencyKey] ?? 0) + 1;
+        runningByCompute[job.compute.id] = (runningByCompute[job.compute.id] ?? 0) + 1;
+    }
+    return {
+        kind: FRONTIER_SWARM_SCHEDULE_KIND,
+        version: FRONTIER_SWARM_SCHEDULE_VERSION,
+        id: 'swarm-schedule:' + stableHash([plan.id, run?.id, ready.map((job) => job.jobId), blocked.map((job) => [job.jobId, job.reasons]), createdAt]),
+        planId: plan.id,
+        ...(run ? { runId: run.id } : {}),
+        createdAt,
+        ready,
+        blocked,
+        running: runningJobs,
+        completed: Array.from(completed).sort(),
+        failed: Array.from(failed).sort(),
+        summary: {
+            jobCount: plan.jobs.length,
+            readyCount: ready.length,
+            blockedCount: blocked.length,
+            runningCount: runningJobs.length,
+            completedCount: completed.size,
+            failedCount: failed.size
+        }
+    };
+}
+export function createSwarmLeases(input) {
+    const now = input.now ?? Date.now();
+    const leaseMs = Math.max(1, Math.floor(input.leaseMs ?? 900000));
+    const activeJobIds = new Set((input.existingLeases ?? []).filter((lease) => lease.status === 'active' && lease.expiresAt > now).map((lease) => lease.jobId));
+    const existingMaxFence = Math.max(0, ...(input.existingLeases ?? []).map((lease) => lease.fencingToken));
+    const count = Math.max(0, Math.floor(input.count ?? input.schedule.ready.length));
+    return input.schedule.ready
+        .filter((job) => !activeJobIds.has(job.jobId))
+        .slice(0, count)
+        .map((job, index) => ({
+        kind: FRONTIER_SWARM_LEASE_KIND,
+        version: FRONTIER_SWARM_LEASE_VERSION,
+        id: 'swarm-lease:' + stableHash([input.schedule.id, job.jobId, input.workerId, now, existingMaxFence + index + 1]),
+        jobId: job.jobId,
+        workerId: input.workerId,
+        token: stableHash([job.jobId, input.workerId, now, existingMaxFence + index + 1]),
+        leasedAt: now,
+        expiresAt: now + leaseMs,
+        fencingToken: existingMaxFence + index + 1,
+        status: 'active'
+    }));
+}
+export function renewSwarmLease(input) {
+    const now = input.now ?? Date.now();
+    const leaseMs = Math.max(1, Math.floor(input.leaseMs ?? Math.max(1, input.lease.expiresAt - input.lease.leasedAt)));
+    return {
+        ...cloneJsonValue(input.lease),
+        leasedAt: now,
+        expiresAt: now + leaseMs,
+        status: input.status ?? 'active'
+    };
+}
+export function createSwarmQueueSnapshot(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const leases = [...(input.leases ?? [])].map((lease) => cloneJsonValue(lease));
+    const jobs = (input.jobs ? input.jobs.map(normalizeQueueJob) : queueJobsFromPlan(input.plan, input.run, leases)).sort((left, right) => (left.priority - right.priority
+        || left.jobId.localeCompare(right.jobId)));
+    const byStatus = groupIds(jobs, (job) => job.status);
+    const byLane = groupIds(jobs, (job) => job.lane ?? 'unassigned');
+    return {
+        kind: FRONTIER_SWARM_QUEUE_SNAPSHOT_KIND,
+        version: FRONTIER_SWARM_QUEUE_SNAPSHOT_VERSION,
+        id: input.id ?? 'swarm-queue-snapshot:' + stableHash([input.plan.id, input.run?.id, jobs, leases, generatedAt]),
+        planId: input.plan.id,
+        runId: input.run?.id ?? input.plan.runId,
+        generatedAt,
+        jobs,
+        byStatus,
+        byLane,
+        leases,
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {}),
+        summary: {
+            jobCount: jobs.length,
+            leaseCount: leases.length,
+            readyCount: byStatus.ready?.length ?? 0,
+            leasedCount: byStatus.leased?.length ?? 0,
+            completedCount: byStatus.completed?.length ?? 0,
+            failedCount: byStatus.failed?.length ?? 0,
+            deadLetterCount: byStatus['dead-letter']?.length ?? 0
+        }
+    };
+}
+export function createSwarmRunCheckpoint(input) {
+    const run = 'kind' in input ? input : input.run;
+    const sequence = 'kind' in input ? run.events.length + run.results.length : input.sequence ?? run.events.length + run.results.length;
+    const savedAt = 'kind' in input ? Date.now() : input.savedAt ?? Date.now();
+    return {
+        kind: FRONTIER_SWARM_RUN_CHECKPOINT_KIND,
+        version: FRONTIER_SWARM_RUN_CHECKPOINT_VERSION,
+        id: 'swarm-run-checkpoint:' + stableHash([run.id, sequence, savedAt, run.summary]),
+        runId: run.id,
+        planId: run.planId,
+        sequence,
+        savedAt,
+        status: run.status,
+        eventCount: run.events.length,
+        resultCount: run.results.length,
+        hash: stableHash(run),
+        ...(!('kind' in input) && toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+export function checkSwarmBudget(job, usageInput) {
+    const usage = normalizeUsage(usageInput);
+    const budget = job.budget;
+    const violations = [];
+    if (budget?.maxCostUsd !== undefined && usage.costUsd > budget.maxCostUsd)
+        violations.push('max-cost-usd');
+    if (budget?.maxInputTokens !== undefined && usage.inputTokens > budget.maxInputTokens)
+        violations.push('max-input-tokens');
+    if (budget?.maxOutputTokens !== undefined && usage.outputTokens > budget.maxOutputTokens)
+        violations.push('max-output-tokens');
+    if (budget?.maxDurationMs !== undefined && usage.durationMs > budget.maxDurationMs)
+        violations.push('max-duration-ms');
+    if (budget && usage.attempts > budget.maxRetries + 1)
+        violations.push('max-retries');
+    return { ok: violations.length === 0, jobId: job.id, usage, ...(budget ? { budget } : {}), violations };
+}
+export function createSwarmArtifactIndex(input) {
+    const run = 'kind' in input ? input : input.run;
+    const generatedAt = 'kind' in input ? Date.now() : input.generatedAt ?? Date.now();
+    const explicit = 'kind' in input ? [] : input.artifacts ?? [];
+    const artifacts = [
+        ...(run?.results ?? []).flatMap((result) => result.evidencePaths.map((evidencePath) => normalizeArtifact({ jobId: result.jobId, path: evidencePath, kind: 'evidence' }))),
+        ...explicit.map(normalizeArtifact)
+    ].sort((left, right) => left.jobId.localeCompare(right.jobId) || left.path.localeCompare(right.path));
+    const byJobId = groupArtifacts(artifacts, (artifact) => artifact.jobId);
+    const byKind = groupArtifacts(artifacts, (artifact) => artifact.kind);
+    return {
+        kind: FRONTIER_SWARM_ARTIFACT_INDEX_KIND,
+        version: FRONTIER_SWARM_ARTIFACT_INDEX_VERSION,
+        id: 'swarm-artifact-index:' + stableHash([artifacts, generatedAt]),
+        generatedAt,
+        artifacts,
+        byJobId,
+        byKind,
+        summary: {
+            artifactCount: artifacts.length,
+            jobCount: Object.keys(byJobId).length,
+            kindCount: Object.keys(byKind).length,
+            totalBytes: artifacts.reduce((total, artifact) => total + (artifact.bytes ?? 0), 0)
+        }
+    };
+}
+export function createSwarmReviewPlan(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const resultsByJob = new Map((input.run?.results ?? []).map((result) => [result.jobId, result]));
+    const budgetsByJob = new Map((input.budgetDecisions ?? []).map((decision) => [decision.jobId, decision]));
+    const assignments = [];
+    for (const job of input.plan.jobs) {
+        const result = resultsByJob.get(job.id);
+        const budget = budgetsByJob.get(job.id);
+        const reason = reviewReason(job, result, budget, input.sampleSalt ?? input.plan.id);
+        if (!reason)
+            continue;
+        const pool = job.review.reviewerPool.length ? job.review.reviewerPool : [...(input.reviewers ?? [])];
+        assignments.push({
+            jobId: job.id,
+            taskId: job.taskId,
+            reviewers: selectReviewers(pool, job.review.requiredReviewers, job.id),
+            required: job.review.alwaysReview || reason === 'violations' || reason === 'failed' || reason === 'budget',
+            reason
+        });
+    }
+    return {
+        kind: FRONTIER_SWARM_REVIEW_PLAN_KIND,
+        version: FRONTIER_SWARM_REVIEW_PLAN_VERSION,
+        id: 'swarm-review-plan:' + stableHash([input.plan.id, assignments, generatedAt]),
+        planId: input.plan.id,
+        generatedAt,
+        assignments,
+        summary: {
+            assignmentCount: assignments.length,
+            requiredCount: assignments.filter((assignment) => assignment.required).length,
+            sampledCount: assignments.filter((assignment) => assignment.reason === 'sampled').length
+        }
+    };
+}
+export function createSwarmMergePlan(input) {
+    const generatedAt = input.generatedAt ?? Date.now();
+    const resultsByJob = new Map(input.run.results.map((result) => [result.jobId, result]));
+    const reviewRequired = new Set((input.reviewPlan?.assignments ?? []).filter((assignment) => assignment.required).map((assignment) => assignment.jobId));
+    const conflicts = conflictMap(input.run.results);
+    const ready = [];
+    const blocked = [];
+    for (const job of input.plan.jobs) {
+        const result = resultsByJob.get(job.id);
+        const reasons = [];
+        if (!result || result.status !== 'completed' && result.status !== 'verified')
+            reasons.push('not-completed');
+        if (result?.ownershipViolations.length)
+            reasons.push('ownership-violations');
+        if (reviewRequired.has(job.id))
+            reasons.push('review-required');
+        const conflictingJobIds = Array.from(conflicts.get(job.id) ?? []).sort();
+        if (conflictingJobIds.length)
+            reasons.push('conflicting-changes');
+        if (reasons.length)
+            blocked.push({ jobId: job.id, reasons: uniqueStrings(reasons), conflictingJobIds });
+        else
+            ready.push(job.id);
+    }
+    const groups = groupMergeReadyJobs(ready, input.run.results);
+    return {
+        kind: FRONTIER_SWARM_MERGE_PLAN_KIND,
+        version: FRONTIER_SWARM_MERGE_PLAN_VERSION,
+        id: 'swarm-merge-plan:' + stableHash([input.plan.id, ready, blocked, generatedAt]),
+        planId: input.plan.id,
+        generatedAt,
+        ready,
+        blocked,
+        groups,
+        summary: { readyCount: ready.length, blockedCount: blocked.length, groupCount: groups.length }
+    };
+}
+export function decomposeSwarmFeature(input) {
+    const filesByLane = new Map();
+    const lanes = input.lanes.length ? [...input.lanes] : ['implementation'];
+    for (const lane of lanes)
+        filesByLane.set(lane, []);
+    for (const file of input.files ?? []) {
+        const selected = lanes.find((lane) => file.toLowerCase().includes(lane.toLowerCase())) ?? lanes[filesByLane.size ? stableHash(file).charCodeAt(10) % lanes.length : 0];
+        filesByLane.get(selected)?.push(file);
+    }
+    return lanes.map((lane, index) => ({
+        id: `${input.featureId}-${slug(lane)}`,
+        lane,
+        title: `${titleFromId(lane)} for ${input.featureId}`,
+        objective: input.objective,
+        priority: 100 + index,
+        targetRefs: filesByLane.get(lane) ?? [],
+        verification: input.checks ?? [],
+        review: input.reviewers?.length ? { requiredReviewers: 1, reviewerPool: input.reviewers } : undefined,
+        metadata: toJsonObject(input.metadata)
+    }));
+}
 export function encodeSwarmJsonl(records) {
     return records.map((record) => JSON.stringify(record)).join('\n') + (records.length ? '\n' : '');
 }
@@ -232,6 +759,231 @@ export function matchesGlob(file, glob) {
         .replace(/\u0000/g, '.*');
     return new RegExp('^' + escaped + '$').test(file);
 }
+function createSwarmJobGraph(jobs) {
+    const nodes = jobs.map((job) => job.id).sort();
+    const nodeSet = new Set(nodes);
+    const taskToJob = new Map(jobs.map((job) => [job.taskId, job.id]));
+    const edges = [];
+    const issues = [];
+    for (const job of jobs) {
+        for (const rawDep of job.dependsOn) {
+            const dep = nodeSet.has(rawDep) ? rawDep : taskToJob.get(rawDep);
+            if (!dep) {
+                addIssue(issues, 'missing-job-dependency', 'error', `jobs.${job.id}.dependsOn`, `Job dependency is not in this plan: ${rawDep}`);
+                continue;
+            }
+            if (dep === job.id) {
+                addIssue(issues, 'self-job-dependency', 'error', `jobs.${job.id}.dependsOn`, `Job cannot depend on itself: ${job.id}`);
+                continue;
+            }
+            edges.push({ from: dep, to: job.id, type: 'depends-on' });
+        }
+    }
+    const dependenciesByJobId = Object.fromEntries(nodes.map((node) => [node, []]));
+    const dependentsByJobId = Object.fromEntries(nodes.map((node) => [node, []]));
+    for (const edge of edges) {
+        dependenciesByJobId[edge.to]?.push(edge.from);
+        dependentsByJobId[edge.from]?.push(edge.to);
+    }
+    for (const key of nodes) {
+        dependenciesByJobId[key] = uniqueStrings(dependenciesByJobId[key] ?? []).sort();
+        dependentsByJobId[key] = uniqueStrings(dependentsByJobId[key] ?? []).sort();
+        if (hasJobDependencyCycle(key, dependenciesByJobId)) {
+            addIssue(issues, 'job-dependency-cycle', 'error', `jobs.${key}.dependsOn`, `Job dependency graph contains a cycle at ${key}`);
+        }
+    }
+    return {
+        nodes,
+        edges: edges.sort((left, right) => left.from.localeCompare(right.from) || left.to.localeCompare(right.to)),
+        dependentsByJobId,
+        dependenciesByJobId,
+        roots: nodes.filter((node) => dependenciesByJobId[node]?.length === 0),
+        leaves: nodes.filter((node) => dependentsByJobId[node]?.length === 0),
+        issues
+    };
+}
+function normalizeScheduleLimits(manifest, options) {
+    const maxLaneConcurrency = {};
+    for (const lane of manifest.lanes) {
+        const browserMax = lane.resourceRequirements?.browser?.maxConcurrency;
+        const value = options.maxLaneConcurrency?.[lane.id] ?? lane.maxConcurrency ?? browserMax ?? manifest.policy.defaultConcurrency;
+        maxLaneConcurrency[lane.id] = Math.max(1, Math.floor(value));
+    }
+    return {
+        ...(positiveNumber(options.maxReadyJobs) ? { maxReadyJobs: Math.floor(options.maxReadyJobs) } : {}),
+        maxLaneConcurrency: { ...maxLaneConcurrency, ...(options.maxLaneConcurrency ?? {}) },
+        maxConcurrencyKeyConcurrency: { ...(options.maxConcurrencyKeyConcurrency ?? {}) },
+        maxComputeConcurrency: { ...(options.maxComputeConcurrency ?? {}) }
+    };
+}
+function mergeScheduleLimits(base, override) {
+    return {
+        maxReadyJobs: positiveNumber(override.maxReadyJobs) ? Math.floor(override.maxReadyJobs) : base.maxReadyJobs,
+        maxLaneConcurrency: { ...base.maxLaneConcurrency, ...(override.maxLaneConcurrency ?? {}) },
+        maxConcurrencyKeyConcurrency: { ...base.maxConcurrencyKeyConcurrency, ...(override.maxConcurrencyKeyConcurrency ?? {}) },
+        maxComputeConcurrency: { ...base.maxComputeConcurrency, ...(override.maxComputeConcurrency ?? {}) }
+    };
+}
+function scheduleJob(job, dependsOn = job.dependsOn) {
+    return {
+        jobId: job.id,
+        taskId: job.taskId,
+        lane: job.lane,
+        compute: job.compute.id,
+        concurrencyKey: job.concurrencyKey,
+        priority: job.priority,
+        dependsOn: [...dependsOn],
+        capabilities: [...job.capabilities],
+        ...(job.resourceRequirements ? { resourceRequirements: cloneJsonValue(job.resourceRequirements) } : {})
+    };
+}
+function normalizeBudget(input = {}) {
+    return {
+        ...(positiveNumber(input.maxCostUsd) ? { maxCostUsd: input.maxCostUsd } : {}),
+        ...(positiveNumber(input.maxInputTokens) ? { maxInputTokens: Math.floor(input.maxInputTokens) } : {}),
+        ...(positiveNumber(input.maxOutputTokens) ? { maxOutputTokens: Math.floor(input.maxOutputTokens) } : {}),
+        ...(positiveNumber(input.maxDurationMs) ? { maxDurationMs: Math.floor(input.maxDurationMs) } : {}),
+        maxRetries: Math.max(0, Math.floor(input.maxRetries ?? 0)),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeUsage(input) {
+    return {
+        costUsd: Math.max(0, input.costUsd ?? 0),
+        inputTokens: Math.max(0, Math.floor(input.inputTokens ?? 0)),
+        outputTokens: Math.max(0, Math.floor(input.outputTokens ?? 0)),
+        durationMs: Math.max(0, Math.floor(input.durationMs ?? 0)),
+        attempts: Math.max(1, Math.floor(input.attempts ?? 1)),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeReviewPolicy(input = {}) {
+    const sampleRate = typeof input.sampleRate === 'number' && Number.isFinite(input.sampleRate)
+        ? Math.min(1, Math.max(0, input.sampleRate))
+        : 0;
+    return {
+        requiredReviewers: Math.max(0, Math.floor(input.requiredReviewers ?? 0)),
+        sampleRate,
+        alwaysReview: input.alwaysReview ?? false,
+        reviewerPool: uniqueStrings(input.reviewerPool ?? []),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeArtifact(input) {
+    return {
+        jobId: normalizeId(input.jobId, 'artifact job id'),
+        path: normalizeId(input.path, 'artifact path'),
+        kind: input.kind ?? 'artifact',
+        ...(positiveNumber(input.bytes) ? { bytes: Math.floor(input.bytes) } : {}),
+        ...(input.hash ? { hash: input.hash } : {}),
+        ...(input.producedAt !== undefined ? { producedAt: input.producedAt } : {}),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function reviewReason(job, result, budget, sampleSalt) {
+    if (result?.ownershipViolations.length)
+        return 'violations';
+    if (result?.status === 'failed' || result?.exitCode !== undefined && result.exitCode !== 0)
+        return 'failed';
+    if (budget && !budget.ok)
+        return 'budget';
+    if (job.review.alwaysReview)
+        return 'always-review';
+    if (job.review.sampleRate > 0 && deterministicUnitInterval([sampleSalt, job.id]) < job.review.sampleRate)
+        return 'sampled';
+    return undefined;
+}
+function selectReviewers(pool, required, salt) {
+    if (required <= 0 || pool.length === 0)
+        return [];
+    const sorted = [...uniqueStrings(pool)].sort((left, right) => stableHash([salt, left]).localeCompare(stableHash([salt, right])));
+    return sorted.slice(0, Math.min(required, sorted.length));
+}
+function conflictMap(results) {
+    const byPath = new Map();
+    for (const result of results) {
+        const keys = result.changedRegions.length
+            ? result.changedRegions.map((region) => `region:${region}`)
+            : result.changedPaths.map((file) => `file:${file}`);
+        for (const key of keys) {
+            const list = byPath.get(key) ?? [];
+            list.push(result.jobId);
+            byPath.set(key, list);
+        }
+    }
+    const conflicts = new Map();
+    for (const jobIds of byPath.values()) {
+        if (jobIds.length < 2)
+            continue;
+        for (const jobId of jobIds) {
+            const set = conflicts.get(jobId) ?? new Set();
+            for (const other of jobIds) {
+                if (other !== jobId)
+                    set.add(other);
+            }
+            conflicts.set(jobId, set);
+        }
+    }
+    return conflicts;
+}
+function groupMergeReadyJobs(ready, results) {
+    const byJob = new Map(results.map((result) => [result.jobId, result]));
+    return ready.map((jobId) => {
+        const changedPaths = [...(byJob.get(jobId)?.changedPaths ?? [])].sort();
+        return {
+            id: 'merge-group:' + stableHash([jobId, changedPaths]),
+            jobIds: [jobId],
+            changedPaths
+        };
+    });
+}
+function groupArtifacts(artifacts, key) {
+    const out = {};
+    for (const artifact of artifacts) {
+        const group = key(artifact);
+        out[group] = [...(out[group] ?? []), artifact];
+    }
+    return out;
+}
+function groupIds(items, key) {
+    const out = {};
+    for (const item of items) {
+        const group = key(item);
+        out[group] = [...(out[group] ?? []), item.jobId];
+    }
+    for (const ids of Object.values(out))
+        ids.sort();
+    return out;
+}
+function countBy(values) {
+    const out = {};
+    for (const value of values)
+        out[value] = (out[value] ?? 0) + 1;
+    return out;
+}
+function hasJobDependencyCycle(start, dependenciesByJobId) {
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (node) => {
+        if (visiting.has(node))
+            return true;
+        if (visited.has(node))
+            return false;
+        visiting.add(node);
+        for (const dep of dependenciesByJobId[node] ?? []) {
+            if (visit(dep))
+                return true;
+        }
+        visiting.delete(node);
+        visited.add(node);
+        return false;
+    };
+    return visit(start);
+}
+function deterministicUnitInterval(value) {
+    const hex = stableHash(value).split(':')[1] ?? '0';
+    return parseInt(hex, 16) / 0xffffffff;
+}
 function normalizeComputeList(input) {
     const values = input && input.length > 0 ? input : [{
             id: FRONTIER_SWARM_DEFAULT_CODEX_COMPUTE_ID,
@@ -278,6 +1030,9 @@ function normalizeLane(input) {
         allowedWrites,
         sharedReadOnly: uniqueStrings(input.sharedReadOnly ?? []),
         neverEdit: uniqueStrings(input.neverEdit ?? []),
+        ownershipRegions: normalizeOwnershipRegions(input.ownershipRegions ?? []),
+        capabilities: uniqueStrings(input.capabilities ?? []),
+        ...(input.resourceRequirements ? { resourceRequirements: normalizeResourceRequirements(input.resourceRequirements) } : {}),
         ...(input.worktreePath ? { worktreePath: input.worktreePath } : {}),
         ...(input.evidencePrefix || input.evidenceOutDirPrefix ? { evidencePrefix: input.evidencePrefix ?? input.evidenceOutDirPrefix } : {}),
         concurrencyKey: input.concurrencyKey ?? input.id,
@@ -287,6 +1042,68 @@ function normalizeLane(input) {
         ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
     };
 }
+function normalizeOwnershipRegions(input = []) {
+    return input.map((region) => {
+        const globs = uniqueStrings([...(region.globs ?? []), ...(region.paths ?? [])]);
+        return {
+            id: normalizeId(region.id, 'ownership region id'),
+            title: region.title ?? titleFromId(region.id),
+            ...(region.description ? { description: region.description } : {}),
+            globs,
+            selectors: uniqueStrings(region.selectors ?? []),
+            ...(region.owner ? { owner: region.owner } : {}),
+            ...(toJsonObject(region.metadata) ? { metadata: toJsonObject(region.metadata) } : {})
+        };
+    });
+}
+function mergeOwnershipRegions(laneRegions, taskRegions) {
+    const byId = new Map();
+    for (const region of laneRegions)
+        byId.set(region.id, cloneJsonValue(region));
+    for (const region of taskRegions)
+        byId.set(region.id, cloneJsonValue(region));
+    return Array.from(byId.values()).sort((left, right) => left.id.localeCompare(right.id));
+}
+function normalizeResourceRequirements(input = {}) {
+    const resources = {};
+    for (const [key, value] of Object.entries(input.resources ?? {})) {
+        if (Number.isFinite(value) && value > 0)
+            resources[key] = value;
+    }
+    return {
+        capabilities: uniqueStrings(input.capabilities ?? []),
+        resources,
+        ...(input.browser ? { browser: normalizeBrowserResource(input.browser) } : {}),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function normalizeBrowserResource(input) {
+    return {
+        required: input.required ?? true,
+        portPool: uniqueStrings((input.portPool ?? []).map((port) => String(port))),
+        ...(input.profileDir ? { profileDir: input.profileDir } : {}),
+        ...(input.profileDirPrefix ? { profileDirPrefix: input.profileDirPrefix } : {}),
+        ...(positiveNumber(input.maxConcurrency) ? { maxConcurrency: Math.floor(input.maxConcurrency) } : {}),
+        ...(input.headless !== undefined ? { headless: input.headless } : {}),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function mergeResourceRequirements(lane, task, extraCapabilities = []) {
+    if (!lane && !task && extraCapabilities.length === 0)
+        return undefined;
+    const capabilities = uniqueStrings([...(lane?.capabilities ?? []), ...(task?.capabilities ?? []), ...extraCapabilities]);
+    const resources = { ...(lane?.resources ?? {}) };
+    for (const [key, value] of Object.entries(task?.resources ?? {}))
+        resources[key] = Math.max(resources[key] ?? 0, value);
+    const browser = task?.browser ?? lane?.browser;
+    const metadata = toJsonObject({ ...(lane?.metadata ?? {}), ...(task?.metadata ?? {}) });
+    return {
+        capabilities,
+        resources,
+        ...(browser ? { browser } : {}),
+        ...(metadata && Object.keys(metadata).length ? { metadata } : {})
+    };
+}
 function normalizePolicy(input, defaultCompute) {
     return {
         mode: input?.mode ?? 'hard-file-ownership',
@@ -315,10 +1132,19 @@ function normalizeTask(input) {
         ...(input.layer ? { layer: input.layer } : {}),
         ...(input.compute ? { compute: input.compute } : {}),
         ...(input.parentTaskId ? { parentTaskId: input.parentTaskId } : {}),
+        dependsOn: uniqueStrings(input.dependsOn ?? []),
+        ...(input.concurrencyKey ? { concurrencyKey: input.concurrencyKey } : {}),
+        ...(input.budget ? { budget: normalizeBudget(input.budget) } : {}),
+        ...(input.review ? { review: normalizeReviewPolicy(input.review) } : {}),
         priority: Number.isFinite(input.priority) ? Number(input.priority) : 100,
         sourceRefs: uniqueStrings(input.sourceRefs ?? []),
         targetRefs,
         allowedWrites: uniqueStrings([...(input.allowedWrites ?? []), ...targetRefs]),
+        ownershipRegions: normalizeOwnershipRegions(input.ownershipRegions ?? []),
+        ownedRegions: uniqueStrings(input.ownedRegions ?? []),
+        changedRegions: uniqueStrings(input.changedRegions ?? []),
+        capabilities: uniqueStrings(input.capabilities ?? []),
+        ...(input.resourceRequirements ? { resourceRequirements: normalizeResourceRequirements(input.resourceRequirements) } : {}),
         acceptance: normalizeAcceptance(input),
         verification: normalizeCommands(input.verification ?? []),
         ...(input.evidenceCommand ? { evidenceCommand: input.evidenceCommand } : {}),
@@ -368,6 +1194,55 @@ function selectSwarmTasks(manifest, tasks, options) {
         .sort((left, right) => left.priority - right.priority || left.id.localeCompare(right.id))
         .slice(0, limit);
 }
+function createSelectionEntry(manifest, task, priority) {
+    const lane = task.lane ? manifest.lanes.find((entry) => entry.id === task.lane) : undefined;
+    return {
+        task,
+        ...(lane ? { lane } : {}),
+        ownershipWarnings: selectionOwnershipWarnings(task, lane),
+        selectionPriority: selectionPriority(task, priority)
+    };
+}
+function selectionOwnershipWarnings(task, lane) {
+    if (!lane || lane.allowedWrites.length === 0)
+        return [];
+    return task.targetRefs
+        .filter((file) => !lane.allowedWrites.some((glob) => matchesGlob(file, glob)))
+        .map((file) => `${file} is outside allowed write globs for ${lane.id}`);
+}
+function selectionPriority(task, input) {
+    const statusRanks = input?.statuses ?? {};
+    const workKindRanks = input?.workKinds ?? {};
+    const statusRank = statusRanks[task.status] ?? input?.defaultStatusRank ?? 100;
+    const workKindRank = workKindRanks[task.workKind] ?? input?.defaultWorkKindRank ?? 100;
+    const statusWeight = input?.statusWeight ?? 1000;
+    const workKindWeight = input?.workKindWeight ?? 1;
+    return statusRank * statusWeight + workKindRank * workKindWeight;
+}
+function roundRobinSelectionByLane(entries) {
+    const groups = new Map();
+    for (const entry of entries)
+        groups.set(entry.task.lane ?? 'unassigned', [...(groups.get(entry.task.lane ?? 'unassigned') ?? []), entry]);
+    const selected = [];
+    while (Array.from(groups.values()).some((group) => group.length > 0)) {
+        for (const group of groups.values()) {
+            const next = group.shift();
+            if (next)
+                selected.push(next);
+        }
+    }
+    return selected;
+}
+function summarizeTaskSelection(entries) {
+    return entries.reduce((summary, entry) => {
+        const lane = entry.task.lane ?? 'unassigned';
+        summary.total += 1;
+        summary.byLane[lane] = (summary.byLane[lane] ?? 0) + 1;
+        summary.byWorkKind[entry.task.workKind] = (summary.byWorkKind[entry.task.workKind] ?? 0) + 1;
+        summary.ownershipWarningCount += entry.ownershipWarnings.length;
+        return summary;
+    }, { total: 0, byLane: {}, byWorkKind: {}, ownershipWarningCount: 0 });
+}
 function createJob(compiled, task, options) {
     const lane = task.lane ? compiled.lanesById.get(task.lane) : undefined;
     const layer = task.layer ?? lane?.layer ?? compiled.manifest.policy.defaultLayer;
@@ -383,6 +1258,10 @@ function createJob(compiled, task, options) {
     const ownershipWarnings = task.targetRefs
         .filter((file) => allowedWrites.length > 0 && !allowedWrites.some((glob) => matchesGlob(file, glob)))
         .map((file) => `${file} is outside allowed write globs for ${lane?.id ?? 'unassigned'}`);
+    const capabilities = uniqueStrings([...(lane?.capabilities ?? []), ...task.capabilities]);
+    const resourceRequirements = mergeResourceRequirements(lane?.resourceRequirements, task.resourceRequirements, capabilities);
+    const ownershipRegions = mergeOwnershipRegions(lane?.ownershipRegions ?? [], task.ownershipRegions);
+    const ownedRegions = uniqueStrings([...task.ownedRegions, ...ownershipRegions.map((region) => region.id)]);
     return {
         id: `${lane?.id ?? 'unassigned'}-${slug(task.id)}`,
         taskId: task.id,
@@ -396,16 +1275,30 @@ function createJob(compiled, task, options) {
         allowedWrites,
         sharedReadOnly: uniqueStrings([...(compiled.manifest.policy.sharedReadOnly ?? []), ...(lane?.sharedReadOnly ?? [])]),
         neverEdit: uniqueStrings([...(compiled.manifest.policy.neverEditWithoutParent ?? []), ...(lane?.neverEdit ?? [])]),
+        ownershipRegions,
+        ownedRegions,
+        changedRegions: uniqueStrings(task.changedRegions),
+        capabilities,
+        ...(resourceRequirements ? { resourceRequirements } : {}),
         ...(lane?.worktreePath ? { worktreePath: lane.worktreePath } : {}),
         ...(evidencePrefix ? { evidencePrefix } : {}),
-        concurrencyKey: lane?.concurrencyKey ?? task.lane ?? compute.id,
+        concurrencyKey: task.concurrencyKey ?? lane?.concurrencyKey ?? task.lane ?? compute.id,
         ownershipWarnings,
         verification: task.verification.length ? task.verification : (lane?.handoffCommands ?? []),
         acceptance: [...task.acceptance],
+        dependsOn: resolveJobDependencies(task),
+        ...(task.budget ? { budget: task.budget } : {}),
+        review: task.review ?? normalizeReviewPolicy(),
         tags: uniqueStrings([...task.tags, ...(lane?.tags ?? []), ...(layer ? [layer] : []), compute.id]),
         ...(task.metadata ? { metadata: task.metadata } : {})
     };
 }
+function resolveJobDependencies(task) {
+    return uniqueStrings([
+        ...(task.parentTaskId ? [task.parentTaskId] : []),
+        ...task.dependsOn
+    ]);
+}
 function resolveTaskCompute(compiled, task) {
     if (task.compute)
         return readCompute(compiled, task.compute);
@@ -438,8 +1331,9 @@ function resolveLayerCompute(compiled, layerId) {
 function readCompute(compiled, id) {
     return compiled.computeById.get(id) ?? compiled.computeById.get(compiled.manifest.policy.defaultCompute) ?? compiled.manifest.compute[0];
 }
-function validateTasksForManifest(compiled, tasks) {
-    const issues = [...compiled.validation.issues];
+function validateTasksForManifest(compiled, tasks, graph) {
+    const issues = [...compiled.validation.issues, ...(graph?.issues ?? [])];
+    const taskIds = new Set(tasks.map((task) => task.id));
     for (const task of tasks) {
         if (task.lane && !compiled.lanesById.has(task.lane)) {
             addIssue(issues, 'missing-task-lane', 'error', `tasks.${task.id}.lane`, `Task lane is not declared: ${task.lane}`);
@@ -450,6 +1344,14 @@ function validateTasksForManifest(compiled, tasks) {
         if (task.compute && !compiled.computeById.has(task.compute)) {
             addIssue(issues, 'missing-task-compute', 'error', `tasks.${task.id}.compute`, `Task compute is not declared: ${task.compute}`);
         }
+        for (const dependency of task.dependsOn) {
+            if (!taskIds.has(dependency)) {
+                addIssue(issues, 'missing-task-dependency', 'warning', `tasks.${task.id}.dependsOn`, `Task dependency is not declared in the task set: ${dependency}`);
+            }
+        }
+        if (task.parentTaskId && !taskIds.has(task.parentTaskId)) {
+            addIssue(issues, 'missing-parent-task', 'warning', `tasks.${task.id}.parentTaskId`, `Task parent is not declared in the task set: ${task.parentTaskId}`);
+        }
     }
     return { valid: issues.every((issue) => issue.severity !== 'error'), issues };
 }
@@ -472,26 +1374,121 @@ function normalizeEvent(input) {
         ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
     };
 }
+function normalizeQueueJob(input) {
+    return {
+        jobId: input.jobId,
+        ...(input.taskId ? { taskId: input.taskId } : {}),
+        ...(input.runId ? { runId: input.runId } : {}),
+        status: input.status ?? 'ready',
+        ...(input.lane ? { lane: input.lane } : {}),
+        ...(input.compute ? { compute: input.compute } : {}),
+        ...(input.concurrencyKey ? { concurrencyKey: input.concurrencyKey } : {}),
+        priority: input.priority ?? 100,
+        attempts: Math.max(0, Math.floor(input.attempts ?? 0)),
+        maxAttempts: Math.max(1, Math.floor(input.maxAttempts ?? 1)),
+        ...(input.availableAt !== undefined ? { availableAt: input.availableAt } : {}),
+        ...(input.lease ? { lease: cloneJsonValue(input.lease) } : {}),
+        ...(input.lastError ? { lastError: input.lastError } : {}),
+        ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
+    };
+}
+function queueJobsFromPlan(plan, run, leases) {
+    const resultsByJob = new Map((run?.results ?? []).map((result) => [result.jobId, result]));
+    const activeLeases = new Map(leases.filter((lease) => lease.status === 'active').map((lease) => [lease.jobId, lease]));
+    return plan.jobs.map((job) => {
+        const result = resultsByJob.get(job.id);
+        const lease = activeLeases.get(job.id);
+        const failed = result?.status === 'failed' || result?.exitCode !== undefined && result.exitCode !== 0;
+        const completed = result?.status === 'completed' || result?.status === 'verified';
+        const status = completed
+            ? 'completed'
+            : failed
+                ? 'failed'
+                : lease
+                    ? 'leased'
+                    : job.status === 'running'
+                        ? 'running'
+                        : 'ready';
+        return normalizeQueueJob({
+            jobId: job.id,
+            taskId: job.taskId,
+            runId: run?.id ?? plan.runId,
+            status,
+            lane: job.lane,
+            compute: job.compute.id,
+            concurrencyKey: job.concurrencyKey,
+            priority: job.priority,
+            attempts: result?.metadata && typeof result.metadata.attempts === 'number' ? result.metadata.attempts : undefined,
+            maxAttempts: job.budget?.maxRetries !== undefined ? job.budget.maxRetries + 1 : 1,
+            lease,
+            lastError: result?.error
+        });
+    });
+}
 function normalizeResult(input) {
     const startedAt = input.startedAt;
     const finishedAt = input.finishedAt;
+    const status = input.status ?? (input.exitCode === 0 || input.exitCode === undefined ? 'completed' : 'failed');
     return {
         jobId: input.jobId,
-        status: input.status ?? (input.exitCode === 0 || input.exitCode === undefined ? 'completed' : 'failed'),
+        status,
+        mergeReadiness: classifySwarmMergeReadiness({ ...input, status }),
         ...(startedAt !== undefined ? { startedAt } : {}),
         ...(finishedAt !== undefined ? { finishedAt } : {}),
         ...(startedAt !== undefined && finishedAt !== undefined ? { durationMs: Math.max(0, finishedAt - startedAt) } : {}),
         ...(input.exitCode !== undefined ? { exitCode: input.exitCode } : {}),
         ...(input.signal ? { signal: input.signal } : {}),
         changedPaths: uniqueStrings(input.changedPaths ?? []),
+        changedRegions: uniqueStrings(input.changedRegions ?? []),
         ownershipViolations: uniqueStrings(input.ownershipViolations ?? []),
         evidencePaths: uniqueStrings(input.evidencePaths ?? []),
+        ...(input.patchPath ? { patchPath: input.patchPath } : {}),
+        queueItemIds: uniqueStrings(input.queueItemIds ?? []),
+        riskLevel: input.riskLevel ?? 'unknown',
+        mergeDisposition: input.mergeDisposition ?? classifySwarmMergeDisposition({ ...input, status }),
         verification: (input.verification ?? []).map(normalizeVerificationResult),
         ...(input.lastMessage ? { lastMessage: input.lastMessage } : {}),
         ...(input.error !== undefined ? { error: stringifyError(input.error) } : {}),
         ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
     };
 }
+function isSwarmJobResult(value) {
+    return Array.isArray(value.changedPaths)
+        && Array.isArray(value.changedRegions)
+        && Array.isArray(value.verification)
+        && Array.isArray(value.queueItemIds)
+        && typeof value.riskLevel === 'string'
+        && typeof value.mergeDisposition === 'string';
+}
+function mergeBundleReasons(result, disposition, staleAgainstHead) {
+    const reasons = [];
+    if (staleAgainstHead)
+        reasons.push('stale-against-head');
+    if (result.status === 'blocked')
+        reasons.push('blocked');
+    if (result.status === 'failed')
+        reasons.push('failed');
+    if (result.ownershipViolations.length)
+        reasons.push('ownership-violations');
+    if (result.verification.some((entry) => entry.required !== false && entry.status !== 0))
+        reasons.push('failed-verification');
+    if (disposition === 'needs-port')
+        reasons.push('needs-human-port');
+    if (disposition === 'rejected')
+        reasons.push('rejected');
+    return uniqueStrings(reasons);
+}
+function inferMergeRisk(result, disposition) {
+    if (disposition === 'discovery-only')
+        return 'low';
+    if (disposition === 'rejected' || disposition === 'blocked' || disposition === 'stale-against-head')
+        return 'high';
+    if (result.changedPaths.length <= 2 && result.ownershipViolations.length === 0)
+        return 'low';
+    if (result.changedPaths.length <= 8)
+        return 'medium';
+    return 'high';
+}
 function normalizeVerificationResult(input) {
     return {
         name: input.name ?? ((input.command ?? []).join(' ') || 'verification'),
@@ -567,6 +1564,20 @@ function isSwarmManifest(value) {
 function isSwarmTask(value) {
     return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_TASK_KIND;
 }
+function isSwarmEvent(value) {
+    return !!value && typeof value === 'object' && value.kind === FRONTIER_SWARM_EVENT_KIND;
+}
+function readLaneId(value) {
+    return typeof value === 'string' ? value : value.id;
+}
+function joinPathParts(...parts) {
+    const first = parts[0] ? String(parts[0]) : '';
+    const prefix = first.startsWith('/') ? '/' : '';
+    return prefix + parts
+        .map((part, index) => String(part).replace(index === 0 ? /\/+$/g : /^\/+|\/+$/g, ''))
+        .filter(Boolean)
+        .join('/');
+}
 function normalizeId(value, label) {
     const id = String(value || '').trim();
     if (!id)