sneakoscope 3.0.4 → 3.1.1

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

@@ -0,0 +1,16 @@
+export const LOOP_LEVEL_ORDER = ['L0-report', 'L1-assisted', 'L2-action', 'L3-unattended'];
+export function canEscalateLoopLevel(input) {
+    const blockers = [
+        ...(!input.previousProof?.gate_result.ok ? ['previous_level_proof_not_passed'] : []),
+        ...(input.previousProof && input.previousProof.budget.used.iterations >= input.node.budget.max_iterations ? ['loop_budget_exhausted'] : []),
+        ...(['high', 'critical'].includes(input.node.risk.level) && input.node.level === 'L3-unattended' ? ['high_risk_l3_blocked'] : []),
+        ...(!input.ownerLeaseAcquired ? ['owner_lease_missing'] : []),
+        ...(input.node.level === 'L2-action' && !input.node.checker.required_before_next_iteration ? ['checker_required_for_l2'] : []),
+        ...(input.node.level === 'L3-unattended' && input.node.dependencies.length === 0 ? ['new_domain_cannot_start_l3'] : [])
+    ];
+    return { ok: blockers.length === 0, blockers };
+}
+export function sourceMutationRequiresGptFinal(node) {
+    return node.level === 'L2-action' || node.risk.requires_gpt_final || node.gates.final.includes('gpt:final-arbiter');
+}
+//# sourceMappingURL=loop-gate-ladder.js.map

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

@@ -0,0 +1,177 @@
+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 { loopBudgetPath, loopGatePath, loopStatePath } from './loop-artifacts.js';
+import { resolveLoopGate } from './loop-gate-registry.js';
+export async function runLoopGates(input) {
+    const selected = allGateIds(input.gates);
+    const failed = [];
+    const passed = [];
+    const skipped = [];
+    const blockers = [];
+    for (const gate of selected) {
+        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: 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-gate-selector.js

@@ -0,0 +1,52 @@
+export function selectLoopGates(input) {
+    const files = input.changedFiles.join(' ');
+    const triage = ['loop:state-valid', 'loop:budget-valid'];
+    const local = new Set();
+    if (input.node.level === 'L0-report')
+        return { triage, local: [], checker: [], integration: [], final: [] };
+    if (isDocsOnly(input.changedFiles, input.node))
+        add(local, ['docs:loop-runtime', 'changelog:check']);
+    else if (/zellij/.test(files) || input.node.loop_id.includes('zellij'))
+        add(local, ['zellij:slot-telemetry-live-flush', 'zellij:slot-pane-stale-detection']);
+    else if (/release/.test(files) || input.node.loop_id.includes('release'))
+        add(local, ['release:affected-selector', 'release:dynamic-presets']);
+    else if (/research/.test(files) || input.node.loop_id.includes('research'))
+        add(local, ['research:quality-contract']);
+    else if (/qa-loop/.test(files) || input.node.loop_id.includes('qa-loop'))
+        add(local, ['qa-loop:app-handoff-gate-lifecycle']);
+    else if (/codex/.test(files) || input.node.loop_id.includes('codex'))
+        add(local, ['codex:0139-capability', 'codex-sdk:version-compat']);
+    else if (/mad-db|db-safety/.test(files) || input.node.loop_id.includes('mad-db'))
+        add(local, ['mad-db:safety-conflict-matrix', 'mad-db:operation-lifecycle-ledger']);
+    else if (/agent|scheduler|native-swarm/.test(files) || input.node.loop_id.includes('naruto'))
+        add(local, ['parallel:runtime-real-blackbox', 'scheduler:utilization-proof']);
+    else
+        add(local, ['loop:affected']);
+    const integration = new Set();
+    if ((input.packageScriptsChanged || []).length || (input.releaseGateIdsChanged || []).length || files.includes('package.json') || files.includes('release-gates.v2.json')) {
+        integration.add('release:dag-full-coverage');
+    }
+    if (input.risk.level === 'high')
+        integration.add('loop:integration-required');
+    const final = new Set();
+    if (input.changedFiles.length || input.risk.requires_gpt_final)
+        final.add('gpt:final-arbiter');
+    if (input.risk.level === 'critical')
+        final.add('human:handoff-required');
+    return {
+        triage,
+        local: [...local],
+        checker: input.node.level === 'L2-action' ? ['loop:checker-fresh-session'] : [],
+        integration: [...integration],
+        final: [...final]
+    };
+}
+function isDocsOnly(files, node) {
+    const scoped = [...files, ...node.owner_scope.files, ...node.owner_scope.directories];
+    return scoped.length > 0 && scoped.every((file) => file === 'README.md' || file === 'CHANGELOG.md' || file.startsWith('docs'));
+}
+function add(target, values) {
+    for (const value of values)
+        target.add(value);
+}
+//# sourceMappingURL=loop-gate-selector.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-iteration-runner.js

@@ -0,0 +1,2 @@
+export { runLoopNode } from './loop-runtime.js';
+//# sourceMappingURL=loop-iteration-runner.js.map

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

@@ -0,0 +1,91 @@
+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) {
+    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) {
+    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 = [];
+    for (const lease of active) {
+        if (lease.loop_id === node.loop_id)
+            continue;
+        if (overlap(lease.owner_scope.files, node.owner_scope.files).length && (lease.owner_scope.exclusive || node.owner_scope.exclusive)) {
+            blockers.push(`lease_file_conflict:${lease.loop_id}`);
+        }
+        if (overlap(lease.owner_scope.package_scripts, node.owner_scope.package_scripts).length)
+            blockers.push(`lease_package_script_conflict:${lease.loop_id}`);
+        if (node.owner_scope.files.includes('release-gates.v2.json') || lease.owner_scope.files.includes('release-gates.v2.json')) {
+            blockers.push(`lease_release_gates_integration_only:${lease.loop_id}`);
+        }
+        const docsOnly = allDocs(lease.owner_scope) && allDocs(node.owner_scope);
+        if (docsOnly) {
+            for (let i = blockers.length - 1; i >= 0; i -= 1) {
+                if (blockers[i]?.includes(lease.loop_id))
+                    blockers.splice(i, 1);
+            }
+        }
+    }
+    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',
+        mission_id: missionId,
+        updated_at: nowIso(),
+        leases: []
+    });
+}
+async function writeLoopOwnerLedger(root, missionId, leases) {
+    await writeJsonAtomic(loopOwnerLedgerPath(root, missionId), {
+        schema: 'sks.loop-owner-ledger.v1',
+        mission_id: missionId,
+        updated_at: nowIso(),
+        leases
+    });
+}
+function overlap(a, b) {
+    const rhs = new Set(b);
+    return a.filter((value) => rhs.has(value));
+}
+function allDocs(scope) {
+    const values = [...scope.files, ...scope.directories];
+    return values.length > 0 && values.every((value) => value === 'README.md' || value === 'CHANGELOG.md' || value.startsWith('docs'));
+}
+//# sourceMappingURL=loop-lease.js.map

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

@@ -0,0 +1,19 @@
+import { readJson } from '../fsx.js';
+import { loopGraphProofPath } from './loop-artifacts.js';
+export async function readLoopGraphProof(root, missionId) {
+    return readJson(loopGraphProofPath(root, missionId), null);
+}
+export function summarizeLoopGraphProof(proof) {
+    if (!proof)
+        return { total: 0, running: 0, completed: 0, blocked: 0, speedup_ratio: 0, active_loop_ids: [], blocked_loop_ids: [] };
+    return {
+        total: proof.total_loops,
+        running: Math.max(0, proof.total_loops - proof.completed_loops - proof.blocked_loops - proof.failed_loops - proof.handoff_loops),
+        completed: proof.completed_loops,
+        blocked: proof.blocked_loops + proof.failed_loops + proof.handoff_loops,
+        speedup_ratio: proof.parallelism.speedup_ratio,
+        active_loop_ids: [],
+        blocked_loop_ids: proof.blockers
+    };
+}
+//# sourceMappingURL=loop-observability.js.map

package/dist/core/loops/loop-owner-inference.js

@@ -0,0 +1,57 @@
+export function inferLoopOwnerScope(input) {
+    if (input.integration) {
+        return {
+            files: ['CHANGELOG.md'],
+            directories: ['.sneakoscope/missions'],
+            package_scripts: [],
+            release_gate_ids: ['release:dag-full-coverage'],
+            exclusive: true,
+            collision_policy: 'integration-only'
+        };
+    }
+    const files = [...new Set(input.domain.files.filter((file) => !['package.json', 'release-gates.v2.json'].includes(file)))];
+    const releaseGateIds = input.domain.gates.filter((gate) => !gate.includes('*'));
+    const ownsPackage = input.domain.files.includes('package.json');
+    return {
+        files,
+        directories: input.domain.dirs.filter((dir) => dir !== 'package.json' && dir !== 'release-gates.v2.json'),
+        package_scripts: ownsPackage ? [] : inferPackageScripts(input.domain.id),
+        release_gate_ids: releaseGateIds,
+        exclusive: input.domain.id !== 'docs',
+        collision_policy: input.domain.id === 'docs' ? 'wait' : 'handoff'
+    };
+}
+export function detectOwnerScopeCollisions(scopes) {
+    const blockers = [];
+    for (let i = 0; i < scopes.length; i += 1) {
+        for (let j = i + 1; j < scopes.length; j += 1) {
+            const a = scopes[i];
+            const b = scopes[j];
+            if (!a || !b)
+                continue;
+            const fileOverlap = intersection(a.owner_scope.files, b.owner_scope.files);
+            const scriptOverlap = intersection(a.owner_scope.package_scripts, b.owner_scope.package_scripts);
+            if (fileOverlap.length && (a.owner_scope.exclusive || b.owner_scope.exclusive))
+                blockers.push(`file_collision:${a.loop_id}:${b.loop_id}:${fileOverlap.join(',')}`);
+            if (scriptOverlap.length)
+                blockers.push(`script_collision:${a.loop_id}:${b.loop_id}:${scriptOverlap.join(',')}`);
+        }
+    }
+    return blockers;
+}
+function inferPackageScripts(domainId) {
+    if (domainId === 'docs')
+        return ['docs:loop-runtime'];
+    if (domainId === 'naruto')
+        return ['naruto:loop-mesh'];
+    if (domainId === 'release')
+        return ['release:dag-full-coverage'];
+    if (domainId === 'loop-general-coding')
+        return ['loop:runtime'];
+    return [];
+}
+function intersection(a, b) {
+    const rhs = new Set(b);
+    return a.filter((value) => rhs.has(value));
+}
+//# sourceMappingURL=loop-owner-inference.js.map

package/dist/core/loops/loop-owner-ledger.js

@@ -0,0 +1,2 @@
+export { acquireLoopLease, releaseLoopLease, detectLoopLeaseConflicts } from './loop-lease.js';
+//# sourceMappingURL=loop-owner-ledger.js.map