sneakoscope 3.1.0 → 3.1.2

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

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

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

@@ -1,9 +1,9 @@
 import os from 'node:os';
-export function scheduleLoopGraph(nodes, parallelism = 'balanced') {
+export function scheduleLoopGraph(nodes, parallelism = 'balanced', budget) {
     const pending = new Map(nodes.map((node) => [node.loop_id, node]));
     const completed = new Set();
     const batches = [];
-    const maxParallel = maxConcurrentLoops(nodes, parallelism);
+    const maxParallel = budget?.max_active_loops || maxConcurrentLoops(nodes, parallelism);
     const blockers = [];
     while (pending.size) {
         const ready = [...pending.values()].filter((node) => node.dependencies.every((dep) => completed.has(dep)));
@@ -26,9 +26,18 @@ export function scheduleLoopGraph(nodes, parallelism = 'balanced') {
 export function maxConcurrentLoops(nodes, parallelism = 'balanced') {
     const cores = Math.max(1, os.cpus().length || 1);
     const base = parallelism === 'safe' ? 2 : parallelism === 'extreme' ? Math.min(16, cores) : Math.min(8, cores);
-    return nodes.some((node) => node.risk.level === 'critical' || node.risk.level === 'high') && parallelism !== 'extreme'
-        ? Math.max(1, Math.min(base, 3))
-        : Math.max(1, base);
+    return Math.max(1, Math.min(base, riskAwareLoopCap(nodes, parallelism, cores)));
+}
+function riskAwareLoopCap(nodes, parallelism, cores) {
+    if (parallelism === 'extreme')
+        return Math.min(16, cores);
+    const hasCritical = nodes.some((node) => node.risk.level === 'critical');
+    const hasHigh = nodes.some((node) => node.risk.level === 'high');
+    if (hasCritical)
+        return parallelism === 'safe' ? 1 : Math.max(2, Math.floor(cores / 4));
+    if (hasHigh)
+        return parallelism === 'safe' ? 2 : Math.max(4, Math.floor(cores / 2));
+    return parallelism === 'safe' ? 2 : Math.min(8, cores);
 }
 export function graphProofFromLoopProofs(input) {
     const selected = [...new Set(input.proofs.flatMap((proof) => proof.gate_result.selected_gates))];

package/dist/core/loops/loop-side-effect-scanner.js

@@ -0,0 +1,91 @@
+import { readJson, writeJsonAtomic } from '../fsx.js';
+import { loopGatePath, loopMutationLedgerPath, loopSideEffectReportPath } from './loop-artifacts.js';
+import { mutationLedgerFromLoopProofs, readLoopMutationLedger } from './loop-mutation-ledger.js';
+import { enforceLoopOwnerScope } from './loop-worktree-runtime.js';
+export async function buildLoopSideEffectReport(input) {
+    await mutationLedgerFromLoopProofs({
+        root: input.root,
+        missionId: input.missionId,
+        proofs: input.proofs,
+        integrationMerge: input.integrationMerge || null
+    });
+    const ledger = await readLoopMutationLedger(input.root, input.missionId);
+    const changedFiles = [...new Set([
+            ...input.proofs.flatMap((proof) => proof.changed_files),
+            ...(input.integrationMerge?.changed_files || []),
+            ...ledger.map((event) => event.file_path).filter((file) => Boolean(file))
+        ])];
+    const integrationLoopIds = new Set(input.proofs.filter((proof) => proof.loop_id.includes('integration')).map((proof) => proof.loop_id));
+    const ownerScopeViolations = collectOwnerScopeViolations(input.proofs, ledger);
+    const unexpectedPackageChanges = changedFiles.filter((file) => isPackageOrReleaseFile(file) && !changedByIntegration(input.proofs, file, integrationLoopIds));
+    const globalConfigMutations = changedFiles.filter(isGlobalConfigPath);
+    const gateSideEffects = await collectGateSideEffects(input.root, input.missionId, input.proofs);
+    const networkOrInstallSideEffects = gateSideEffects.filter((item) => /(install|network|npm|pnpm|yarn|curl|brew)/i.test(item));
+    const blockers = [
+        ...ownerScopeViolations.map((file) => `loop_side_effect_owner_scope_violation:${file}`),
+        ...unexpectedPackageChanges.map((file) => `loop_side_effect_unexpected_package_change:${file}`),
+        ...globalConfigMutations.map((file) => `loop_side_effect_global_config_mutation:${file}`),
+        ...networkOrInstallSideEffects.map((item) => `loop_side_effect_network_or_install:${item}`),
+        ...gateSideEffects.filter((item) => item.includes('gate_side_effect_not_hermetic')).map((item) => `loop_side_effect_gate:${item}`)
+    ];
+    const report = {
+        schema: 'sks.loop-side-effect-report.v1',
+        ok: blockers.length === 0,
+        mission_id: input.missionId,
+        changed_files: changedFiles,
+        owner_scope_violations: [...new Set(ownerScopeViolations)],
+        unexpected_package_changes: [...new Set(unexpectedPackageChanges)],
+        global_config_mutations: [...new Set(globalConfigMutations)],
+        network_or_install_side_effects: [...new Set(networkOrInstallSideEffects)],
+        gate_side_effects: [...new Set(gateSideEffects)],
+        mutation_ledger_path: `.sneakoscope/missions/${input.missionId}/loops/mutation-ledger.jsonl`,
+        blockers: [...new Set(blockers)]
+    };
+    await writeJsonAtomic(loopSideEffectReportPath(input.root, input.missionId), { ...report, generated_at: new Date().toISOString() });
+    return report;
+}
+function collectOwnerScopeViolations(proofs, ledger) {
+    const fromLedger = ledger
+        .filter((event) => event.event_type === 'owner_scope_violation' || event.allowed_by_owner_scope === false)
+        .map((event) => event.file_path)
+        .filter((file) => Boolean(file));
+    const fromProofs = proofs.flatMap((proof) => proof.changed_files.filter((file) => enforceLoopOwnerScope([file], proof.owner_scope).length > 0));
+    return [...fromLedger, ...fromProofs];
+}
+async function collectGateSideEffects(root, missionId, proofs) {
+    const results = [];
+    for (const proof of proofs) {
+        for (const gateId of proof.gate_result.selected_gates || []) {
+            const artifact = await readJson(loopGatePath(root, missionId, proof.loop_id, gateId), null);
+            const sideEffect = String(artifact?.side_effect || artifact?.definition_side_effect || '');
+            if (proof.loop_id !== 'loop-integration' && sideEffect === 'mutation') {
+                results.push(`gate_side_effect_not_hermetic:${proof.loop_id}:${gateId}`);
+            }
+            if (Array.isArray(artifact?.side_effects)) {
+                results.push(...artifact.side_effects.map((value) => `${proof.loop_id}:${gateId}:${String(value)}`));
+            }
+        }
+    }
+    return results;
+}
+function changedByIntegration(proofs, file, integrationLoopIds) {
+    return proofs.some((proof) => integrationLoopIds.has(proof.loop_id) && proof.changed_files.includes(file));
+}
+function isPackageOrReleaseFile(file) {
+    return ['package.json', 'package-lock.json', 'release-gates.v2.json'].includes(normalize(file));
+}
+function isGlobalConfigPath(file) {
+    const normalized = normalize(file);
+    return normalized.startsWith('.codex/')
+        || normalized.startsWith('.agents/')
+        || normalized.startsWith('.sneakoscope/policy')
+        || normalized.includes('/.codex/')
+        || normalized.includes('/.agents/');
+}
+function normalize(file) {
+    return String(file || '').replace(/\\/g, '/').replace(/^\.\/+/, '');
+}
+export function loopSideEffectLedgerPath(root, missionId) {
+    return loopMutationLedgerPath(root, missionId);
+}
+//# sourceMappingURL=loop-side-effect-scanner.js.map

package/dist/core/loops/loop-worker-prompts.js

@@ -0,0 +1,43 @@
+import { allGateIds } from './loop-schema.js';
+export function buildLoopMakerPrompt(input) {
+    const node = input.node;
+    return [
+        'You are the maker worker for an SKS Loop Mesh L2 action loop.',
+        `Mission: ${input.plan.mission_id}`,
+        `Loop: ${node.loop_id}`,
+        `Purpose: ${node.purpose}`,
+        `Owner files: ${node.owner_scope.files.join(', ') || '-'}`,
+        `Owner directories: ${node.owner_scope.directories.join(', ') || '-'}`,
+        `Allowed mutation scope: ${ownerScopeText(node)}`,
+        'Do not mutate outside the owner scope.',
+        `Selected local gates: ${allGateIds(node.gates).join(', ') || '-'}`,
+        `Budget: ${JSON.stringify(node.budget)}`,
+        `Worktree path: ${input.worktreePath || '-'}`,
+        'Write a patch candidate/runtime proof artifact with changed files and blockers.',
+        'No synthetic pass is allowed for production proof.'
+    ].join('\n');
+}
+export function buildLoopCheckerPrompt(input) {
+    const node = input.node;
+    return [
+        'You are the checker worker for an SKS Loop Mesh action loop.',
+        'You must run in a fresh session and must not mutate source files.',
+        `Mission: ${input.plan.mission_id}`,
+        `Loop: ${node.loop_id}`,
+        `Purpose: ${node.purpose}`,
+        `Maker artifacts: ${input.makerArtifacts.join(', ') || '-'}`,
+        `Diff/patch summary: ${input.diffSummary || '-'}`,
+        `Selected gates: ${allGateIds(node.gates).join(', ') || '-'}`,
+        `Risk: ${node.risk.level} (${node.risk.reasons.join(', ') || '-'})`,
+        'Reject unrequested side effects and owner-scope violations.',
+        'Write checker-findings.json with fresh_session, reviewed_maker_artifacts, side_effects_detected, and approved.',
+        'No synthetic pass is allowed for production proof.'
+    ].join('\n');
+}
+function ownerScopeText(node) {
+    return [
+        ...node.owner_scope.files.map((file) => `file:${file}`),
+        ...node.owner_scope.directories.map((dir) => `dir:${dir}`)
+    ].join(', ') || 'none';
+}
+//# sourceMappingURL=loop-worker-prompts.js.map