iosm-cli 0.1.3 → 0.2.1

package/dist/core/swarm/retry.d.ts

@@ -0,0 +1,16 @@
+export type SwarmRetryBucket = "permission" | "dependency_import" | "test" | "timeout" | "unknown";
+export interface SwarmRetryPolicy {
+    maxByBucket: Record<SwarmRetryBucket, number>;
+}
+export declare const DEFAULT_RETRY_POLICY: SwarmRetryPolicy;
+export declare function classifyRetryBucket(errorMessage: string): SwarmRetryBucket;
+export declare function shouldRetry(input: {
+    errorMessage: string;
+    currentRetries: number;
+    policy?: SwarmRetryPolicy;
+}): {
+    retry: boolean;
+    bucket: SwarmRetryBucket;
+    max: number;
+};
+//# sourceMappingURL=retry.d.ts.map

package/dist/core/swarm/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/core/swarm/retry.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG,mBAAmB,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;AAEnG,MAAM,WAAW,gBAAgB;IAChC,WAAW,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;CAC9C;AAED,eAAO,MAAM,oBAAoB,EAAE,gBAQlC,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,gBAAgB,CAO1E;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,gBAAgB,CAAC;CAC1B,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,gBAAgB,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAS5D"}

package/dist/core/swarm/retry.js

@@ -0,0 +1,32 @@
+export const DEFAULT_RETRY_POLICY = {
+    maxByBucket: {
+        permission: 1,
+        dependency_import: 2,
+        test: 2,
+        timeout: 2,
+        unknown: 1,
+    },
+};
+export function classifyRetryBucket(errorMessage) {
+    const msg = errorMessage.toLowerCase();
+    if (/(permission|denied|not allowed|forbidden|eacces|eprem)/.test(msg))
+        return "permission";
+    if (/(module not found|cannot find module|importerror|dependency|package)/.test(msg))
+        return "dependency_import";
+    if (/(test failed|assert|expect\(|failing test|spec failed)/.test(msg))
+        return "test";
+    if (/(timeout|timed out|deadline exceeded)/.test(msg))
+        return "timeout";
+    return "unknown";
+}
+export function shouldRetry(input) {
+    const bucket = classifyRetryBucket(input.errorMessage);
+    const policy = input.policy ?? DEFAULT_RETRY_POLICY;
+    const max = policy.maxByBucket[bucket] ?? 0;
+    return {
+        retry: input.currentRetries < max,
+        bucket,
+        max,
+    };
+}
+//# sourceMappingURL=retry.js.map

package/dist/core/swarm/retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.js","sourceRoot":"","sources":["../../../src/core/swarm/retry.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,MAAM,oBAAoB,GAAqB;IACrD,WAAW,EAAE;QACZ,UAAU,EAAE,CAAC;QACb,iBAAiB,EAAE,CAAC;QACpB,IAAI,EAAE,CAAC;QACP,OAAO,EAAE,CAAC;QACV,OAAO,EAAE,CAAC;KACV;CACD,CAAC;AAEF,MAAM,UAAU,mBAAmB,CAAC,YAAoB;IACvD,MAAM,GAAG,GAAG,YAAY,CAAC,WAAW,EAAE,CAAC;IACvC,IAAI,wDAAwD,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,YAAY,CAAC;IAC5F,IAAI,sEAAsE,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,mBAAmB,CAAC;IACjH,IAAI,wDAAwD,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,MAAM,CAAC;IACtF,IAAI,uCAAuC,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IACxE,OAAO,SAAS,CAAC;AAClB,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,KAI3B;IACA,MAAM,MAAM,GAAG,mBAAmB,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IACvD,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,IAAI,oBAAoB,CAAC;IACpD,MAAM,GAAG,GAAG,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC5C,OAAO;QACN,KAAK,EAAE,KAAK,CAAC,cAAc,GAAG,GAAG;QACjC,MAAM;QACN,GAAG;KACH,CAAC;AACH,CAAC","sourcesContent":["export type SwarmRetryBucket = \"permission\" | \"dependency_import\" | \"test\" | \"timeout\" | \"unknown\";\n\nexport interface SwarmRetryPolicy {\n\tmaxByBucket: Record<SwarmRetryBucket, number>;\n}\n\nexport const DEFAULT_RETRY_POLICY: SwarmRetryPolicy = {\n\tmaxByBucket: {\n\t\tpermission: 1,\n\t\tdependency_import: 2,\n\t\ttest: 2,\n\t\ttimeout: 2,\n\t\tunknown: 1,\n\t},\n};\n\nexport function classifyRetryBucket(errorMessage: string): SwarmRetryBucket {\n\tconst msg = errorMessage.toLowerCase();\n\tif (/(permission|denied|not allowed|forbidden|eacces|eprem)/.test(msg)) return \"permission\";\n\tif (/(module not found|cannot find module|importerror|dependency|package)/.test(msg)) return \"dependency_import\";\n\tif (/(test failed|assert|expect\\(|failing test|spec failed)/.test(msg)) return \"test\";\n\tif (/(timeout|timed out|deadline exceeded)/.test(msg)) return \"timeout\";\n\treturn \"unknown\";\n}\n\nexport function shouldRetry(input: {\n\terrorMessage: string;\n\tcurrentRetries: number;\n\tpolicy?: SwarmRetryPolicy;\n}): { retry: boolean; bucket: SwarmRetryBucket; max: number } {\n\tconst bucket = classifyRetryBucket(input.errorMessage);\n\tconst policy = input.policy ?? DEFAULT_RETRY_POLICY;\n\tconst max = policy.maxByBucket[bucket] ?? 0;\n\treturn {\n\t\tretry: input.currentRetries < max,\n\t\tbucket,\n\t\tmax,\n\t};\n}\n"]}

package/dist/core/swarm/scheduler.d.ts

@@ -0,0 +1,48 @@
+import type { EngineeringContract } from "../contract.js";
+import { type SwarmRetryPolicy } from "./retry.js";
+import type { SwarmDispatchResult, SwarmEvent, SwarmPlan, SwarmRuntimeState, SwarmSchedulerResult, SwarmTaskPlan, SwarmTaskRuntimeState } from "./types.js";
+export interface RunSwarmSchedulerOptions {
+    runId: string;
+    plan: SwarmPlan;
+    contract: EngineeringContract;
+    maxParallel: number;
+    budgetUsd?: number;
+    existingState?: SwarmRuntimeState;
+    retryPolicy?: SwarmRetryPolicy;
+    noProgressTickLimit?: number;
+    spawnCap?: number;
+    progressHeuristic?: {
+        enabled?: boolean;
+        activateAfterNoProgressTicks?: number;
+        minScore?: number;
+    };
+    conflictDensityGuard?: {
+        enabled?: boolean;
+        threshold?: number;
+        minParallel?: number;
+    };
+    confirmSpawn?: (input: {
+        candidate: NonNullable<SwarmDispatchResult["spawnCandidates"]>[number];
+        parentTask: SwarmTaskPlan;
+        parentTaskRuntime: SwarmTaskRuntimeState;
+        state: SwarmRuntimeState;
+    }) => Promise<boolean>;
+    dispatchTask: (input: {
+        task: SwarmTaskPlan;
+        runtime: SwarmTaskRuntimeState;
+        tick: number;
+    }) => Promise<SwarmDispatchResult>;
+    onEvent?: (event: SwarmEvent, state: SwarmRuntimeState) => void;
+    onStateChanged?: (state: SwarmRuntimeState) => void;
+    shouldStop?: () => boolean;
+}
+export interface RunSwarmSchedulerExtendedResult extends SwarmSchedulerResult {
+    spawnBacklog: Array<{
+        fingerprint: string;
+        description: string;
+        path: string;
+        changeType: string;
+    }>;
+}
+export declare function runSwarmScheduler(options: RunSwarmSchedulerOptions): Promise<RunSwarmSchedulerExtendedResult>;
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/core/swarm/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../../src/core/swarm/scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAG1D,OAAO,EAAqC,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEtF,OAAO,KAAK,EACX,mBAAmB,EACnB,UAAU,EAEV,SAAS,EAET,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,EACb,qBAAqB,EACrB,MAAM,YAAY,CAAC;AAyOpB,MAAM,WAAW,wBAAwB;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,4BAA4B,CAAC,EAAE,MAAM,CAAC;QACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,oBAAoB,CAAC,EAAE;QACtB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE;QACtB,SAAS,EAAE,WAAW,CAAC,mBAAmB,CAAC,iBAAiB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QACvE,UAAU,EAAE,aAAa,CAAC;QAC1B,iBAAiB,EAAE,qBAAqB,CAAC;QACzC,KAAK,EAAE,iBAAiB,CAAC;KACzB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACvB,YAAY,EAAE,CAAC,KAAK,EAAE;QACrB,IAAI,EAAE,aAAa,CAAC;QACpB,OAAO,EAAE,qBAAqB,CAAC;QAC/B,IAAI,EAAE,MAAM,CAAC;KACb,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAChE,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACpD,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,+BAAgC,SAAQ,oBAAoB;IAC5E,YAAY,EAAE,KAAK,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpG;AAED,wBAAsB,iBAAiB,CACtC,OAAO,EAAE,wBAAwB,GAC/B,OAAO,CAAC,+BAA+B,CAAC,CAsY1C"}

package/dist/core/swarm/scheduler.js

@@ -0,0 +1,554 @@
+import { touchesConflict, HierarchicalLockManager } from "./locks.js";
+import { evaluateRunGates, evaluateTaskGates } from "./gates.js";
+import { DEFAULT_RETRY_POLICY, shouldRetry } from "./retry.js";
+import { SwarmSpawnQueue } from "./spawn.js";
+const TERMINAL_STATUSES = new Set(["done", "error", "cancelled", "blocked"]);
+function nowIso() {
+    return new Date().toISOString();
+}
+function compact(values) {
+    return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))];
+}
+function isTerminal(status) {
+    return TERMINAL_STATUSES.has(status);
+}
+function severityWeight(task) {
+    if (task.severity === "high")
+        return 3;
+    if (task.severity === "medium")
+        return 2;
+    return 1;
+}
+function collectDependents(plan) {
+    const result = new Map();
+    for (const task of plan.tasks) {
+        for (const dep of task.depends_on) {
+            result.set(dep, (result.get(dep) ?? 0) + 1);
+        }
+    }
+    return result;
+}
+function createTaskRuntimeState(task) {
+    return {
+        id: task.id,
+        status: task.depends_on.length === 0 ? "ready" : "pending",
+        attempts: 0,
+        depends_on: [...task.depends_on],
+        touches: [...task.touches],
+        scopes: [...task.scopes],
+    };
+}
+function buildInitialState(input) {
+    if (input.existingState) {
+        return {
+            ...input.existingState,
+            updatedAt: nowIso(),
+            status: input.existingState.status === "completed" ? "running" : input.existingState.status,
+        };
+    }
+    const tasks = {};
+    for (const task of input.plan.tasks) {
+        tasks[task.id] = createTaskRuntimeState(task);
+    }
+    return {
+        runId: input.runId,
+        status: "running",
+        createdAt: nowIso(),
+        updatedAt: nowIso(),
+        tick: 0,
+        noProgressTicks: 0,
+        readyQueue: Object.values(tasks)
+            .filter((task) => task.status === "ready")
+            .map((task) => task.id),
+        blockedTasks: [],
+        tasks,
+        locks: {},
+        retries: {},
+        budget: {
+            limitUsd: input.budgetUsd,
+            spentUsd: 0,
+            warned80: false,
+            hardStopped: false,
+        },
+    };
+}
+function runHasOnlyBlockedTasks(state) {
+    const tasks = Object.values(state.tasks);
+    const unfinished = tasks.filter((task) => !isTerminal(task.status));
+    if (unfinished.length > 0)
+        return false;
+    return tasks.length > 0 && tasks.some((task) => task.status === "blocked");
+}
+function collectReadyTasks(state, planById) {
+    const ready = [];
+    for (const [taskId, runtime] of Object.entries(state.tasks)) {
+        if (runtime.status !== "pending" && runtime.status !== "ready")
+            continue;
+        const plan = planById.get(taskId);
+        if (!plan)
+            continue;
+        const depsDone = plan.depends_on.every((dep) => state.tasks[dep]?.status === "done");
+        if (!depsDone) {
+            runtime.status = "pending";
+            continue;
+        }
+        if (runtime.status !== "ready") {
+            runtime.status = "ready";
+        }
+        ready.push(taskId);
+    }
+    return ready;
+}
+function selectBatch(input) {
+    const sorted = [...input.readyTaskIds].sort((a, b) => {
+        const taskA = input.planById.get(a);
+        const taskB = input.planById.get(b);
+        if (!taskA || !taskB)
+            return a.localeCompare(b);
+        const severityDelta = severityWeight(taskB) - severityWeight(taskA);
+        if (severityDelta !== 0)
+            return severityDelta;
+        const dependentDelta = (input.dependents.get(b) ?? 0) - (input.dependents.get(a) ?? 0);
+        if (dependentDelta !== 0)
+            return dependentDelta;
+        return a.localeCompare(b);
+    });
+    const selected = [];
+    for (const taskId of sorted) {
+        const plan = input.planById.get(taskId);
+        if (!plan)
+            continue;
+        const hasConflictWithSelected = selected.some((existingId) => {
+            const existing = input.planById.get(existingId);
+            if (!existing)
+                return false;
+            return touchesConflict(existing.touches, plan.touches);
+        });
+        if (hasConflictWithSelected)
+            continue;
+        selected.push(taskId);
+        if (selected.length >= Math.max(1, input.maxParallel))
+            break;
+    }
+    return selected;
+}
+function progressScore(task, dependents) {
+    const dependentWeight = dependents.get(task.id) ?? 0;
+    const touchWeight = Math.min(3, Math.max(1, task.touches.length));
+    return severityWeight(task) * 3 + dependentWeight * 2 + touchWeight;
+}
+function applyProgressHeuristic(input) {
+    if (input.readyTaskIds.length <= 1)
+        return input.readyTaskIds;
+    if (input.state.noProgressTicks < input.activateAfterNoProgressTicks)
+        return input.readyTaskIds;
+    const scored = input.readyTaskIds
+        .map((taskId) => {
+        const plan = input.planById.get(taskId);
+        if (!plan)
+            return undefined;
+        return { taskId, score: progressScore(plan, input.dependents), severity: plan.severity };
+    })
+        .filter((item) => item !== undefined)
+        .sort((a, b) => b.score - a.score || a.taskId.localeCompare(b.taskId));
+    if (scored.length === 0)
+        return input.readyTaskIds;
+    const topScore = scored[0].score;
+    const threshold = Math.max(input.minScore, topScore - 2);
+    const filtered = scored
+        .filter((item) => item.score >= threshold || item.severity === "high")
+        .map((item) => item.taskId);
+    return filtered.length > 0 ? filtered : [scored[0].taskId];
+}
+function conflictDensity(input) {
+    const count = input.taskIds.length;
+    if (count < 2)
+        return 0;
+    let conflictingPairs = 0;
+    let totalPairs = 0;
+    for (let i = 0; i < count; i += 1) {
+        const a = input.planById.get(input.taskIds[i]);
+        if (!a)
+            continue;
+        for (let j = i + 1; j < count; j += 1) {
+            const b = input.planById.get(input.taskIds[j]);
+            if (!b)
+                continue;
+            totalPairs += 1;
+            if (touchesConflict(a.touches, b.touches)) {
+                conflictingPairs += 1;
+            }
+        }
+    }
+    return totalPairs > 0 ? conflictingPairs / totalPairs : 0;
+}
+function applyConflictDensityGuard(input) {
+    const density = conflictDensity({ taskIds: input.readyTaskIds, planById: input.planById });
+    if (density < input.threshold) {
+        return { effectiveMaxParallel: input.maxParallel, density };
+    }
+    const scaled = Math.max(input.minParallel, Math.floor(input.maxParallel * Math.max(0.2, 1 - density)));
+    return {
+        effectiveMaxParallel: Math.max(1, Math.min(input.maxParallel, scaled)),
+        density,
+    };
+}
+function shouldStopForBudget(state) {
+    const limit = state.budget.limitUsd;
+    if (limit === undefined || limit <= 0)
+        return false;
+    if (!state.budget.warned80 && state.budget.spentUsd >= limit * 0.8) {
+        state.budget.warned80 = true;
+    }
+    if (state.budget.spentUsd >= limit) {
+        state.budget.hardStopped = true;
+        return true;
+    }
+    return false;
+}
+export async function runSwarmScheduler(options) {
+    const planById = new Map(options.plan.tasks.map((task) => [task.id, task]));
+    const dependents = collectDependents(options.plan);
+    const retryPolicy = options.retryPolicy ?? DEFAULT_RETRY_POLICY;
+    const noProgressLimit = Math.max(3, options.noProgressTickLimit ?? 8);
+    const spawnCap = Math.max(1, options.spawnCap ?? 30);
+    const progressHeuristicEnabled = options.progressHeuristic?.enabled !== false;
+    const progressHeuristicActivateAfter = Math.max(1, options.progressHeuristic?.activateAfterNoProgressTicks ?? 2);
+    const progressHeuristicMinScore = Math.max(1, options.progressHeuristic?.minScore ?? 4);
+    const conflictGuardEnabled = options.conflictDensityGuard?.enabled !== false;
+    const conflictGuardThreshold = Math.min(1, Math.max(0, options.conflictDensityGuard?.threshold ?? 0.45));
+    const conflictGuardMinParallel = Math.max(1, options.conflictDensityGuard?.minParallel ?? 1);
+    const state = buildInitialState({
+        runId: options.runId,
+        plan: options.plan,
+        budgetUsd: options.budgetUsd,
+        existingState: options.existingState,
+    });
+    const lockManager = new HierarchicalLockManager();
+    const taskGateByTaskId = new Map();
+    const spawned = new SwarmSpawnQueue();
+    const events = [];
+    for (const [taskId, taskState] of Object.entries(state.tasks)) {
+        if (taskState.status === "running") {
+            taskState.status = "pending";
+            taskState.startedAt = undefined;
+        }
+        if (taskState.status === "done") {
+            const plan = planById.get(taskId);
+            if (plan) {
+                taskGateByTaskId.set(taskId, evaluateTaskGates({ ...plan, touches: taskState.touches }, options.contract));
+            }
+        }
+    }
+    const emit = (type, message, payload, taskId) => {
+        const event = {
+            type,
+            timestamp: nowIso(),
+            runId: options.runId,
+            tick: state.tick,
+            message,
+            payload,
+            ...(taskId ? { taskId } : {}),
+        };
+        events.push(event);
+        options.onEvent?.(event, state);
+    };
+    emit("run_started", `Swarm run ${options.runId} started`, {
+        tasks: options.plan.tasks.length,
+        maxParallel: options.maxParallel,
+        budgetUsd: options.budgetUsd,
+    });
+    options.onStateChanged?.(state);
+    while (true) {
+        if (options.shouldStop?.()) {
+            state.status = "stopped";
+            state.lastError = "Run interrupted by user.";
+            emit("run_stopped", state.lastError);
+            break;
+        }
+        state.tick += 1;
+        state.updatedAt = nowIso();
+        emit("tick", `scheduler_tick=${state.tick}`);
+        if (shouldStopForBudget(state)) {
+            state.status = "stopped";
+            state.lastError = "Budget hard-stop reached.";
+            emit("run_stopped", state.lastError, {
+                budgetLimitUsd: state.budget.limitUsd,
+                spentUsd: state.budget.spentUsd,
+            });
+            options.onStateChanged?.(state);
+            break;
+        }
+        const readyTaskIds = collectReadyTasks(state, planById);
+        state.readyQueue = [...readyTaskIds];
+        state.blockedTasks = Object.values(state.tasks)
+            .filter((task) => task.status === "blocked")
+            .map((task) => task.id)
+            .sort((a, b) => a.localeCompare(b));
+        if (readyTaskIds.length === 0) {
+            const allTerminal = Object.values(state.tasks).every((task) => isTerminal(task.status));
+            if (allTerminal) {
+                const runGate = evaluateRunGates({
+                    taskStates: state.tasks,
+                    taskGateResults: [...taskGateByTaskId.values()],
+                    contract: options.contract,
+                });
+                emit("gate_run", runGate.pass ? "run_gates_passed" : "run_gates_failed", {
+                    warnings: runGate.warnings,
+                    failures: runGate.failures,
+                });
+                if (runGate.pass && Object.values(state.tasks).every((task) => task.status === "done" || task.status === "blocked")) {
+                    state.status = runHasOnlyBlockedTasks(state) ? "blocked" : "completed";
+                    emit(state.status === "completed" ? "run_completed" : "run_blocked", `Swarm run ${state.status}`);
+                }
+                else {
+                    state.status = "failed";
+                    state.lastError = runGate.failures.join(" | ") || "Run gates failed.";
+                    emit("run_failed", state.lastError);
+                }
+                options.onStateChanged?.(state);
+                break;
+            }
+            state.noProgressTicks += 1;
+            if (state.noProgressTicks >= noProgressLimit) {
+                state.status = "blocked";
+                state.lastError = "No progress threshold reached.";
+                emit("run_blocked", state.lastError, { noProgressTicks: state.noProgressTicks });
+                options.onStateChanged?.(state);
+                break;
+            }
+            options.onStateChanged?.(state);
+            continue;
+        }
+        const progressReady = progressHeuristicEnabled
+            ? applyProgressHeuristic({
+                readyTaskIds,
+                planById,
+                dependents,
+                state,
+                activateAfterNoProgressTicks: progressHeuristicActivateAfter,
+                minScore: progressHeuristicMinScore,
+            })
+            : readyTaskIds;
+        const guard = conflictGuardEnabled
+            ? applyConflictDensityGuard({
+                readyTaskIds: progressReady,
+                planById,
+                maxParallel: options.maxParallel,
+                threshold: conflictGuardThreshold,
+                minParallel: conflictGuardMinParallel,
+            })
+            : { effectiveMaxParallel: options.maxParallel, density: conflictDensity({ taskIds: progressReady, planById }) };
+        emit("tick", "scheduler_guards", {
+            ready: readyTaskIds.length,
+            progress_candidates: progressReady.length,
+            conflict_density: Number(guard.density.toFixed(3)),
+            effective_max_parallel: guard.effectiveMaxParallel,
+            no_progress_ticks: state.noProgressTicks,
+        });
+        const preselected = selectBatch({
+            readyTaskIds: progressReady,
+            planById,
+            maxParallel: guard.effectiveMaxParallel,
+            dependents,
+        });
+        const selected = [];
+        for (const taskId of preselected) {
+            const plan = planById.get(taskId);
+            if (!plan)
+                continue;
+            const lockCheck = lockManager.canAcquire(taskId, plan.touches);
+            if (!lockCheck.ok) {
+                const runtime = state.tasks[taskId];
+                if (runtime) {
+                    runtime.status = "blocked";
+                    runtime.lastError = `Lock conflict: ${lockCheck.conflicts
+                        .map((conflict) => `${conflict.touch}<->${conflict.conflictingTouch}`)
+                        .join(", ")}`;
+                    emit("task_blocked", runtime.lastError, { conflicts: lockCheck.conflicts }, taskId);
+                }
+                continue;
+            }
+            selected.push(taskId);
+        }
+        if (selected.length === 0) {
+            state.noProgressTicks += 1;
+            if (state.noProgressTicks >= noProgressLimit) {
+                state.status = "blocked";
+                state.lastError = "No dispatch candidates after lock/budget filters.";
+                emit("run_blocked", state.lastError, { ready: readyTaskIds });
+                options.onStateChanged?.(state);
+                break;
+            }
+            options.onStateChanged?.(state);
+            continue;
+        }
+        let progressThisTick = false;
+        const dispatchContexts = [];
+        for (const taskId of selected) {
+            const plan = planById.get(taskId);
+            const runtime = state.tasks[taskId];
+            if (!plan || !runtime)
+                continue;
+            lockManager.acquire(taskId, runtime.touches.length > 0 ? runtime.touches : plan.touches);
+            state.locks = lockManager.snapshot();
+            emit("lock_acquired", `lock acquired for ${taskId}`, { touches: runtime.touches }, taskId);
+            runtime.status = "running";
+            runtime.attempts += 1;
+            runtime.startedAt = nowIso();
+            emit("task_running", `task ${taskId} running`, { attempt: runtime.attempts }, taskId);
+            dispatchContexts.push({ taskId, plan, runtime });
+        }
+        options.onStateChanged?.(state);
+        const dispatchResults = await Promise.all(dispatchContexts.map(async ({ taskId, plan, runtime }) => {
+            let result;
+            try {
+                result = await options.dispatchTask({
+                    task: plan,
+                    runtime,
+                    tick: state.tick,
+                });
+            }
+            catch (error) {
+                result = {
+                    taskId,
+                    status: "error",
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+            return { taskId, plan, runtime, result };
+        }));
+        for (const { taskId, plan, runtime, result } of dispatchResults) {
+            if (result.touchesRefined && result.touchesRefined.length > 0) {
+                runtime.touches = compact(result.touchesRefined);
+                lockManager.downgrade(taskId, runtime.touches);
+                state.locks = lockManager.snapshot();
+            }
+            if (typeof result.costUsd === "number" && Number.isFinite(result.costUsd) && result.costUsd > 0) {
+                state.budget.spentUsd += result.costUsd;
+            }
+            if (result.status === "done") {
+                runtime.status = "done";
+                runtime.completedAt = nowIso();
+                runtime.lastError = undefined;
+                progressThisTick = true;
+                emit("task_done", `task ${taskId} done`, undefined, taskId);
+                const gateResult = evaluateTaskGates({ ...plan, touches: runtime.touches }, options.contract);
+                taskGateByTaskId.set(taskId, gateResult);
+                emit("gate_task", gateResult.pass ? "task_gates_passed" : "task_gates_failed", {
+                    warnings: gateResult.warnings,
+                    failures: gateResult.failures,
+                }, taskId);
+            }
+            else if (result.status === "blocked") {
+                runtime.status = "blocked";
+                runtime.lastError = result.error ?? "Task blocked by user input or policy.";
+                emit("task_blocked", runtime.lastError, undefined, taskId);
+            }
+            else {
+                const errorMessage = result.error ?? "Unknown task failure.";
+                const currentRetries = state.retries[taskId] ?? 0;
+                const retryDecision = shouldRetry({
+                    errorMessage,
+                    currentRetries,
+                    policy: retryPolicy,
+                });
+                if (retryDecision.retry) {
+                    state.retries[taskId] = currentRetries + 1;
+                    runtime.status = "ready";
+                    runtime.lastError = errorMessage;
+                    emit("task_retry", `retry ${state.retries[taskId]}/${retryDecision.max} for ${taskId} (${retryDecision.bucket})`, {
+                        error: errorMessage,
+                        bucket: retryDecision.bucket,
+                        failureCause: result.failureCause ?? retryDecision.bucket,
+                    }, taskId);
+                }
+                else {
+                    runtime.status = "error";
+                    runtime.completedAt = nowIso();
+                    runtime.lastError = errorMessage;
+                    emit("task_error", errorMessage, { bucket: retryDecision.bucket, failureCause: result.failureCause ?? retryDecision.bucket }, taskId);
+                }
+            }
+            for (const candidate of result.spawnCandidates ?? []) {
+                if (spawned.size() >= spawnCap)
+                    break;
+                const requiresConfirmation = candidate.severity === "high" || plan.spawn_policy === "manual_high_risk";
+                if (requiresConfirmation && options.confirmSpawn) {
+                    const approved = await options.confirmSpawn({
+                        candidate,
+                        parentTask: plan,
+                        parentTaskRuntime: runtime,
+                        state,
+                    });
+                    if (!approved) {
+                        emit("spawn_rejected", `spawn rejected from ${taskId}`, {
+                            description: candidate.description,
+                            path: candidate.path,
+                            changeType: candidate.changeType,
+                            severity: candidate.severity,
+                        }, taskId);
+                        continue;
+                    }
+                }
+                const queued = spawned.enqueue(candidate);
+                if (!queued.accepted)
+                    continue;
+                emit("spawn_enqueued", `spawn queued from ${taskId}`, {
+                    fingerprint: queued.fingerprint,
+                    description: candidate.description,
+                    path: candidate.path,
+                    changeType: candidate.changeType,
+                    severity: candidate.severity,
+                }, taskId);
+            }
+            lockManager.release(taskId);
+            state.locks = lockManager.snapshot();
+            emit("lock_released", `lock released for ${taskId}`, undefined, taskId);
+            options.onStateChanged?.(state);
+        }
+        if (shouldStopForBudget(state)) {
+            state.status = "stopped";
+            state.lastError = "Budget hard-stop reached.";
+            emit("run_stopped", state.lastError, {
+                budgetLimitUsd: state.budget.limitUsd,
+                spentUsd: state.budget.spentUsd,
+            });
+            options.onStateChanged?.(state);
+            break;
+        }
+        state.noProgressTicks = progressThisTick ? 0 : state.noProgressTicks + 1;
+        options.onStateChanged?.(state);
+        if (!progressThisTick && state.noProgressTicks >= noProgressLimit) {
+            state.status = "blocked";
+            state.lastError = "No measurable progress within scheduler threshold.";
+            emit("run_blocked", state.lastError, { noProgressTicks: state.noProgressTicks });
+            options.onStateChanged?.(state);
+            break;
+        }
+    }
+    const runGate = evaluateRunGates({
+        taskStates: state.tasks,
+        taskGateResults: [...taskGateByTaskId.values()],
+        contract: options.contract,
+    });
+    if (state.status === "completed" && !runGate.pass) {
+        state.status = "failed";
+        state.lastError = runGate.failures.join(" | ") || "Run gates failed.";
+        emit("run_failed", state.lastError);
+    }
+    const drainedSpawn = spawned.drain(spawnCap).map(({ fingerprint, candidate }) => ({
+        fingerprint,
+        description: candidate.description,
+        path: candidate.path,
+        changeType: candidate.changeType,
+    }));
+    return {
+        state,
+        taskGates: [...taskGateByTaskId.values()],
+        runGate,
+        events,
+        spawnBacklog: drainedSpawn,
+    };
+}
+//# sourceMappingURL=scheduler.js.map