sneakoscope 3.0.3 → 3.1.0

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '3.0.3';
+export const PACKAGE_VERSION = '3.1.0';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {
@@ -101,6 +101,30 @@ export async function readJson(p, fallback) {
 export async function writeJsonAtomic(p, data) {
     await writeTextAtomic(p, `${JSON.stringify(data, null, 2)}\n`);
 }
+export async function writeBinaryAtomic(p, data) {
+    await ensureDir(path.dirname(p));
+    try {
+        if ((await fsp.readFile(p)).equals(data))
+            return;
+    }
+    catch { }
+    const tmp = `${p}.${process.pid}.${randomId(6)}.tmp`;
+    try {
+        const handle = await fsp.open(tmp, 'w');
+        try {
+            await handle.writeFile(data);
+            await handle.sync().catch(() => { });
+        }
+        finally {
+            await handle.close().catch(() => { });
+        }
+        await fsp.rename(tmp, p);
+    }
+    catch (err) {
+        await fsp.rm(tmp, { force: true }).catch(() => { });
+        throw err;
+    }
+}
 export async function appendJsonl(p, obj) {
     await ensureDir(path.dirname(p));
     await fsp.appendFile(p, `${JSON.stringify(obj)}\n`, 'utf8');

package/dist/core/init.js

@@ -603,6 +603,8 @@ export async function initProject(root, opts = {}) {
         next = upsertTomlTableKeyIfAbsent(next, 'agents', 'max_threads = 6');
         next = upsertTomlTableKeyIfAbsent(next, 'agents', 'max_depth = 1');
         for (const block of managedCodexConfigBlocks()) {
+            if (block.preserveExisting === true && hasTomlTable(next, block.table))
+                continue;
             next = upsertTomlTable(next, block.table, block.text);
         }
         // Plugin tables broke the Codex App UI by force-reverting user `enabled=false`.
@@ -797,7 +799,10 @@ export async function initProject(root, opts = {}) {
     }
     function managedCodexConfigBlocks() {
         return [
-            { table: 'mcp_servers.context7', text: context7ConfigToml().trim() },
+            // Context7 credentials may live directly in this table as args/env/headers/url
+            // depending on the user's MCP client setup. Seed the default only when absent;
+            // never replace an existing Context7 block during setup/update.
+            { table: 'mcp_servers.context7', text: context7ConfigToml().trim(), preserveExisting: true },
             { table: 'agents.native_agent', text: agentConfigBlock('native_agent', 'Read-only SKS analysis agent.', './agents/native-agent-intake.toml', ['Analysis', 'Mapper']) },
             { table: 'agents.team_consensus', text: agentConfigBlock('team_consensus', 'SKS planning/debate agent.', './agents/team-consensus.toml', ['Consensus', 'Atlas']) },
             { table: 'agents.implementation_worker', text: agentConfigBlock('implementation_worker', 'SKS bounded implementation worker.', './agents/implementation-worker.toml', ['Builder', 'Mason']) },

package/dist/core/loops/goal-to-loop-compat.js

@@ -0,0 +1,23 @@
+import path from 'node:path';
+import { writeJsonAtomic } from '../fsx.js';
+import { planLoopsFromRequest } from './loop-planner.js';
+export async function compileGoalToLoopPlan(input) {
+    const plan = await planLoopsFromRequest({
+        root: input.root,
+        missionId: input.missionId,
+        request: input.goalText,
+        sourceCommand: 'goal'
+    });
+    await writeJsonAtomic(path.join(input.root, '.sneakoscope', 'missions', input.missionId, 'goal-compat.json'), {
+        schema: 'sks.goal-loop-compat.v1',
+        legacy_goal_text: input.goalText,
+        legacy_goal_options: input.legacyGoalOptions,
+        loop_plan_path: `.sneakoscope/missions/${input.missionId}/loops/loop-plan.json`,
+        loop_graph_proof_path: `.sneakoscope/missions/${input.missionId}/loops/loop-graph-proof.json`,
+        runtime: 'loop-graph',
+        compat_mode: true,
+        generated_at: new Date().toISOString()
+    });
+    return plan;
+}
+//# sourceMappingURL=goal-to-loop-compat.js.map

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

@@ -0,0 +1,41 @@
+import path from 'node:path';
+export function loopRoot(root, missionId) {
+    return path.join(root, '.sneakoscope', 'missions', missionId, 'loops');
+}
+export function loopNodeRoot(root, missionId, loopId) {
+    return path.join(loopRoot(root, missionId), loopId);
+}
+export function loopPlanPath(root, missionId) {
+    return path.join(loopRoot(root, missionId), 'loop-plan.json');
+}
+export function loopStatePath(root, missionId, loopId) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'loop-state.json');
+}
+export function loopRunLogPath(root, missionId, loopId) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'loop-run-log.jsonl');
+}
+export function loopProofPath(root, missionId, loopId) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'loop-proof.json');
+}
+export function loopBudgetPath(root, missionId, loopId) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'loop-budget.json');
+}
+export function loopGraphProofPath(root, missionId) {
+    return path.join(loopRoot(root, missionId), 'loop-graph-proof.json');
+}
+export function loopGatePath(root, missionId, loopId, gateId) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'gates', `${sanitizeArtifactPart(gateId)}.json`);
+}
+export function loopPatchPath(root, missionId, loopId, name) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'patches', `${sanitizeArtifactPart(name)}.json`);
+}
+export function loopHandoffPath(root, missionId, loopId) {
+    return path.join(loopNodeRoot(root, missionId, loopId), 'handoff.md');
+}
+export function loopOwnerLedgerPath(root, missionId) {
+    return path.join(loopRoot(root, missionId), 'loop-owner-ledger.json');
+}
+export function sanitizeArtifactPart(value) {
+    return String(value || 'artifact').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 96) || 'artifact';
+}
+//# sourceMappingURL=loop-artifacts.js.map

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

@@ -0,0 +1,56 @@
+export const LOOP_DOMAIN_RULES = [
+    { id: 'zellij', dirs: ['src/core/zellij', 'src/scripts/zellij-'], gates: ['zellij:*'] },
+    { id: 'release', dirs: ['src/core/release', 'src/scripts/release-', 'release-gates.v2.json'], gates: ['release:*'] },
+    { id: 'research', dirs: ['src/core/research', 'src/scripts/research-'], gates: ['research:*'] },
+    { id: 'qa-loop', dirs: ['src/core/qa-loop', 'src/core/commands/qa-loop-command.ts'], gates: ['qa-loop:*'] },
+    { id: 'naruto', dirs: ['src/core/naruto', 'src/core/commands/naruto-command.ts'], gates: ['naruto:*'] },
+    { id: 'codex-control', dirs: ['src/core/codex-control', 'src/scripts/codex-'], gates: ['codex:*', 'codex-sdk:*'] },
+    { id: 'image', dirs: ['src/core/image', 'src/core/image-generation'], gates: ['image:*'] },
+    { id: 'mad-db', dirs: ['src/core/mad-db', 'src/core/db-safety.ts'], gates: ['mad-db:*'] },
+    { id: 'docs', dirs: ['docs', 'README.md', 'CHANGELOG.md'], gates: ['docs:*', 'changelog:check'] }
+];
+export function decomposeRequestIntoLoopDomains(request, changedFiles = []) {
+    const text = `${request} ${changedFiles.join(' ')}`.toLowerCase();
+    const explicitFiles = extractFilePaths(request).concat(changedFiles).filter(Boolean);
+    const selected = new Map();
+    for (const rule of LOOP_DOMAIN_RULES) {
+        const matchedByText = [rule.id, ...domainAliases(rule.id)].some((needle) => text.includes(needle))
+            || rule.dirs.some((dir) => text.includes(dir.toLowerCase()) || text.includes(lastPart(dir)));
+        const matchedFiles = explicitFiles.filter((file) => rule.dirs.some((dir) => file === dir || file.startsWith(dir.replace(/\*+$/, ''))));
+        if (!matchedByText && matchedFiles.length === 0)
+            continue;
+        selected.set(rule.id, {
+            id: rule.id,
+            dirs: rule.dirs.filter((dir) => !dir.includes('*')),
+            files: matchedFiles,
+            gates: rule.gates
+        });
+    }
+    if (selected.size === 0 && explicitFiles.length) {
+        selected.set('loop-general-coding', { id: 'loop-general-coding', dirs: [], files: explicitFiles, gates: ['loop:affected'] });
+    }
+    if (selected.size === 0) {
+        selected.set('loop-general-coding', { id: 'loop-general-coding', dirs: ['src'], files: [], gates: ['loop:affected'] });
+    }
+    return [...selected.values()];
+}
+function extractFilePaths(request) {
+    return [...request.matchAll(/(?:^|\s)([A-Za-z0-9_.@/-]+\.(?:ts|tsx|js|mjs|json|md|toml|yml|yaml))(?:\s|$)/g)]
+        .map((match) => match[1])
+        .filter((value) => Boolean(value));
+}
+function lastPart(value) {
+    return value.split('/').at(-1)?.replace(/[^a-z0-9-]/gi, '').toLowerCase() || value.toLowerCase();
+}
+function domainAliases(id) {
+    if (id === 'codex-control')
+        return ['codex', 'probe', 'capability'];
+    if (id === 'release')
+        return ['cache', 'gate', 'dag'];
+    if (id === 'docs')
+        return ['doc', 'docs', 'readme', 'changelog'];
+    if (id === 'qa-loop')
+        return ['qa'];
+    return [];
+}
+//# sourceMappingURL=loop-decomposer.js.map

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

@@ -0,0 +1,28 @@
+import { readJson, writeJsonAtomic } from '../fsx.js';
+import { loopGraphProofPath, loopProofPath } from './loop-artifacts.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)));
+    const realProofs = proofs.filter((proof) => Boolean(proof));
+    const graph = graphProofFromLoopProofs({
+        missionId: input.plan.mission_id,
+        proofs: realProofs,
+        maxActiveLoops: input.maxActiveLoops || 1,
+        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 anyHandoff = realProofs.some((proof) => proof.handoff.required);
+    const anySourceMutation = realProofs.some((proof) => proof.changed_files.length > 0);
+    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'] : [])
+        ]
+    };
+    await writeJsonAtomic(loopGraphProofPath(input.root, input.plan.mission_id), finalGraph);
+    return finalGraph;
+}
+//# sourceMappingURL=loop-finalizer.js.map

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-runner.js

@@ -0,0 +1,29 @@
+import { writeJsonAtomic } from '../fsx.js';
+import { allGateIds } from './loop-schema.js';
+import { loopGatePath } from './loop-artifacts.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));
+    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()
+        });
+    }
+    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}`)
+    };
+}
+//# 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-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,76 @@
+import { loopOwnerLedgerPath } from './loop-artifacts.js';
+import { nowIso, readJson, writeJsonAtomic } from '../fsx.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;
+}
+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);
+}
+export async function detectLoopLeaseConflicts(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 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

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

@@ -0,0 +1,139 @@
+import { writeJsonAtomic } from '../fsx.js';
+import { decomposeRequestIntoLoopDomains } from './loop-decomposer.js';
+import { loopPlanPath, loopRunLogPath, loopStatePath } from './loop-artifacts.js';
+import { selectLoopGates } from './loop-gate-selector.js';
+import { inferLoopOwnerScope } from './loop-owner-inference.js';
+import { classifyLoopRisk } from './loop-risk-classifier.js';
+import { defaultLoopBudget, validateLoopPlan } from './loop-schema.js';
+export async function planLoopsFromRequest(input) {
+    const maxLoops = Math.max(1, Math.min(32, input.maxLoops || 8));
+    const domains = decomposeRequestIntoLoopDomains(input.request).slice(0, maxLoops);
+    const actionNodes = domains.map((domain) => {
+        const loopId = `loop-${domain.id}`;
+        const ownerScope = inferLoopOwnerScope({ domain });
+        const risk = classifyLoopRisk({ loop_id: loopId, owner_scope: ownerScope, level: 'L2-action' });
+        const nodeBase = makeNode({
+            missionId: input.missionId,
+            loopId,
+            title: titleFromDomain(domain.id),
+            purpose: `Execute ${domain.id} slice for: ${input.request}`,
+            ownerScope,
+            dependencies: [],
+            route: domain.id === 'docs' ? '$Loop' : '$Naruto',
+            level: domain.id === 'docs' ? 'L1-assisted' : 'L2-action',
+            risk
+        });
+        return { ...nodeBase, gates: selectLoopGates({ node: nodeBase, changedFiles: [...ownerScope.files, ...ownerScope.directories], risk }) };
+    });
+    const integrationOwner = inferLoopOwnerScope({ domain: { id: 'integration', dirs: [], files: [], gates: ['release:dag-full-coverage'] }, integration: true });
+    const integrationRisk = classifyLoopRisk({ loop_id: 'loop-integration', owner_scope: integrationOwner, level: 'L1-assisted' });
+    const integrationBase = makeNode({
+        missionId: input.missionId,
+        loopId: 'loop-integration',
+        title: 'Integration loop finalizer',
+        purpose: 'Merge loop proofs, run integration gates, and require GPT final arbitration when source mutation exists.',
+        ownerScope: integrationOwner,
+        dependencies: actionNodes.map((node) => node.loop_id),
+        route: '$Integration',
+        level: 'L1-assisted',
+        risk: integrationRisk
+    });
+    const integrationNode = {
+        ...integrationBase,
+        gates: selectLoopGates({
+            node: integrationBase,
+            changedFiles: ['package.json', 'release-gates.v2.json', 'CHANGELOG.md'],
+            risk: integrationRisk,
+            packageScriptsChanged: ['loop:runtime'],
+            releaseGateIdsChanged: ['release:dag-full-coverage']
+        })
+    };
+    const nodes = [...actionNodes, integrationNode];
+    const plan = {
+        schema: 'sks.loop-plan.v1',
+        mission_id: input.missionId,
+        request: input.request,
+        generated_at: new Date().toISOString(),
+        planner: {
+            route: '$Loop',
+            model_policy: input.mode === 'codex-assisted' ? 'codex-sdk' : 'deterministic',
+            confidence: actionNodes.length ? 'high' : 'medium'
+        },
+        graph: {
+            nodes,
+            edges: actionNodes.map((node) => ({ from: node.loop_id, to: integrationNode.loop_id, reason: 'integration_after_loop_proof' }))
+        },
+        global_budget: defaultLoopBudget({
+            max_iterations: Math.max(...nodes.map((node) => node.budget.max_iterations)),
+            max_subagents: nodes.reduce((sum, node) => sum + node.budget.max_subagents, 0)
+        }),
+        safety: {
+            no_unrequested_fallback_code: true,
+            require_owner_lease: true,
+            require_checker_for_action: true,
+            require_gpt_final_for_source_mutation: true
+        },
+        integration_loop_id: integrationNode.loop_id,
+        compatibility: {
+            goal_compat_artifact: input.sourceCommand === 'goal' ? `.sneakoscope/missions/${input.missionId}/goal-compat.json` : null,
+            source_command: input.sourceCommand
+        },
+        blockers: []
+    };
+    const validation = validateLoopPlan(plan);
+    plan.blockers = validation.blockers;
+    await writeJsonAtomic(loopPlanPath(input.root, input.missionId), plan);
+    return plan;
+}
+function makeNode(input) {
+    const budget = defaultLoopBudget({
+        max_subagents: input.route === '$Integration' ? 2 : 4,
+        max_changed_files: input.ownerScope.files.length ? Math.max(4, input.ownerScope.files.length + 2) : 12
+    });
+    return {
+        schema: 'sks.loop-node.v1',
+        loop_id: input.loopId,
+        mission_id: input.missionId,
+        title: input.title,
+        purpose: input.purpose,
+        level: input.level,
+        route: input.route,
+        owner_scope: input.ownerScope,
+        state_file: loopStatePath('', input.missionId, input.loopId).replace(/^\/?/, ''),
+        run_log_file: loopRunLogPath('', input.missionId, input.loopId).replace(/^\/?/, ''),
+        budget,
+        maker: {
+            route: '$Naruto',
+            role: input.route === '$Integration' ? 'planner' : input.loopId.includes('docs') ? 'writer' : 'implementer',
+            worker_count: input.route === '$Integration' ? 1 : 2,
+            backend_preference: ['codex-sdk', 'python-codex-sdk', 'local-llm'],
+            local_draft_allowed: input.risk.level !== 'critical',
+            gpt_final_required: input.risk.requires_gpt_final
+        },
+        checker: {
+            route: input.loopId.includes('research') ? '$Research' : input.loopId.includes('docs') ? '$DFix' : '$QA-LOOP',
+            worker_count: input.route === '$Integration' ? 1 : 1,
+            fresh_session_required: true,
+            stronger_model_required: input.risk.level === 'high' || input.risk.level === 'critical',
+            required_before_next_iteration: input.level === 'L2-action'
+        },
+        gates: { triage: [], local: [], checker: [], integration: [], final: [] },
+        dependencies: input.dependencies,
+        handoff_policy: {
+            allow_handoff: true,
+            reasons: input.risk.requires_human_handoff ? ['critical_risk_requires_handoff'] : [],
+            artifact: null
+        },
+        worktree: {
+            required: input.risk.requires_worktree,
+            mode: input.risk.requires_worktree ? 'new-worktree' : 'none',
+            branch_prefix: `sks/loop/${input.missionId}`,
+            cleanup: input.risk.level === 'low' ? 'on-success' : 'keep-on-failure'
+        },
+        risk: input.risk
+    };
+}
+function titleFromDomain(domainId) {
+    return domainId === 'loop-general-coding' ? 'General coding loop' : `${domainId} loop`;
+}
+//# sourceMappingURL=loop-planner.js.map

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

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

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

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