sneakoscope 3.0.4 → 3.1.1

package/dist/core/loops/loop-planner.js

@@ -0,0 +1,170 @@
+import { writeJsonAtomic } from '../fsx.js';
+import { decomposeRequestIntoLoopDomains } from './loop-decomposer.js';
+import { loopPlanPath, loopRunLogPath, loopStatePath } from './loop-artifacts.js';
+import { selectLoopGates } from './loop-gate-selector.js';
+import { inferLoopOwnerScope } from './loop-owner-inference.js';
+import { classifyLoopRisk } from './loop-risk-classifier.js';
+import { defaultLoopBudget, validateLoopPlan } from './loop-schema.js';
+export async function planLoopsFromRequest(input) {
+    const parallelism = input.parallelism || 'balanced';
+    const maxLoops = Math.max(1, Math.min(32, input.maxLoops || 8));
+    const domains = decomposeRequestIntoLoopDomains(input.request).slice(0, maxLoops);
+    const actionNodes = domains.map((domain) => {
+        const loopId = `loop-${domain.id}`;
+        const ownerScope = inferLoopOwnerScope({ domain });
+        const risk = classifyLoopRisk({ loop_id: loopId, owner_scope: ownerScope, level: 'L2-action' });
+        const nodeBase = makeNode({
+            missionId: input.missionId,
+            loopId,
+            title: titleFromDomain(domain.id),
+            purpose: `Execute ${domain.id} slice for: ${input.request}`,
+            ownerScope,
+            dependencies: [],
+            route: domain.id === 'docs' ? '$Loop' : '$Naruto',
+            level: domain.id === 'docs' ? 'L1-assisted' : 'L2-action',
+            risk,
+            parallelism
+        });
+        return { ...nodeBase, gates: selectLoopGates({ node: nodeBase, changedFiles: [...ownerScope.files, ...ownerScope.directories], risk }) };
+    });
+    const integrationOwner = inferLoopOwnerScope({ domain: { id: 'integration', dirs: [], files: [], gates: ['release:dag-full-coverage'] }, integration: true });
+    const integrationRisk = classifyLoopRisk({ loop_id: 'loop-integration', owner_scope: integrationOwner, level: 'L1-assisted' });
+    const integrationBase = makeNode({
+        missionId: input.missionId,
+        loopId: 'loop-integration',
+        title: 'Integration loop finalizer',
+        purpose: 'Merge loop proofs, run integration gates, and require GPT final arbitration when source mutation exists.',
+        ownerScope: integrationOwner,
+        dependencies: actionNodes.map((node) => node.loop_id),
+        route: '$Integration',
+        level: 'L1-assisted',
+        risk: integrationRisk,
+        parallelism
+    });
+    const integrationNode = {
+        ...integrationBase,
+        gates: selectLoopGates({
+            node: integrationBase,
+            changedFiles: ['package.json', 'release-gates.v2.json', 'CHANGELOG.md'],
+            risk: integrationRisk,
+            packageScriptsChanged: ['loop:runtime'],
+            releaseGateIdsChanged: ['release:dag-full-coverage']
+        })
+    };
+    const nodes = [...actionNodes, integrationNode];
+    const plan = {
+        schema: 'sks.loop-plan.v1',
+        mission_id: input.missionId,
+        request: input.request,
+        generated_at: new Date().toISOString(),
+        planner: {
+            route: '$Loop',
+            model_policy: input.mode === 'codex-assisted' ? 'codex-sdk' : 'deterministic',
+            confidence: actionNodes.length ? 'high' : 'medium'
+        },
+        graph: {
+            nodes,
+            edges: actionNodes.map((node) => ({ from: node.loop_id, to: integrationNode.loop_id, reason: 'integration_after_loop_proof' }))
+        },
+        global_budget: defaultLoopBudget({
+            max_iterations: Math.max(...nodes.map((node) => node.budget.max_iterations)),
+            max_subagents: nodes.reduce((sum, node) => sum + node.budget.max_subagents, 0)
+        }),
+        safety: {
+            no_unrequested_fallback_code: true,
+            require_owner_lease: true,
+            require_checker_for_action: true,
+            require_gpt_final_for_source_mutation: true
+        },
+        integration_loop_id: integrationNode.loop_id,
+        compatibility: {
+            goal_compat_artifact: input.sourceCommand === 'goal' ? `.sneakoscope/missions/${input.missionId}/goal-compat.json` : null,
+            source_command: input.sourceCommand
+        },
+        blockers: []
+    };
+    const validation = validateLoopPlan(plan);
+    plan.blockers = validation.blockers;
+    await writeJsonAtomic(loopPlanPath(input.root, input.missionId), plan);
+    return plan;
+}
+function makeNode(input) {
+    const makerWorkerCount = dynamicMakerWorkerCount(input);
+    const checkerWorkerCount = dynamicCheckerWorkerCount(input);
+    const budget = defaultLoopBudget({
+        max_subagents: input.route === '$Integration' ? 2 : Math.max(4, makerWorkerCount + checkerWorkerCount + 1),
+        max_changed_files: input.ownerScope.files.length ? Math.max(4, input.ownerScope.files.length + 2) : 12
+    });
+    return {
+        schema: 'sks.loop-node.v1',
+        loop_id: input.loopId,
+        mission_id: input.missionId,
+        title: input.title,
+        purpose: input.purpose,
+        level: input.level,
+        route: input.route,
+        owner_scope: input.ownerScope,
+        state_file: loopStatePath('', input.missionId, input.loopId).replace(/^\/?/, ''),
+        run_log_file: loopRunLogPath('', input.missionId, input.loopId).replace(/^\/?/, ''),
+        budget,
+        maker: {
+            route: '$Naruto',
+            role: input.route === '$Integration' ? 'planner' : input.loopId.includes('docs') ? 'writer' : 'implementer',
+            worker_count: makerWorkerCount,
+            backend_preference: ['codex-sdk', 'python-codex-sdk', 'local-llm'],
+            local_draft_allowed: input.risk.level !== 'critical',
+            gpt_final_required: input.risk.requires_gpt_final
+        },
+        checker: {
+            route: input.loopId.includes('research') ? '$Research' : input.loopId.includes('docs') ? '$DFix' : '$QA-LOOP',
+            worker_count: checkerWorkerCount,
+            fresh_session_required: true,
+            stronger_model_required: input.risk.level === 'high' || input.risk.level === 'critical',
+            required_before_next_iteration: input.level === 'L2-action'
+        },
+        gates: { triage: [], local: [], checker: [], integration: [], final: [] },
+        dependencies: input.dependencies,
+        handoff_policy: {
+            allow_handoff: true,
+            reasons: input.risk.requires_human_handoff ? ['critical_risk_requires_handoff'] : [],
+            artifact: null
+        },
+        worktree: {
+            required: input.risk.requires_worktree,
+            mode: input.risk.requires_worktree ? 'new-worktree' : 'none',
+            branch_prefix: `sks/loop/${input.missionId}`,
+            cleanup: input.risk.level === 'low' ? 'on-success' : 'keep-on-failure'
+        },
+        risk: input.risk
+    };
+}
+// Maker parallelism scales with the loop's owned scope instead of a flat 2:
+// Naruto can fan out far wider, and a fixed count starved wide scopes while
+// over-provisioning single-file loops. Risk still clamps the ceiling so
+// critical work cannot stampede, and 'safe' mode keeps the old behavior.
+function dynamicMakerWorkerCount(input) {
+    if (input.route === '$Integration')
+        return 1;
+    const scopeSize = input.ownerScope.files.length + input.ownerScope.directories.length * 3;
+    const modeCap = input.parallelism === 'safe' ? 2 : input.parallelism === 'extreme' ? 8 : 6;
+    const riskCap = input.risk.level === 'critical' ? 2 : modeCap;
+    const riskFloor = input.risk.level === 'high' ? 3 : 2;
+    const scopeScaled = Math.max(riskFloor, Math.ceil(scopeSize / 3));
+    return Math.max(1, Math.min(modeCap, riskCap, scopeScaled));
+}
+// Checker workers are read-only GPT review lanes. They scale more conservatively
+// than makers, but wide/high-risk owner scopes get more than one fresh reviewer.
+function dynamicCheckerWorkerCount(input) {
+    if (input.route === '$Integration')
+        return 1;
+    const scopeSize = input.ownerScope.files.length + input.ownerScope.directories.length * 3;
+    const modeCap = input.parallelism === 'safe' ? 1 : input.parallelism === 'extreme' ? 4 : 3;
+    const riskFloor = input.risk.level === 'high' || input.risk.level === 'critical' ? 2 : 1;
+    const riskCap = input.risk.level === 'critical' ? Math.min(2, modeCap) : modeCap;
+    const scopeScaled = Math.max(riskFloor, Math.ceil(scopeSize / 6));
+    return Math.max(1, Math.min(modeCap, riskCap, scopeScaled));
+}
+function titleFromDomain(domainId) {
+    return domainId === 'loop-general-coding' ? 'General coding loop' : `${domainId} loop`;
+}
+//# sourceMappingURL=loop-planner.js.map

package/dist/core/loops/loop-proof-summary.js

@@ -0,0 +1,10 @@
+export function renderLoopProofSummary(proof) {
+    return [
+        `Loop graph: ${proof.ok ? 'passed' : 'blocked'}`,
+        `Loops: ${proof.total_loops} total / ${proof.completed_loops} done / ${proof.handoff_loops} handoff`,
+        `Parallelism: ${proof.parallelism.max_active_loops} active loops / ${proof.parallelism.max_active_workers} max workers / ${proof.parallelism.speedup_ratio}x speedup`,
+        `Gates: ${proof.gates.selected.length} selected / ${proof.gates.passed.length} passed`,
+        `Blocked: ${proof.blockers.length ? proof.blockers.join(', ') : 'none'}`
+    ].join('\n');
+}
+//# sourceMappingURL=loop-proof-summary.js.map

package/dist/core/loops/loop-proof.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=loop-proof.js.map

package/dist/core/loops/loop-risk-classifier.js

@@ -0,0 +1,42 @@
+export function classifyLoopRisk(node) {
+    const scope = [
+        ...node.owner_scope.files,
+        ...node.owner_scope.directories,
+        ...node.owner_scope.package_scripts,
+        ...node.owner_scope.release_gate_ids
+    ].join(' ').toLowerCase();
+    const reasons = [];
+    let level = 'low';
+    if (/(db|mad-db|mcp|token|auth|postinstall|publish|global config)/.test(scope)) {
+        level = 'critical';
+        reasons.push('critical_scope');
+    }
+    else if (/(release-gates|worktree|scheduler|zellij|codex-control|agent|native-swarm)/.test(scope)) {
+        level = 'high';
+        reasons.push('runtime_or_scheduler_scope');
+    }
+    else if (/(qa-loop|research|image|docs)/.test(scope)) {
+        level = 'medium';
+        reasons.push('domain_scope');
+    }
+    else {
+        reasons.push('bounded_scope');
+    }
+    const requiresHuman = level === 'critical';
+    return {
+        level,
+        reasons,
+        requires_worktree: level === 'medium' || level === 'high' || level === 'critical',
+        requires_gpt_final: level !== 'low',
+        requires_human_handoff: requiresHuman
+    };
+}
+export function loopLevelAllowedUnattended(node) {
+    return node.level === 'L3-unattended'
+        && (node.risk.level === 'low' || node.risk.level === 'medium')
+        && node.owner_scope.exclusive
+        && node.budget.max_changed_files <= 8
+        && node.gates.local.length > 0
+        && !node.risk.requires_human_handoff;
+}
+//# sourceMappingURL=loop-risk-classifier.js.map

package/dist/core/loops/loop-runtime-control.js

@@ -0,0 +1,25 @@
+import { readJson, writeJsonAtomic } from '../fsx.js';
+import { loopKillRequestPath, loopProofPath, loopStatePath } from './loop-artifacts.js';
+import { writeLoopCheckpoint } from './loop-checkpoint.js';
+export async function writeLoopKillRequest(root, missionId, target) {
+    const request = { schema: 'sks.loop-kill-request.v1', mission_id: missionId, target, requested_at: new Date().toISOString() };
+    await writeJsonAtomic(loopKillRequestPath(root, missionId), request);
+    return request;
+}
+export async function shouldKillLoop(root, missionId, loopId) {
+    const request = await readJson(loopKillRequestPath(root, missionId), null);
+    return request?.target === 'all' || request?.target === loopId;
+}
+export async function checkpointCancelledLoop(root, node, iteration, phase) {
+    await writeLoopCheckpoint({
+        root,
+        mission_id: node.mission_id,
+        loop_id: node.loop_id,
+        iteration,
+        phase,
+        state_path: loopStatePath(root, node.mission_id, node.loop_id),
+        proof_path: loopProofPath(root, node.mission_id, node.loop_id),
+        resumable: true
+    });
+}
+//# sourceMappingURL=loop-runtime-control.js.map

package/dist/core/loops/loop-runtime.js

@@ -0,0 +1,314 @@
+import { writeJsonAtomic } from '../fsx.js';
+import { loopBudgetPath, loopProofPath, loopStatePath } from './loop-artifacts.js';
+import { writeLoopCheckpoint } from './loop-checkpoint.js';
+import { finalizeLoopGraph } from './loop-finalizer.js';
+import { runLoopGates } from './loop-gate-runner.js';
+import { acquireLoopLease, releaseLoopLease } from './loop-lease.js';
+import { checkpointCancelledLoop, shouldKillLoop } from './loop-runtime-control.js';
+import { scheduleLoopGraph } from './loop-scheduler.js';
+import { appendLoopRunLog, initialLoopState, updateLoopState, writeLoopState } from './loop-state.js';
+import { runLoopCheckerWorkers, runLoopMakerWorkers } from './loop-worker-runtime.js';
+import { allocateLoopWorktree, computeLoopDiff } from './loop-worktree-runtime.js';
+export async function runLoopPlan(input) {
+    const started = Date.now();
+    const schedule = scheduleLoopGraph(input.plan.graph.nodes, input.parallelism || 'balanced');
+    const proofs = [];
+    for (const batch of schedule.batches) {
+        if (await shouldKillLoop(input.root, input.plan.mission_id, 'all'))
+            break;
+        const batchProofs = await Promise.all(batch.map((node) => runLoopNode({
+            root: input.root,
+            plan: input.plan,
+            node,
+            noMutation: Boolean(input.noMutation || input.dryRun)
+        })));
+        proofs.push(...batchProofs);
+    }
+    const graphProof = await finalizeLoopGraph({
+        root: input.root,
+        plan: input.plan,
+        proofs,
+        maxActiveLoops: schedule.max_active_loops,
+        maxActiveWorkers: Math.max(1, proofs.reduce((sum, proof) => sum + proof.maker_result.worker_count + proof.checker_result.worker_count, 0)),
+        wallMs: Math.max(1, Date.now() - started)
+    });
+    return {
+        ok: schedule.ok && graphProof.ok,
+        mission_id: input.plan.mission_id,
+        proofs,
+        graph_proof: graphProof,
+        blockers: [...schedule.blockers, ...graphProof.blockers]
+    };
+}
+export async function runLoopNode(input) {
+    const started = Date.now();
+    const node = input.node;
+    const iteration = input.iterationStart || 1;
+    const files = [...node.owner_scope.files, ...node.owner_scope.directories];
+    let lease = null;
+    let worktree = null;
+    try {
+        await writeLoopState(input.root, initialLoopState({ missionId: node.mission_id, loopId: node.loop_id, files }));
+        await writeJsonAtomic(loopBudgetPath(input.root, node.mission_id, node.loop_id), node.budget);
+        await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_started', status: 'running', message: node.purpose });
+        await checkpoint(input.root, node, iteration, 'triage', false);
+        await updateLoopState(input.root, node.mission_id, node.loop_id, { status: 'running', iteration, current_phase: 'triage' });
+        await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_triage_completed', status: 'running' });
+        lease = await acquireLoopLease(input.root, input.plan, node);
+        if (lease.blockers.length)
+            return blockedProof(input.root, node, lease.blockers, started, 'owner_collision', 'handoff');
+        worktree = await allocateLoopWorktree({
+            root: input.root,
+            plan: input.plan,
+            node,
+            ...(input.noMutation === undefined ? {} : { noMutation: input.noMutation })
+        });
+        if (worktree.blockers.length)
+            return blockedProof(input.root, node, worktree.blockers, started, 'worktree_blocked', 'blocked', lease, worktree);
+        await updateLoopState(input.root, node.mission_id, node.loop_id, {
+            current_phase: 'maker',
+            acting_on: { files, worktree_id: worktree.worktree_id || lease.worktree_id, branch: worktree.branch }
+        });
+        if (await shouldCancel(input.root, node, iteration, 'maker'))
+            return cancelledProof(input.root, node, started, lease, worktree, 'maker');
+        await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_maker_started', status: 'running' });
+        const maker = await runLoopMakerWorkers({
+            root: input.root,
+            plan: input.plan,
+            node,
+            worktree: { id: worktree.worktree_id || lease.worktree_id, path: worktree.path, branch: worktree.branch },
+            ...(input.noMutation === undefined ? {} : { noMutation: input.noMutation })
+        });
+        await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_maker_completed', status: maker.ok ? 'running' : 'blocked' });
+        await checkpoint(input.root, node, iteration, 'maker', true);
+        if (!maker.ok)
+            return workerBlockedProof(input.root, node, maker, null, started, 'maker_failed', lease, worktree);
+        await updateLoopState(input.root, node.mission_id, node.loop_id, { current_phase: 'checker', last_action: 'maker_workers_completed' });
+        if (await shouldCancel(input.root, node, iteration, 'checker'))
+            return cancelledProof(input.root, node, started, lease, worktree, 'checker');
+        await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_checker_started', status: 'running' });
+        const checker = await runLoopCheckerWorkers({
+            root: input.root,
+            plan: input.plan,
+            node,
+            worktree: { id: worktree.worktree_id || lease.worktree_id, path: worktree.path, branch: worktree.branch },
+            // Checker is read-only by definition; fixture mode requires an explicit test-only runtime flag.
+            noMutation: true,
+            makerArtifacts: maker.artifacts
+        });
+        await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_checker_completed', status: checker.ok ? 'running' : 'blocked' });
+        await checkpoint(input.root, node, iteration, 'checker', true);
+        if (!checker.ok)
+            return workerBlockedProof(input.root, node, maker, checker, started, 'checker_failed', lease, worktree);
+        const diff = input.noMutation ? emptyDiff() : await computeLoopDiff({
+            root: input.root,
+            worktreePath: worktree.path,
+            ownerScope: node.owner_scope
+        });
+        const changedFiles = [...new Set([...maker.changed_files, ...diff.changed_files])];
+        const patchBytes = Math.max(diff.patch_bytes, ...maker.patch_candidates.map((artifact) => artifact.length), 0);
+        if (diff.blockers.length)
+            return completedOrBlockedProof({ root: input.root, node, maker, checker, gate: emptyGate(), lease, worktree, diff, changedFiles, patchBytes, started, extraBlockers: diff.blockers });
+        await updateLoopState(input.root, node.mission_id, node.loop_id, { current_phase: 'gates', last_checker_result: 'fresh_checker_passed' });
+        if (await shouldCancel(input.root, node, iteration, 'gates'))
+            return cancelledProof(input.root, node, started, lease, worktree, 'gates');
+        await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_gate_started', status: 'running' });
+        const gate = await runLoopGates({ root: input.root, missionId: node.mission_id, node, gates: node.gates, checkerArtifacts: checker.checker_findings });
+        await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_gate_completed', status: gate.ok ? 'completed' : 'blocked' });
+        return completedOrBlockedProof({ root: input.root, node, maker, checker, gate, lease, worktree, diff, changedFiles, patchBytes, started, extraBlockers: [] });
+    }
+    catch (err) {
+        return blockedProof(input.root, node, [`loop_runtime_exception:${err instanceof Error ? err.message : String(err)}`], started, 'runtime_exception', 'failed', lease, worktree);
+    }
+    finally {
+        if (lease?.status === 'active')
+            await releaseLoopLease(input.root, node.mission_id, node.loop_id).catch(() => undefined);
+    }
+}
+async function completedOrBlockedProof(input) {
+    const blockers = [
+        ...input.extraBlockers,
+        ...(input.gate.blockers || []),
+        ...(input.node.risk.requires_human_handoff ? ['human_handoff_required'] : [])
+    ];
+    const status = blockers.length ? (input.node.risk.requires_human_handoff ? 'handoff' : 'blocked') : 'completed';
+    const proof = buildProof({
+        node: input.node,
+        status,
+        started: input.started,
+        maker: input.maker,
+        checker: input.checker,
+        gate: input.gate,
+        lease: input.lease,
+        worktree: input.worktree,
+        changedFiles: input.changedFiles,
+        patchBytes: input.patchBytes,
+        blockers
+    });
+    await writeProofAndState(input.root, proof);
+    return proof;
+}
+async function workerBlockedProof(root, node, maker, checker, started, reason, lease, worktree) {
+    const blockers = [...maker.blockers, ...(checker?.blockers || []), reason];
+    const proof = buildProof({
+        node,
+        status: 'blocked',
+        started,
+        maker,
+        checker: checker || emptyWorker(node, 'checker'),
+        gate: emptyGate(),
+        lease,
+        worktree,
+        changedFiles: maker.changed_files,
+        patchBytes: 0,
+        blockers
+    });
+    await writeProofAndState(root, proof);
+    return proof;
+}
+async function cancelledProof(root, node, started, lease, worktree, phase) {
+    await checkpointCancelledLoop(root, node, 1, phase);
+    const proof = buildProof({
+        node,
+        status: 'cancelled',
+        started,
+        maker: emptyWorker(node, 'maker'),
+        checker: emptyWorker(node, 'checker'),
+        gate: emptyGate(),
+        lease,
+        worktree,
+        changedFiles: [],
+        patchBytes: 0,
+        blockers: [`loop_cancelled:${phase}`]
+    });
+    await writeProofAndState(root, proof);
+    return proof;
+}
+async function blockedProof(root, node, blockers, started, reason, status = 'handoff', lease, worktree) {
+    const proof = buildProof({
+        node,
+        status,
+        started,
+        maker: emptyWorker(node, 'maker'),
+        checker: emptyWorker(node, 'checker'),
+        gate: emptyGate(),
+        lease: lease || null,
+        worktree: worktree || null,
+        changedFiles: [],
+        patchBytes: 0,
+        blockers: [...blockers, reason]
+    });
+    await writeProofAndState(root, proof);
+    return proof;
+}
+function buildProof(input) {
+    const handoffRequired = input.status === 'handoff';
+    return {
+        schema: 'sks.loop-proof.v1',
+        mission_id: input.node.mission_id,
+        loop_id: input.node.loop_id,
+        status: input.status,
+        iterations: 1,
+        owner_scope: input.node.owner_scope,
+        worktree: {
+            id: input.worktree?.worktree_id || input.lease?.worktree_id || null,
+            path: input.worktree?.path || null,
+            branch: input.worktree?.branch || null
+        },
+        maker_result: {
+            ok: input.maker.ok,
+            worker_count: input.maker.worker_count,
+            artifacts: input.maker.artifacts,
+            patch_candidates: input.maker.patch_candidates,
+            backend: input.maker.backend,
+            changed_files: input.maker.changed_files,
+            runtime_proof_path: input.maker.runtime_proof_path
+        },
+        checker_result: {
+            ok: input.checker.ok,
+            worker_count: input.checker.worker_count,
+            artifacts: input.checker.artifacts,
+            checker_findings: input.checker.checker_findings,
+            blockers: input.checker.blockers,
+            backend: input.checker.backend,
+            fresh_session: input.checker.session_ids.every((session) => !input.maker.session_ids.includes(session)),
+            runtime_proof_path: input.checker.runtime_proof_path
+        },
+        gate_result: input.gate,
+        budget: {
+            used: {
+                wall_ms: Math.max(1, Date.now() - input.started),
+                model_calls: input.node.route === '$Integration' ? 1 : 2,
+                subagents: input.maker.worker_count + input.checker.worker_count,
+                iterations: 1,
+                changed_files: input.changedFiles.length,
+                patch_bytes: input.patchBytes
+            },
+            max: input.node.budget
+        },
+        changed_files: input.changedFiles,
+        patch_bytes: input.patchBytes,
+        handoff: {
+            required: handoffRequired,
+            reason: handoffRequired ? input.blockers.join(',') : null,
+            artifact: handoffRequired ? `${input.node.loop_id}/handoff.md` : null
+        },
+        blockers: [...new Set(input.blockers)]
+    };
+}
+async function writeProofAndState(root, proof) {
+    await writeJsonAtomic(loopProofPath(root, proof.mission_id, proof.loop_id), proof);
+    await updateLoopState(root, proof.mission_id, proof.loop_id, {
+        status: proof.status,
+        current_phase: proof.status === 'completed' ? 'finalizer' : 'handoff',
+        last_gate_result: proof.gate_result.ok ? 'passed' : 'blocked',
+        blockers: proof.blockers,
+        handoff: proof.handoff,
+        budget_used: proof.budget.used
+    });
+    await appendLoopRunLog(root, proof.mission_id, proof.loop_id, { event_type: proof.status === 'completed' ? 'loop_completed' : 'loop_blocked', status: proof.status });
+}
+async function shouldCancel(root, node, iteration, phase) {
+    if (!(await shouldKillLoop(root, node.mission_id, node.loop_id)))
+        return false;
+    await checkpointCancelledLoop(root, node, iteration, phase);
+    return true;
+}
+async function checkpoint(root, node, iteration, phase, resumable) {
+    await writeLoopCheckpoint({
+        root,
+        mission_id: node.mission_id,
+        loop_id: node.loop_id,
+        iteration,
+        phase,
+        state_path: loopStatePath(root, node.mission_id, node.loop_id),
+        proof_path: loopProofPath(root, node.mission_id, node.loop_id),
+        resumable
+    });
+}
+function emptyWorker(node, phase) {
+    return {
+        schema: 'sks.loop-worker-run-result.v1',
+        ok: false,
+        mission_id: node.mission_id,
+        loop_id: node.loop_id,
+        phase,
+        worker_count: 0,
+        backend: 'mock',
+        artifacts: [],
+        patch_candidates: [],
+        checker_findings: [],
+        changed_files: [],
+        blockers: [],
+        runtime_proof_path: null,
+        worker_ids: [],
+        session_ids: []
+    };
+}
+function emptyGate() {
+    return { ok: false, selected_gates: [], passed_gates: [], failed_gates: [], skipped_gates: [], blockers: [] };
+}
+function emptyDiff() {
+    return { changed_files: [], patch_bytes: 0, diff_stat: '', blockers: [] };
+}
+//# sourceMappingURL=loop-runtime.js.map

package/dist/core/loops/loop-scheduler.js

@@ -0,0 +1,69 @@
+import os from 'node:os';
+export function scheduleLoopGraph(nodes, parallelism = 'balanced') {
+    const pending = new Map(nodes.map((node) => [node.loop_id, node]));
+    const completed = new Set();
+    const batches = [];
+    const maxParallel = maxConcurrentLoops(nodes, parallelism);
+    const blockers = [];
+    while (pending.size) {
+        const ready = [...pending.values()].filter((node) => node.dependencies.every((dep) => completed.has(dep)));
+        if (!ready.length) {
+            blockers.push(`loop_dependency_cycle:${[...pending.keys()].join(',')}`);
+            break;
+        }
+        const batch = ready.slice(0, maxParallel);
+        batches.push(batch);
+        for (const node of batch) {
+            pending.delete(node.loop_id);
+            if (node.route !== '$Integration')
+                completed.add(node.loop_id);
+            else
+                completed.add(node.loop_id);
+        }
+    }
+    return { ok: blockers.length === 0, batches, max_active_loops: Math.max(0, ...batches.map((batch) => batch.length)), blockers };
+}
+export function maxConcurrentLoops(nodes, parallelism = 'balanced') {
+    const cores = Math.max(1, os.cpus().length || 1);
+    const base = parallelism === 'safe' ? 2 : parallelism === 'extreme' ? Math.min(16, cores) : Math.min(8, cores);
+    return Math.max(1, Math.min(base, riskAwareLoopCap(nodes, parallelism, cores)));
+}
+function riskAwareLoopCap(nodes, parallelism, cores) {
+    if (parallelism === 'extreme')
+        return Math.min(16, cores);
+    const hasCritical = nodes.some((node) => node.risk.level === 'critical');
+    const hasHigh = nodes.some((node) => node.risk.level === 'high');
+    if (hasCritical)
+        return parallelism === 'safe' ? 1 : Math.max(2, Math.floor(cores / 4));
+    if (hasHigh)
+        return parallelism === 'safe' ? 2 : Math.max(4, Math.floor(cores / 2));
+    return parallelism === 'safe' ? 2 : Math.min(8, cores);
+}
+export function graphProofFromLoopProofs(input) {
+    const selected = [...new Set(input.proofs.flatMap((proof) => proof.gate_result.selected_gates))];
+    const passed = [...new Set(input.proofs.flatMap((proof) => proof.gate_result.passed_gates))];
+    const failed = [...new Set(input.proofs.flatMap((proof) => proof.gate_result.failed_gates))];
+    const skipped = [...new Set(input.proofs.flatMap((proof) => proof.gate_result.skipped_gates))];
+    const blockers = [...new Set(input.proofs.flatMap((proof) => proof.blockers))];
+    const sequential = Math.max(input.wallMs, input.proofs.length * Math.max(1, Math.floor(input.wallMs / Math.max(1, input.maxActiveLoops))));
+    return {
+        schema: 'sks.loop-graph-proof.v1',
+        mission_id: input.missionId,
+        ok: blockers.length === 0 && failed.length === 0,
+        total_loops: input.proofs.length,
+        completed_loops: input.proofs.filter((proof) => proof.status === 'completed').length,
+        blocked_loops: input.proofs.filter((proof) => proof.status === 'blocked').length,
+        failed_loops: input.proofs.filter((proof) => proof.status === 'failed').length,
+        handoff_loops: input.proofs.filter((proof) => proof.status === 'handoff').length,
+        parallelism: {
+            max_active_loops: input.maxActiveLoops,
+            max_active_workers: input.maxActiveWorkers,
+            wall_ms: input.wallMs,
+            sequential_estimate_ms: sequential,
+            speedup_ratio: Number((sequential / Math.max(1, input.wallMs)).toFixed(2))
+        },
+        gates: { selected, passed, failed, skipped },
+        blockers
+    };
+}
+//# sourceMappingURL=loop-scheduler.js.map