sneakoscope 3.1.0 → 3.1.1

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

@@ -1,9 +1,10 @@
 import path from 'node:path';
 export function loopRoot(root, missionId) {
-    return path.join(root, '.sneakoscope', 'missions', missionId, 'loops');
+    const missionsRoot = path.resolve(root, '.sneakoscope', 'missions');
+    return containedJoin(missionsRoot, safeArtifactId('mission', missionId), 'loops');
 }
 export function loopNodeRoot(root, missionId, loopId) {
-    return path.join(loopRoot(root, missionId), loopId);
+    return containedJoin(loopRoot(root, missionId), safeArtifactId('loop', loopId));
 }
 export function loopPlanPath(root, missionId) {
     return path.join(loopRoot(root, missionId), 'loop-plan.json');
@@ -20,9 +21,24 @@ export function loopProofPath(root, missionId, loopId) {
 export function loopBudgetPath(root, missionId, loopId) {
     return path.join(loopNodeRoot(root, missionId, loopId), 'loop-budget.json');
 }
+export function loopCheckpointPath(root, missionId, loopId, iteration, phase) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'checkpoints', `${String(Math.max(1, Math.floor(iteration))).padStart(4, '0')}-${sanitizeArtifactPart(phase)}.json`);
+}
+export function loopLatestCheckpointPath(root, missionId, loopId) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'checkpoint-latest.json');
+}
 export function loopGraphProofPath(root, missionId) {
     return path.join(loopRoot(root, missionId), 'loop-graph-proof.json');
 }
+export function loopIntegrationMergePath(root, missionId) {
+    return path.join(loopRoot(root, missionId), 'integration-merge.json');
+}
+export function loopGptFinalArbiterPath(root, missionId) {
+    return path.join(loopRoot(root, missionId), 'loop-gpt-final-arbiter.json');
+}
+export function loopKillRequestPath(root, missionId) {
+    return path.join(loopRoot(root, missionId), 'kill-request.json');
+}
 export function loopGatePath(root, missionId, loopId, gateId) {
     return path.join(loopNodeRoot(root, missionId, loopId), 'gates', `${sanitizeArtifactPart(gateId)}.json`);
 }
@@ -38,4 +54,19 @@ export function loopOwnerLedgerPath(root, missionId) {
 export function sanitizeArtifactPart(value) {
     return String(value || 'artifact').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 96) || 'artifact';
 }
+function safeArtifactId(kind, value) {
+    const text = String(value || '').trim();
+    const sanitized = sanitizeArtifactPart(text);
+    if (!text || sanitized !== text)
+        throw new Error(`invalid_loop_${kind}_id:${text || 'empty'}`);
+    return sanitized;
+}
+function containedJoin(base, ...parts) {
+    const resolvedBase = path.resolve(base);
+    const target = path.resolve(resolvedBase, ...parts);
+    if (target !== resolvedBase && !target.startsWith(`${resolvedBase}${path.sep}`)) {
+        throw new Error(`loop_artifact_path_escape:${target}`);
+    }
+    return target;
+}
 //# sourceMappingURL=loop-artifacts.js.map

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

@@ -0,0 +1,22 @@
+import { readJson, writeJsonAtomic } from '../fsx.js';
+import { loopCheckpointPath, loopLatestCheckpointPath } from './loop-artifacts.js';
+export async function writeLoopCheckpoint(input) {
+    const checkpoint = {
+        schema: 'sks.loop-checkpoint.v1',
+        mission_id: input.mission_id,
+        loop_id: input.loop_id,
+        iteration: input.iteration,
+        phase: input.phase,
+        state_path: input.state_path,
+        proof_path: input.proof_path,
+        resumable: input.resumable,
+        created_at: new Date().toISOString()
+    };
+    await writeJsonAtomic(loopCheckpointPath(input.root, input.mission_id, input.loop_id, input.iteration, input.phase), checkpoint);
+    await writeJsonAtomic(loopLatestCheckpointPath(input.root, input.mission_id, input.loop_id), checkpoint);
+    return checkpoint;
+}
+export async function readLatestLoopCheckpoint(root, missionId, loopId) {
+    return readJson(loopLatestCheckpointPath(root, missionId, loopId), null);
+}
+//# sourceMappingURL=loop-checkpoint.js.map

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

@@ -1,5 +1,7 @@
 import { readJson, writeJsonAtomic } from '../fsx.js';
 import { loopGraphProofPath, loopProofPath } from './loop-artifacts.js';
+import { runLoopGptFinalArbiter } from './loop-gpt-final-arbiter.js';
+import { mergeLoopWorktrees } from './loop-integration-merge.js';
 import { graphProofFromLoopProofs } from './loop-scheduler.js';
 export async function finalizeLoopGraph(input) {
     const proofs = input.proofs || await Promise.all(input.plan.graph.nodes.map((node) => readJson(loopProofPath(input.root, input.plan.mission_id, node.loop_id), null)));
@@ -11,16 +13,40 @@ export async function finalizeLoopGraph(input) {
         maxActiveWorkers: input.maxActiveWorkers || Math.max(1, realProofs.reduce((sum, proof) => sum + proof.maker_result.worker_count + proof.checker_result.worker_count, 0)),
         wallMs: input.wallMs || 1
     });
+    const integrationMerge = await mergeLoopWorktrees({
+        root: input.root,
+        plan: input.plan,
+        proofs: realProofs
+    });
     const anyHandoff = realProofs.some((proof) => proof.handoff.required);
-    const anySourceMutation = realProofs.some((proof) => proof.changed_files.length > 0);
+    const anySourceMutation = realProofs.some((proof) => proof.changed_files.some((file) => !file.startsWith('.sneakoscope/')));
+    const arbiter = anySourceMutation
+        ? await runLoopGptFinalArbiter({ root: input.root, plan: input.plan, proofs: realProofs, integrationMerge })
+        : null;
+    const blockers = [
+        ...graph.blockers,
+        ...(anyHandoff ? ['loop_handoff_required'] : []),
+        ...(integrationMerge.ok ? [] : integrationMerge.blockers),
+        ...(anySourceMutation && !arbiter ? ['gpt_final_arbiter_missing'] : []),
+        ...(arbiter && !arbiter.ok ? ['gpt_final_arbiter_not_approved', ...arbiter.blockers] : [])
+    ];
     const finalGraph = {
         ...graph,
-        ok: graph.ok && !anyHandoff && (!anySourceMutation || graph.gates.selected.includes('gpt:final-arbiter')),
-        blockers: [
-            ...graph.blockers,
-            ...(anyHandoff ? ['loop_handoff_required'] : []),
-            ...(anySourceMutation && !graph.gates.selected.includes('gpt:final-arbiter') ? ['gpt_final_arbiter_missing'] : [])
-        ]
+        ok: graph.ok && blockers.length === 0,
+        blockers: [...new Set(blockers)],
+        integration_merge: {
+            ok: integrationMerge.ok,
+            artifact_path: `.sneakoscope/missions/${input.plan.mission_id}/loops/integration-merge.json`,
+            applied_loops: integrationMerge.applied_loops,
+            conflict_loops: integrationMerge.conflict_loops
+        },
+        ...(arbiter ? {
+            gpt_final_arbiter: {
+                ok: arbiter.ok,
+                artifact_path: arbiter.artifact_path,
+                verdict: arbiter.verdict
+            }
+        } : {})
     };
     await writeJsonAtomic(loopGraphProofPath(input.root, input.plan.mission_id), finalGraph);
     return finalGraph;

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

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import { readJson } from '../fsx.js';
+export async function resolveLoopGate(root, gateId) {
+    const builtin = builtinLoopGate(gateId);
+    if (builtin)
+        return builtin;
+    const releaseGate = await resolveReleaseGate(root, gateId);
+    if (releaseGate)
+        return releaseGate;
+    const packageGate = await resolvePackageScriptGate(root, gateId);
+    if (packageGate)
+        return packageGate;
+    return null;
+}
+export async function listLoopGateDefinitions(root) {
+    const packageJson = await readJson(path.join(root, 'package.json'), {});
+    const release = await readJson(path.join(root, 'release-gates.v2.json'), {});
+    const packageScripts = packageJson && typeof packageJson === 'object' && packageJson.scripts && typeof packageJson.scripts === 'object'
+        ? Object.keys(packageJson.scripts)
+        : [];
+    const releaseGates = Array.isArray(release.gates) ? release.gates : [];
+    const definitions = [
+        ...['gpt:final-arbiter', 'human:handoff-required', 'loop:checker-fresh-session', 'loop:state-valid', 'loop:budget-valid'].map((id) => builtinLoopGate(id)).filter((row) => Boolean(row)),
+        ...releaseGates.map((gate) => normalizeReleaseGate(gate)).filter((row) => Boolean(row)),
+        ...packageScripts.map((id) => ({
+            id,
+            command: `npm run ${shellQuote(id)} --silent`,
+            source: 'package-json',
+            side_effect: 'hermetic',
+            timeout_ms: 300000,
+            cache_allowed: true
+        }))
+    ];
+    const byId = new Map();
+    for (const definition of definitions)
+        if (!byId.has(definition.id))
+            byId.set(definition.id, definition);
+    return [...byId.values()];
+}
+function builtinLoopGate(gateId) {
+    if (gateId === 'gpt:final-arbiter') {
+        return { id: gateId, command: 'builtin:gpt-final-arbiter', source: 'builtin-pseudo', side_effect: 'read-only', timeout_ms: 300000, cache_allowed: false };
+    }
+    if (gateId === 'human:handoff-required') {
+        return { id: gateId, command: 'builtin:human-handoff-required', source: 'builtin-pseudo', side_effect: 'human', timeout_ms: 0, cache_allowed: false };
+    }
+    if (gateId === 'loop:checker-fresh-session') {
+        return { id: gateId, command: 'builtin:loop-checker-fresh-session', source: 'builtin-pseudo', side_effect: 'read-only', timeout_ms: 30000, cache_allowed: false };
+    }
+    if (gateId === 'loop:state-valid') {
+        return { id: gateId, command: 'builtin:loop-state-valid', source: 'builtin-pseudo', side_effect: 'read-only', timeout_ms: 30000, cache_allowed: true };
+    }
+    if (gateId === 'loop:budget-valid') {
+        return { id: gateId, command: 'builtin:loop-budget-valid', source: 'builtin-pseudo', side_effect: 'read-only', timeout_ms: 30000, cache_allowed: true };
+    }
+    return null;
+}
+async function resolveReleaseGate(root, gateId) {
+    const release = await readJson(path.join(root, 'release-gates.v2.json'), {});
+    const gate = Array.isArray(release.gates) ? release.gates.find((row) => row.id === gateId) : null;
+    return gate ? normalizeReleaseGate(gate) : null;
+}
+function normalizeReleaseGate(gate) {
+    const id = String(gate.id || '');
+    const command = String(gate.command || '');
+    if (!id || !command)
+        return null;
+    return {
+        id,
+        command,
+        source: 'release-gates-v2',
+        side_effect: normalizeSideEffect(gate.side_effect),
+        timeout_ms: Number.isFinite(Number(gate.timeout_ms)) ? Math.max(1, Number(gate.timeout_ms)) : 300000,
+        cache_allowed: gate.cache?.enabled !== false
+    };
+}
+async function resolvePackageScriptGate(root, gateId) {
+    const packageJson = await readJson(path.join(root, 'package.json'), {});
+    if (!packageJson?.scripts || typeof packageJson.scripts !== 'object' || !(gateId in packageJson.scripts))
+        return null;
+    return {
+        id: gateId,
+        command: `npm run ${shellQuote(gateId)} --silent`,
+        source: 'package-json',
+        side_effect: 'hermetic',
+        timeout_ms: 300000,
+        cache_allowed: true
+    };
+}
+function normalizeSideEffect(value) {
+    return value === 'read-only' || value === 'mutation' || value === 'human' ? value : 'hermetic';
+}
+function shellQuote(value) {
+    return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+//# sourceMappingURL=loop-gate-registry.js.map

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

@@ -1,29 +1,177 @@
-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';
 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 skipUnknownFixtureGate = unknown && !packageJson;
+    const blockers = [
+        ...(unknown && !skipUnknownFixtureGate ? [`unknown_loop_gate:${gateId}`] : []),
+        ...(fullReleaseCheckInsideLoop ? ['full_release_check_inside_non_integration_loop'] : [])
+    ];
+    let ok = blockers.length === 0;
+    let skipped = skipUnknownFixtureGate;
+    let exitCode = null;
+    let stdoutTail = '';
+    let stderrTail = '';
+    let timedOut = false;
+    const fixtureMode = process.env.SKS_LOOP_GATE_FIXTURE === '1';
+    if (definition && ok) {
+        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);
+        }
+        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,
+        skipped,
+        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 };
+}
+async function runBuiltinGate(root, missionId, loopId, definition, checkerArtifacts) {
+    if (definition.id === 'gpt:final-arbiter')
+        return { ok: true, skipped: true, blockers: [] };
+    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,61 @@
+import { runGptFinalArbiter } from '../codex-control/gpt-final-arbiter.js';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { loopGptFinalArbiterPath } from './loop-artifacts.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);
+    if (process.env.SKS_LOOP_GPT_FINAL_FIXTURE === '1' || input.forceVerdict) {
+        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' });
+        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 }),
+        verification_results: input.proofs.map((proof) => ({ id: proof.loop_id, ok: proof.status === 'completed', blockers: proof.blockers })),
+        side_effect_report: { schema: 'sks.loop-side-effect-report.v1', ok: true, changed_files: changedFiles },
+        mutation_ledger: { schema: 'sks.loop-mutation-ledger.v1', proofs: input.proofs },
+        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, 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,75 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { runGitCommand } from '../git/git-worktree-runner.js';
+import { guardedWriteFile, guardContextForRoute } from '../safety/mutation-guard.js';
+import { createRequestedScopeContract } from '../safety/requested-scope-contract.js';
+import { loopIntegrationMergePath } from './loop-artifacts.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();
+    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 diff = await runGitCommand(worktreePath, ['diff', '--binary', '--full-index', 'HEAD'], { timeoutMs: 60000 }).catch(() => null);
+            if (!diff?.ok) {
+                blockers.push(`loop_integration_diff_failed:${proof.loop_id}`);
+                conflictLoops.add(proof.loop_id);
+                continue;
+            }
+            if (!diff.stdout.trim())
+                continue;
+            const apply = await runGitCommand(input.root, ['apply', '--whitespace=nowarn', '-'], { input: diff.stdout, timeoutMs: 60000 }).catch(() => null);
+            if (!apply?.ok) {
+                blockers.push(`loop_integration_apply_conflict:${proof.loop_id}`);
+                conflictLoops.add(proof.loop_id);
+                await writeHandoff(input.root, proof.loop_id, apply?.stderr_tail || apply?.stdout_tail || 'git apply failed');
+                continue;
+            }
+            appliedLoops.push(proof.loop_id);
+            for (const file of proof.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)]
+    };
+    await writeJsonAtomic(loopIntegrationMergePath(input.root, input.plan.mission_id), { ...result, generated_at: nowIso() });
+    return result;
+}
+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-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',