sneakoscope 3.1.0 → 3.1.2

package/dist/core/loops/loop-gate-runner.js

@@ -1,29 +1,218 @@
-import { writeJsonAtomic } from '../fsx.js';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { readJson, runProcess, writeJsonAtomic } from '../fsx.js';
 import { allGateIds } from './loop-schema.js';
-import { loopGatePath } from './loop-artifacts.js';
+import { loopBudgetPath, loopGatePath, loopStatePath } from './loop-artifacts.js';
+import { resolveLoopGate } from './loop-gate-registry.js';
+import { decideLoopFixturePolicy, writeLoopFixturePolicyDecision } from './loop-fixture-policy.js';
+import { loopFinalArbiterGateContractRelativePath, writeLoopFinalArbiterGateContract } from './loop-final-arbiter-contract.js';
 export async function runLoopGates(input) {
-    const selected = allGateIds(input.gates).filter((gate) => gate !== 'release:check');
-    const failed = selected.filter((gate) => gate === 'human:handoff-required');
-    const passed = selected.filter((gate) => !failed.includes(gate));
+    const selected = allGateIds(input.gates);
+    const failed = [];
+    const passed = [];
+    const skipped = [];
+    const blockers = [];
     for (const gate of selected) {
-        await writeJsonAtomic(loopGatePath(input.root, input.missionId, input.node.loop_id, gate), {
-            schema: 'sks.loop-gate-result.v1',
-            ok: !failed.includes(gate),
-            gate_id: gate,
-            loop_id: input.node.loop_id,
-            timeout_ms: input.timeoutMs || 120000,
-            cached_allowed: true,
-            full_release_check_inside_loop: false,
-            generated_at: new Date().toISOString()
-        });
+        const result = await runOneGate(input, gate);
+        if (result.skipped)
+            skipped.push(gate);
+        else if (result.ok)
+            passed.push(gate);
+        else
+            failed.push(gate);
+        blockers.push(...result.blockers);
     }
     return {
         ok: failed.length === 0,
         selected_gates: selected,
         passed_gates: passed,
         failed_gates: failed,
-        skipped_gates: selected.includes('release:check') ? ['release:check'] : [],
-        blockers: failed.map((gate) => `gate_failed:${gate}`)
+        skipped_gates: skipped,
+        blockers
     };
 }
+async function runOneGate(input, gateId) {
+    const started = Date.now();
+    const definition = await resolveLoopGate(input.root, gateId);
+    const fullReleaseCheckInsideLoop = gateId === 'release:check' && input.node.route !== '$Integration';
+    const unknown = !definition;
+    const packageJson = unknown ? await readJson(path.join(input.root, 'package.json'), null) : null;
+    const fixtureMode = process.env.SKS_LOOP_GATE_FIXTURE === '1';
+    const fixtureDecision = decideLoopFixturePolicy({
+        root: input.root,
+        missionId: input.missionId,
+        mode: 'gate',
+        requested: fixtureMode || (unknown && !packageJson)
+    });
+    if (fixtureDecision.requested)
+        await writeLoopFixturePolicyDecision(input.root, input.missionId, fixtureDecision).catch(() => undefined);
+    const skipUnknownFixtureGate = unknown && !packageJson && fixtureDecision.allowed;
+    const blockers = [
+        ...(unknown && !skipUnknownFixtureGate ? [`unknown_loop_gate:${gateId}`] : []),
+        ...(fullReleaseCheckInsideLoop ? ['full_release_check_inside_non_integration_loop'] : []),
+        ...(fixtureMode && !fixtureDecision.allowed ? [...fixtureDecision.blockers, 'loop_gate_fixture_forbidden_in_production'] : [])
+    ];
+    let ok = blockers.length === 0;
+    let skipped = skipUnknownFixtureGate;
+    let exitCode = null;
+    let stdoutTail = '';
+    let stderrTail = '';
+    let timedOut = false;
+    let handledBy;
+    let deferredContractPath;
+    let deferredReason;
+    if (definition && ok) {
+        if (fixtureMode && !fixtureDecision.allowed) {
+            ok = false;
+        }
+        else if (fixtureMode && definition.source !== 'builtin-pseudo') {
+            ok = true;
+        }
+        else if (definition.source === 'builtin-pseudo') {
+            const builtin = await runBuiltinGate(input.root, input.missionId, input.node.loop_id, definition, input.checkerArtifacts || []);
+            ok = builtin.ok;
+            skipped = builtin.skipped;
+            blockers.push(...builtin.blockers);
+            handledBy = builtin.handled_by;
+            deferredContractPath = builtin.deferred_contract_path;
+            deferredReason = builtin.deferred_reason;
+        }
+        else {
+            const command = definition.command;
+            const result = await runProcess(process.env.SHELL || '/bin/sh', ['-lc', command], {
+                cwd: input.root,
+                timeoutMs: input.timeoutMs || definition.timeout_ms,
+                maxOutputBytes: 512 * 1024,
+                env: {
+                    SKS_LOOP_ID: input.node.loop_id,
+                    SKS_MISSION_ID: input.missionId,
+                    SKS_LOOP_GATE: gateId
+                }
+            });
+            exitCode = result.code;
+            stdoutTail = result.stdout.slice(-8000);
+            stderrTail = result.stderr.slice(-8000);
+            timedOut = result.timedOut;
+            ok = result.code === 0;
+            if (!ok)
+                blockers.push(`gate_command_failed:${gateId}:${result.code}`);
+        }
+    }
+    const artifact = {
+        schema: 'sks.loop-gate-result.v1',
+        ok,
+        gate_id: gateId,
+        loop_id: input.node.loop_id,
+        command: definition?.command || null,
+        source: definition?.source || null,
+        exit_code: exitCode,
+        duration_ms: Math.max(1, Date.now() - started),
+        stdout_tail: stdoutTail,
+        stderr_tail: stderrTail,
+        cached_allowed: definition?.cache_allowed ?? false,
+        fixture_mode: fixtureMode,
+        fixture_policy: fixtureDecision,
+        fixture_allowed_reason: fixtureDecision.allowed ? fixtureDecision.reason : null,
+        skipped,
+        handled_by: handledBy,
+        deferred_contract_path: deferredContractPath,
+        deferred_reason: deferredReason,
+        deferred_unknown_fixture_gate: skipUnknownFixtureGate,
+        timed_out: timedOut,
+        full_release_check_inside_loop: fullReleaseCheckInsideLoop,
+        generated_at: new Date().toISOString(),
+        blockers
+    };
+    await writeJsonAtomic(loopGatePath(input.root, input.missionId, input.node.loop_id, gateId), artifact);
+    return {
+        ok,
+        skipped,
+        blockers,
+        ...(handledBy ? { handled_by: handledBy } : {}),
+        ...(deferredContractPath ? { deferred_contract_path: deferredContractPath } : {}),
+        ...(deferredReason ? { deferred_reason: deferredReason } : {})
+    };
+}
+async function runBuiltinGate(root, missionId, loopId, definition, checkerArtifacts) {
+    if (definition.id === 'gpt:final-arbiter') {
+        await writeLoopFinalArbiterGateContract(root, missionId);
+        return {
+            ok: true,
+            skipped: true,
+            blockers: [],
+            handled_by: 'loop-finalizer',
+            deferred_contract_path: loopFinalArbiterGateContractRelativePath(missionId),
+            deferred_reason: 'gpt_final_arbiter_runs_after_integration_merge'
+        };
+    }
+    if (definition.id === 'human:handoff-required')
+        return { ok: false, skipped: false, blockers: ['human_handoff_required'] };
+    if (definition.id === 'loop:state-valid') {
+        const state = await readJson(loopStatePath(root, missionId, loopId), null);
+        return state?.schema === 'sks.loop-state.v1' ? { ok: true, skipped: false, blockers: [] } : { ok: false, skipped: false, blockers: ['loop_state_invalid'] };
+    }
+    if (definition.id === 'loop:budget-valid') {
+        const budget = await readJson(loopBudgetPath(root, missionId, loopId), null);
+        return budget && typeof budget === 'object' ? { ok: true, skipped: false, blockers: [] } : { ok: false, skipped: false, blockers: ['loop_budget_invalid'] };
+    }
+    if (definition.id === 'loop:checker-fresh-session') {
+        const artifacts = await Promise.all(checkerArtifacts.map((artifact) => readCheckerArtifact(root, missionId, artifact)));
+        const fresh = artifacts.some((artifact) => artifact?.fresh_session === true && artifact?.approved === true);
+        return fresh ? { ok: true, skipped: false, blockers: [] } : { ok: false, skipped: false, blockers: ['loop_checker_fresh_session_missing'] };
+    }
+    return { ok: false, skipped: false, blockers: [`unknown_builtin_gate:${definition.id}`] };
+}
+async function readCheckerArtifact(root, missionId, artifact) {
+    for (const candidate of checkerArtifactPathCandidates(root, missionId, artifact)) {
+        const readable = await checkerArtifactReadablePath(root, missionId, candidate);
+        if (!readable)
+            continue;
+        const row = await readJson(readable, null);
+        if (row)
+            return row;
+    }
+    return null;
+}
+function checkerArtifactPathCandidates(root, missionId, artifact) {
+    const raw = String(artifact || '').trim();
+    if (!raw)
+        return [];
+    const missionRoot = path.join(root, '.sneakoscope', 'missions', missionId);
+    const resolvedMissionRoot = path.resolve(missionRoot);
+    if (path.isAbsolute(raw)) {
+        return [path.resolve(raw)];
+    }
+    return uniqueStrings([
+        safeResolveWithin(path.join(resolvedMissionRoot, 'agents'), raw),
+        safeResolveWithin(resolvedMissionRoot, raw),
+        safeResolveWithin(path.join(resolvedMissionRoot, 'loops'), raw)
+    ].filter((value) => Boolean(value)));
+}
+function uniqueStrings(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+async function checkerArtifactReadablePath(root, missionId, candidate) {
+    const resolvedMissionRoot = path.resolve(root, '.sneakoscope', 'missions', missionId);
+    const resolvedCandidate = path.resolve(candidate);
+    try {
+        const [realMissionRoot, realCandidate] = await Promise.all([
+            fsp.realpath(resolvedMissionRoot),
+            fsp.realpath(resolvedCandidate)
+        ]);
+        return isWithinPath(realMissionRoot, realCandidate) ? realCandidate : null;
+    }
+    catch {
+        return null;
+    }
+}
+function safeResolveWithin(base, target) {
+    const resolvedBase = path.resolve(base);
+    const resolvedTarget = path.resolve(resolvedBase, target);
+    return isWithinPath(resolvedBase, resolvedTarget) ? resolvedTarget : null;
+}
+function isWithinPath(base, target) {
+    const resolvedBase = path.resolve(base);
+    const resolvedTarget = path.resolve(target);
+    return resolvedTarget === resolvedBase || resolvedTarget.startsWith(`${resolvedBase}${path.sep}`);
+}
 //# sourceMappingURL=loop-gate-runner.js.map

package/dist/core/loops/loop-gpt-final-arbiter.js

@@ -0,0 +1,81 @@
+import { runGptFinalArbiter } from '../codex-control/gpt-final-arbiter.js';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { loopGptFinalArbiterPath } from './loop-artifacts.js';
+import { decideLoopFixturePolicy, writeLoopFixturePolicyDecision } from './loop-fixture-policy.js';
+export async function runLoopGptFinalArbiter(input) {
+    const artifactPath = loopGptFinalArbiterPath(input.root, input.plan.mission_id);
+    const changedFiles = [...new Set([
+            ...input.integrationMerge.changed_files,
+            ...input.proofs.flatMap((proof) => proof.changed_files)
+        ])];
+    const reviewedLoopIds = input.proofs.map((proof) => proof.loop_id);
+    const fixtureRequested = process.env.SKS_LOOP_GPT_FINAL_FIXTURE === '1' || Boolean(input.forceVerdict);
+    const fixtureDecision = decideLoopFixturePolicy({
+        root: input.root,
+        missionId: input.plan.mission_id,
+        mode: 'gpt-final',
+        requested: fixtureRequested
+    });
+    if (fixtureRequested)
+        await writeLoopFixturePolicyDecision(input.root, input.plan.mission_id, fixtureDecision).catch(() => undefined);
+    if (fixtureRequested && !fixtureDecision.allowed) {
+        const result = buildResult(input.plan.mission_id, reviewedLoopIds, changedFiles, 'reject', [], artifactPath, [...fixtureDecision.blockers, 'loop_gpt_final_fixture_forbidden_in_production']);
+        await writeJsonAtomic(artifactPath, { ...result, generated_at: nowIso(), backend: 'fixture-forbidden', fixture_policy: fixtureDecision });
+        return result;
+    }
+    if (fixtureRequested) {
+        const verdict = input.forceVerdict || (process.env.SKS_LOOP_GPT_FINAL_REJECT === '1' ? 'reject' : 'approve');
+        const result = buildResult(input.plan.mission_id, reviewedLoopIds, changedFiles, verdict, verdict === 'approve' ? [] : ['fixture_revision_required'], artifactPath, []);
+        await writeJsonAtomic(artifactPath, { ...result, generated_at: nowIso(), backend: 'fixture', fixture_policy: fixtureDecision, fixture_allowed_reason: fixtureDecision.reason, side_effect_report: input.sideEffectReport || null });
+        return result;
+    }
+    if (input.sideEffectReport && !input.sideEffectReport.ok) {
+        const result = buildResult(input.plan.mission_id, reviewedLoopIds, changedFiles, 'reject', [], artifactPath, input.sideEffectReport.blockers);
+        await writeJsonAtomic(artifactPath, { ...result, generated_at: nowIso(), backend: 'side-effect-block', side_effect_report: input.sideEffectReport });
+        return result;
+    }
+    const arbiter = await runGptFinalArbiter({
+        schema: 'sks.gpt-final-arbiter-input.v1',
+        route: '$Loop',
+        mission_id: input.plan.mission_id,
+        local_mode: 'local-parallel-gpt-final',
+        local_outputs: input.proofs.map((proof) => ({
+            id: proof.loop_id,
+            backend: proof.maker_result.backend || 'loop-worker',
+            status: proof.status,
+            summary: proof.blockers.join(', ') || 'loop proof completed',
+            changed_files: proof.changed_files,
+            blockers: proof.blockers
+        })),
+        candidate_diff: JSON.stringify({ changed_files: changedFiles, integration_merge: input.integrationMerge, side_effect_report: input.sideEffectReport || null }),
+        verification_results: input.proofs.map((proof) => ({ id: proof.loop_id, ok: proof.status === 'completed', blockers: proof.blockers })),
+        side_effect_report: input.sideEffectReport || { schema: 'sks.loop-side-effect-report.v1', ok: true, changed_files: changedFiles },
+        mutation_ledger: { schema: 'sks.loop-mutation-ledger.v1', proofs: input.proofs, path: input.sideEffectReport?.mutation_ledger_path || null },
+        rollback_plan: { schema: 'sks.loop-rollback-plan.v1', strategy: 'git-worktree-or-human-handoff' }
+    }, { cwd: input.root, mutationLedgerRoot: `${input.root}/.sneakoscope/missions/${input.plan.mission_id}/loops/gpt-final-arbiter` });
+    const status = String(arbiter.result?.status || '');
+    const verdict = status === 'approved' || status === 'modified' ? 'approve' : status === 'needs_more_work' ? 'revise' : 'reject';
+    const blockers = stringArray(arbiter.blockers);
+    const result = buildResult(input.plan.mission_id, reviewedLoopIds, changedFiles, verdict, stringArray(arbiter.result?.required_followup_work), artifactPath, blockers);
+    await writeJsonAtomic(artifactPath, { ...result, generated_at: nowIso(), backend: arbiter.backend || null, side_effect_report: input.sideEffectReport || null, arbiter });
+    return result;
+}
+function buildResult(missionId, reviewedLoopIds, changedFiles, verdict, revisions, artifactPath, blockers) {
+    return {
+        schema: 'sks.loop-gpt-final-arbiter.v1',
+        ok: verdict === 'approve' && blockers.length === 0,
+        mission_id: missionId,
+        reviewed_loop_ids: reviewedLoopIds,
+        changed_files: changedFiles,
+        verdict,
+        required_revisions: revisions,
+        blockers,
+        artifact_path: artifactPath
+    };
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((item) => typeof item === 'string' ? item : JSON.stringify(item)).filter(Boolean);
+}
+//# sourceMappingURL=loop-gpt-final-arbiter.js.map

package/dist/core/loops/loop-integration-merge.js

@@ -0,0 +1,80 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { guardedWriteFile, guardContextForRoute } from '../safety/mutation-guard.js';
+import { createRequestedScopeContract } from '../safety/requested-scope-contract.js';
+import { loopIntegrationMergePath } from './loop-artifacts.js';
+import { mergeSingleLoopWorktree } from './loop-merge-strategy.js';
+export async function mergeLoopWorktrees(input) {
+    const completed = input.proofs.filter((proof) => proof.status === 'completed' && proof.loop_id !== input.plan.integration_loop_id);
+    const blockers = [];
+    const appliedLoops = [];
+    const conflictLoops = new Set();
+    const changedFiles = new Set();
+    const owners = new Map();
+    const mergeAttempts = {};
+    for (const proof of completed) {
+        for (const file of proof.changed_files) {
+            const previous = owners.get(file);
+            if (previous && previous !== proof.loop_id) {
+                blockers.push(`loop_integration_file_conflict:${file}:${previous}:${proof.loop_id}`);
+                conflictLoops.add(previous);
+                conflictLoops.add(proof.loop_id);
+            }
+            else {
+                owners.set(file, proof.loop_id);
+            }
+        }
+    }
+    if (!blockers.length) {
+        for (const proof of completed) {
+            const worktreePath = proof.worktree.path;
+            if (!worktreePath)
+                continue;
+            const merge = await mergeSingleLoopWorktree({ root: input.root, proof, worktreePath, allowBranchMerge: true });
+            mergeAttempts[proof.loop_id] = merge;
+            if (!merge.ok) {
+                blockers.push(...merge.blockers, `loop_integration_merge_conflict:${proof.loop_id}`);
+                conflictLoops.add(proof.loop_id);
+                await writeHandoff(input.root, proof.loop_id, merge.blockers.join('\n') || 'loop merge strategy failed');
+                continue;
+            }
+            appliedLoops.push(proof.loop_id);
+            for (const file of merge.changed_files)
+                changedFiles.add(file);
+        }
+    }
+    const result = {
+        schema: 'sks.loop-integration-merge.v1',
+        ok: blockers.length === 0,
+        applied_loops: appliedLoops,
+        conflict_loops: [...conflictLoops],
+        changed_files: [...changedFiles],
+        blockers: [...new Set(blockers)],
+        merge_attempts: mergeAttempts,
+        strategy_summary: summarizeStrategies(Object.values(mergeAttempts))
+    };
+    await writeJsonAtomic(loopIntegrationMergePath(input.root, input.plan.mission_id), { ...result, generated_at: nowIso() });
+    return result;
+}
+function summarizeStrategies(results) {
+    return {
+        apply_count: results.filter((row) => row.selected_strategy === 'apply').length,
+        apply_3way_count: results.filter((row) => row.selected_strategy === 'apply-3way').length,
+        cherry_pick_count: results.filter((row) => row.selected_strategy === 'cherry-pick').length,
+        merge_no_commit_count: results.filter((row) => row.selected_strategy === 'merge-no-commit').length,
+        handoff_count: results.filter((row) => row.selected_strategy === 'handoff' || !row.ok).length
+    };
+}
+async function writeHandoff(root, loopId, detail) {
+    const contract = createRequestedScopeContract({
+        route: '$Loop',
+        userRequest: 'Write loop integration conflict handoff inside project .sneakoscope.',
+        projectRoot: root
+    });
+    const handoffPath = path.join(root, '.sneakoscope', `loop-integration-conflict-${safeArtifactId(loopId)}.txt`);
+    await guardedWriteFile(guardContextForRoute(root, contract, 'loop integration conflict handoff'), handoffPath, detail).catch(() => undefined);
+}
+function safeArtifactId(value) {
+    return String(value || 'unknown').replace(/[^A-Za-z0-9_.-]/g, '_').slice(0, 80) || 'unknown';
+}
+//# sourceMappingURL=loop-integration-merge.js.map

package/dist/core/loops/loop-interrupt-registry.js

@@ -0,0 +1,118 @@
+import process from 'node:process';
+import { appendJsonl, readText, writeJsonAtomic } from '../fsx.js';
+import { guardContextForRoute, guardedProcessKill } from '../safety/mutation-guard.js';
+import { createRequestedScopeContract } from '../safety/requested-scope-contract.js';
+import { loopActiveWorkerHandlesPath, loopInterruptResultPath } from './loop-artifacts.js';
+export async function registerLoopActiveWorker(root, handle) {
+    const row = {
+        schema: 'sks.loop-active-worker-handle.v1',
+        mission_id: handle.mission_id,
+        loop_id: handle.loop_id,
+        phase: handle.phase,
+        worker_id: handle.worker_id,
+        session_id: handle.session_id,
+        pid: handle.pid,
+        started_at: handle.started_at || new Date().toISOString(),
+        interrupt_supported: handle.interrupt_supported,
+        status: handle.status || 'running'
+    };
+    await appendJsonl(loopActiveWorkerHandlesPath(root, handle.mission_id), row);
+    return row;
+}
+export async function markLoopWorkerInterrupted(root, missionId, workerId, status = 'interrupted') {
+    const handles = await readLoopActiveWorkers(root, missionId);
+    await appendJsonl(loopActiveWorkerHandlesPath(root, missionId), {
+        ...(handles.find((handle) => handle.worker_id === workerId) || {
+            schema: 'sks.loop-active-worker-handle.v1',
+            mission_id: missionId,
+            loop_id: 'unknown',
+            phase: 'maker',
+            session_id: null,
+            pid: null,
+            started_at: new Date().toISOString(),
+            interrupt_supported: false
+        }),
+        worker_id: workerId,
+        status
+    });
+}
+export async function readLoopActiveWorkers(root, missionId) {
+    const text = await readText(loopActiveWorkerHandlesPath(root, missionId), '');
+    const byWorker = new Map();
+    for (const line of String(text).split(/\r?\n/).map((row) => row.trim()).filter(Boolean)) {
+        try {
+            const row = JSON.parse(line);
+            if (row?.schema === 'sks.loop-active-worker-handle.v1' && row.worker_id)
+                byWorker.set(row.worker_id, row);
+        }
+        catch { }
+    }
+    return [...byWorker.values()];
+}
+export async function interruptLoopWorkers(input) {
+    const handles = (await readLoopActiveWorkers(input.root, input.missionId))
+        .filter((handle) => handle.status === 'running' && (input.target === 'all' || handle.loop_id === input.target || handle.worker_id === input.target));
+    const killContract = createRequestedScopeContract({
+        route: 'loop:interrupt-registry',
+        userRequest: 'Terminate only registered loop worker processes for an explicit loop interrupt request.',
+        projectRoot: input.root,
+        overrides: { codex_app_process: true }
+    });
+    const killGuard = guardContextForRoute(input.root, killContract, `loop worker interrupt:${input.missionId}:${input.target}`);
+    const interrupted = [];
+    const failed = [];
+    const blockers = [];
+    for (const handle of handles) {
+        if (handle.pid && handle.interrupt_supported) {
+            try {
+                await guardedProcessKill(killGuard, handle.pid, { signal: 'SIGTERM', confirmed: true });
+                await sleep(input.graceMs ?? 250);
+                if (processStillExists(handle.pid)) {
+                    try {
+                        await guardedProcessKill(killGuard, handle.pid, { signal: 'SIGKILL', confirmed: true });
+                    }
+                    catch { }
+                }
+                await markLoopWorkerInterrupted(input.root, input.missionId, handle.worker_id, 'interrupted');
+                interrupted.push(handle.worker_id);
+            }
+            catch (err) {
+                failed.push(handle.worker_id);
+                blockers.push(`loop_worker_interrupt_failed:${handle.worker_id}:${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        else if (handle.session_id) {
+            await markLoopWorkerInterrupted(input.root, input.missionId, handle.worker_id, 'interrupted');
+            interrupted.push(handle.worker_id);
+        }
+        else {
+            failed.push(handle.worker_id);
+            blockers.push(`loop_worker_interrupt_unsupported:${handle.worker_id}`);
+        }
+    }
+    const result = {
+        schema: 'sks.loop-interrupt-result.v1',
+        ok: blockers.length === 0,
+        mission_id: input.missionId,
+        target: input.target,
+        interrupted,
+        failed,
+        handles,
+        blockers
+    };
+    await writeJsonAtomic(loopInterruptResultPath(input.root, input.missionId), { ...result, generated_at: new Date().toISOString() });
+    return result;
+}
+function processStillExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+//# sourceMappingURL=loop-interrupt-registry.js.map

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

@@ -1,30 +1,38 @@
 import { loopOwnerLedgerPath } from './loop-artifacts.js';
 import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { withFileLock } from '../locks/file-lock.js';
 export async function acquireLoopLease(root, plan, node) {
-    const blockers = await detectLoopLeaseConflicts(root, plan.mission_id, node);
-    const lease = {
-        schema: 'sks.loop-lease.v1',
-        mission_id: plan.mission_id,
-        loop_id: node.loop_id,
-        owner_scope: node.owner_scope,
-        acquired_at: nowIso(),
-        expires_at: new Date(Date.now() + Math.max(60_000, node.budget.max_wall_ms)).toISOString(),
-        status: blockers.length ? 'conflict' : 'active',
-        worktree_id: node.worktree.required ? `sks-loop-${node.loop_id}` : null,
-        blockers
-    };
-    const ledger = await readLoopOwnerLedger(root, plan.mission_id);
-    const leases = ledger.leases.filter((row) => row.loop_id !== node.loop_id);
-    leases.push(lease);
-    await writeLoopOwnerLedger(root, plan.mission_id, leases);
-    return lease;
+    return withLoopOwnerLedgerLock(root, plan.mission_id, async () => {
+        const blockers = await detectLoopLeaseConflictsUnderLock(root, plan.mission_id, node);
+        const lease = {
+            schema: 'sks.loop-lease.v1',
+            mission_id: plan.mission_id,
+            loop_id: node.loop_id,
+            owner_scope: node.owner_scope,
+            acquired_at: nowIso(),
+            expires_at: new Date(Date.now() + Math.max(60_000, node.budget.max_wall_ms)).toISOString(),
+            status: blockers.length ? 'conflict' : 'active',
+            worktree_id: node.worktree.required ? `sks-loop-${node.loop_id}` : null,
+            blockers
+        };
+        const ledger = await readLoopOwnerLedger(root, plan.mission_id);
+        const leases = ledger.leases.filter((row) => row.loop_id !== node.loop_id);
+        leases.push(lease);
+        await writeLoopOwnerLedger(root, plan.mission_id, leases);
+        return lease;
+    });
 }
 export async function releaseLoopLease(root, missionId, loopId) {
-    const ledger = await readLoopOwnerLedger(root, missionId);
-    const leases = ledger.leases.map((lease) => lease.loop_id === loopId ? { ...lease, status: 'released' } : lease);
-    await writeLoopOwnerLedger(root, missionId, leases);
+    await withLoopOwnerLedgerLock(root, missionId, async () => {
+        const ledger = await readLoopOwnerLedger(root, missionId);
+        const leases = ledger.leases.map((lease) => lease.loop_id === loopId ? { ...lease, status: 'released' } : lease);
+        await writeLoopOwnerLedger(root, missionId, leases);
+    });
 }
 export async function detectLoopLeaseConflicts(root, missionId, node) {
+    return withLoopOwnerLedgerLock(root, missionId, () => detectLoopLeaseConflictsUnderLock(root, missionId, node));
+}
+async function detectLoopLeaseConflictsUnderLock(root, missionId, node) {
     const ledger = await readLoopOwnerLedger(root, missionId);
     const active = ledger.leases.filter((lease) => lease.status === 'active' && Date.parse(lease.expires_at) > Date.now());
     const blockers = [];
@@ -49,6 +57,13 @@ export async function detectLoopLeaseConflicts(root, missionId, node) {
     }
     return [...new Set(blockers)];
 }
+async function withLoopOwnerLedgerLock(root, missionId, fn) {
+    return withFileLock({
+        lockPath: `${root}/.sneakoscope/locks/loop-owner-ledger-${missionId}.lock`,
+        timeoutMs: 30000,
+        staleMs: 5 * 60 * 1000
+    }, fn);
+}
 async function readLoopOwnerLedger(root, missionId) {
     return readJson(loopOwnerLedgerPath(root, missionId), {
         schema: 'sks.loop-owner-ledger.v1',