sneakoscope 3.1.1 → 3.1.2

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

@@ -1,9 +1,9 @@
 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';
+import { mergeSingleLoopWorktree } from './loop-merge-strategy.js';
 export async function mergeLoopWorktrees(input) {
     const completed = input.proofs.filter((proof) => proof.status === 'completed' && proof.loop_id !== input.plan.integration_loop_id);
     const blockers = [];
@@ -11,6 +11,7 @@ export async function mergeLoopWorktrees(input) {
     const conflictLoops = new Set();
     const changedFiles = new Set();
     const owners = new Map();
+    const mergeAttempts = {};
     for (const proof of completed) {
         for (const file of proof.changed_files) {
             const previous = owners.get(file);
@@ -29,23 +30,16 @@ export async function mergeLoopWorktrees(input) {
             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}`);
+            const merge = await mergeSingleLoopWorktree({ root: input.root, proof, worktreePath, allowBranchMerge: true });
+            mergeAttempts[proof.loop_id] = merge;
+            if (!merge.ok) {
+                blockers.push(...merge.blockers, `loop_integration_merge_conflict:${proof.loop_id}`);
                 conflictLoops.add(proof.loop_id);
-                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');
+                await writeHandoff(input.root, proof.loop_id, merge.blockers.join('\n') || 'loop merge strategy failed');
                 continue;
             }
             appliedLoops.push(proof.loop_id);
-            for (const file of proof.changed_files)
+            for (const file of merge.changed_files)
                 changedFiles.add(file);
         }
     }
@@ -55,11 +49,22 @@ export async function mergeLoopWorktrees(input) {
         applied_loops: appliedLoops,
         conflict_loops: [...conflictLoops],
         changed_files: [...changedFiles],
-        blockers: [...new Set(blockers)]
+        blockers: [...new Set(blockers)],
+        merge_attempts: mergeAttempts,
+        strategy_summary: summarizeStrategies(Object.values(mergeAttempts))
     };
     await writeJsonAtomic(loopIntegrationMergePath(input.root, input.plan.mission_id), { ...result, generated_at: nowIso() });
     return result;
 }
+function summarizeStrategies(results) {
+    return {
+        apply_count: results.filter((row) => row.selected_strategy === 'apply').length,
+        apply_3way_count: results.filter((row) => row.selected_strategy === 'apply-3way').length,
+        cherry_pick_count: results.filter((row) => row.selected_strategy === 'cherry-pick').length,
+        merge_no_commit_count: results.filter((row) => row.selected_strategy === 'merge-no-commit').length,
+        handoff_count: results.filter((row) => row.selected_strategy === 'handoff' || !row.ok).length
+    };
+}
 async function writeHandoff(root, loopId, detail) {
     const contract = createRequestedScopeContract({
         route: '$Loop',

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

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

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

@@ -0,0 +1,105 @@
+import path from 'node:path';
+import { exists, runProcess } from '../fsx.js';
+import { gitBlocker, runGitCommand } from '../git/git-worktree-runner.js';
+export async function mergeSingleLoopWorktree(input) {
+    const attempts = [];
+    const changedFiles = [...new Set(input.proof.changed_files)];
+    const diff = await runGitCommand(input.worktreePath, ['diff', '--binary', '--full-index', 'HEAD'], { timeoutMs: 60000 }).catch(() => null);
+    if (!diff?.ok) {
+        return result(input.proof.loop_id, false, null, attempts, changedFiles, [`loop_merge_diff_failed:${input.proof.loop_id}`]);
+    }
+    if (!diff.stdout.trim())
+        return result(input.proof.loop_id, true, 'already_applied', attempts, changedFiles, []);
+    const applyCheck = await gitAttempt('apply-check', input.root, ['apply', '--check', '--whitespace=nowarn', '-'], diff.stdout);
+    attempts.push(applyCheck);
+    if (applyCheck.ok) {
+        const apply = await gitAttempt('apply', input.root, ['apply', '--whitespace=nowarn', '-'], diff.stdout);
+        attempts.push(apply);
+        if (apply.ok)
+            return result(input.proof.loop_id, true, 'apply', attempts, changedFiles, []);
+        await rollbackApply(input.root, diff.stdout);
+    }
+    const alreadyApplied = await gitAttempt('apply-check', input.root, ['apply', '--reverse', '--check', '--whitespace=nowarn', '-'], diff.stdout);
+    if (alreadyApplied.ok) {
+        attempts.push({ ...alreadyApplied, strategy: 'apply-check', blockers: [] });
+        return result(input.proof.loop_id, true, 'already_applied', attempts, changedFiles, []);
+    }
+    const apply3Check = await gitAttempt('apply-3way', input.root, ['apply', '--3way', '--check', '--whitespace=nowarn', '-'], diff.stdout);
+    attempts.push(apply3Check);
+    if (apply3Check.ok) {
+        const apply3 = await gitAttempt('apply-3way', input.root, ['apply', '--3way', '--whitespace=nowarn', '-'], diff.stdout);
+        attempts.push(apply3);
+        if (apply3.ok)
+            return result(input.proof.loop_id, true, 'apply-3way', attempts, changedFiles, []);
+        await abortMergeLikeState(input.root);
+    }
+    const head = await runGitCommand(input.worktreePath, ['rev-parse', '--verify', 'HEAD'], { timeoutMs: 10000 }).catch(() => null);
+    const commit = head?.ok ? head.stdout.trim() : '';
+    if (commit) {
+        const cherry = await gitAttempt('cherry-pick', input.root, ['cherry-pick', '--no-commit', commit], undefined);
+        attempts.push(cherry);
+        if (cherry.ok)
+            return result(input.proof.loop_id, true, 'cherry-pick', attempts, changedFiles, []);
+        await runGitCommand(input.root, ['cherry-pick', '--abort'], { timeoutMs: 30000 }).catch(() => null);
+        await abortMergeLikeState(input.root);
+    }
+    if (input.allowBranchMerge && input.proof.worktree.branch) {
+        const branch = input.proof.worktree.branch;
+        const merge = await gitAttempt('merge-no-commit', input.root, ['merge', '--no-ff', '--no-commit', branch], undefined);
+        attempts.push(merge);
+        if (merge.ok)
+            return result(input.proof.loop_id, true, 'merge-no-commit', attempts, changedFiles, []);
+        await runGitCommand(input.root, ['merge', '--abort'], { timeoutMs: 30000 }).catch(() => null);
+        await abortMergeLikeState(input.root);
+    }
+    const handoff = {
+        strategy: 'handoff',
+        ok: false,
+        exit_code: null,
+        stdout_tail: '',
+        stderr_tail: 'all merge strategies failed',
+        duration_ms: 1,
+        blockers: [`loop_merge_conflict_handoff:${input.proof.loop_id}`]
+    };
+    attempts.push(handoff);
+    return result(input.proof.loop_id, false, 'handoff', attempts, changedFiles, handoff.blockers);
+}
+async function gitAttempt(strategy, cwd, args, input) {
+    const started = Date.now();
+    const res = await runGitCommand(cwd, args, { timeoutMs: 60000, ...(input === undefined ? {} : { input }) }).catch((err) => null);
+    if (!res) {
+        return { strategy, ok: false, exit_code: null, stdout_tail: '', stderr_tail: '', duration_ms: Math.max(1, Date.now() - started), blockers: [`loop_merge_${strategy}_exception`] };
+    }
+    return {
+        strategy,
+        ok: res.ok,
+        exit_code: res.code,
+        stdout_tail: res.stdout_tail,
+        stderr_tail: res.stderr_tail,
+        duration_ms: Math.max(1, Date.now() - started),
+        blockers: res.ok ? [] : [gitBlocker(`loop_merge_${strategy}_failed`, res)]
+    };
+}
+async function rollbackApply(root, diff) {
+    await runGitCommand(root, ['apply', '--reverse', '--whitespace=nowarn', '-'], { input: diff, timeoutMs: 60000 }).catch(() => null);
+    await abortMergeLikeState(root);
+}
+async function abortMergeLikeState(root) {
+    if (await exists(path.join(root, '.git', 'MERGE_HEAD')))
+        await runGitCommand(root, ['merge', '--abort'], { timeoutMs: 30000 }).catch(() => null);
+    if (await exists(path.join(root, '.git', 'CHERRY_PICK_HEAD')))
+        await runGitCommand(root, ['cherry-pick', '--abort'], { timeoutMs: 30000 }).catch(() => null);
+    await runProcess('git', ['reset', '--merge'], { cwd: root, timeoutMs: 30000, maxOutputBytes: 64 * 1024 }).catch(() => null);
+}
+function result(loopId, ok, selectedStrategy, attempts, changedFiles, blockers) {
+    return {
+        schema: 'sks.loop-merge-strategy-result.v1',
+        loop_id: loopId,
+        ok,
+        selected_strategy: selectedStrategy,
+        attempts,
+        changed_files: changedFiles,
+        blockers: [...new Set(blockers)]
+    };
+}
+//# sourceMappingURL=loop-merge-strategy.js.map

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

@@ -0,0 +1,103 @@
+import { appendJsonl, readText } from '../fsx.js';
+import { loopMutationLedgerPath } from './loop-artifacts.js';
+import { enforceLoopOwnerScope } from './loop-worktree-runtime.js';
+export async function appendLoopMutationEvent(root, missionId, event) {
+    await appendJsonl(loopMutationLedgerPath(root, missionId), {
+        schema: 'sks.loop-mutation-ledger-event.v1',
+        ts: event.ts || new Date().toISOString(),
+        mission_id: missionId,
+        loop_id: event.loop_id,
+        event_type: event.event_type,
+        file_path: event.file_path,
+        source: event.source,
+        allowed_by_owner_scope: event.allowed_by_owner_scope,
+        details: event.details
+    });
+}
+export async function readLoopMutationLedger(root, missionId) {
+    const text = await readText(loopMutationLedgerPath(root, missionId), '');
+    return String(text).split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((row) => Boolean(row));
+}
+export async function mutationLedgerFromLoopProofs(input) {
+    const events = [];
+    for (const proof of input.proofs) {
+        const workerChanged = [...new Set([...(proof.maker_result.changed_files || []), ...proof.changed_files])];
+        for (const file of workerChanged) {
+            const violations = enforceLoopOwnerScope([file], proof.owner_scope);
+            const eventType = violations.length ? 'owner_scope_violation' : 'file_changed';
+            const event = {
+                schema: 'sks.loop-mutation-ledger-event.v1',
+                ts: new Date().toISOString(),
+                mission_id: input.missionId,
+                loop_id: proof.loop_id,
+                event_type: eventType,
+                file_path: file,
+                source: 'git-diff',
+                allowed_by_owner_scope: violations.length === 0,
+                details: { status: proof.status, blockers: violations }
+            };
+            events.push(event);
+            await appendJsonl(loopMutationLedgerPath(input.root, input.missionId), event);
+        }
+        if (proof.gate_result.blockers?.some((blocker) => blocker.includes('side_effect') || blocker.includes('mutation'))) {
+            const event = {
+                schema: 'sks.loop-mutation-ledger-event.v1',
+                ts: new Date().toISOString(),
+                mission_id: input.missionId,
+                loop_id: proof.loop_id,
+                event_type: 'gate_side_effect',
+                file_path: null,
+                source: 'gate-result',
+                allowed_by_owner_scope: false,
+                details: { blockers: proof.gate_result.blockers || [] }
+            };
+            events.push(event);
+            await appendJsonl(loopMutationLedgerPath(input.root, input.missionId), event);
+        }
+    }
+    if (input.integrationMerge) {
+        for (const loopId of input.integrationMerge.applied_loops) {
+            const event = {
+                schema: 'sks.loop-mutation-ledger-event.v1',
+                ts: new Date().toISOString(),
+                mission_id: input.missionId,
+                loop_id: loopId,
+                event_type: 'merge_applied',
+                file_path: null,
+                source: 'integration-merge',
+                allowed_by_owner_scope: true,
+                details: { changed_files: input.integrationMerge.changed_files }
+            };
+            events.push(event);
+            await appendJsonl(loopMutationLedgerPath(input.root, input.missionId), event);
+        }
+        for (const loopId of input.integrationMerge.conflict_loops) {
+            const event = {
+                schema: 'sks.loop-mutation-ledger-event.v1',
+                ts: new Date().toISOString(),
+                mission_id: input.missionId,
+                loop_id: loopId,
+                event_type: 'merge_conflict',
+                file_path: null,
+                source: 'integration-merge',
+                allowed_by_owner_scope: false,
+                details: { blockers: input.integrationMerge.blockers }
+            };
+            events.push(event);
+            await appendJsonl(loopMutationLedgerPath(input.root, input.missionId), event);
+        }
+    }
+    return events;
+}
+//# sourceMappingURL=loop-mutation-ledger.js.map

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

@@ -1,9 +1,11 @@
 import { readJson, writeJsonAtomic } from '../fsx.js';
 import { loopKillRequestPath, loopProofPath, loopStatePath } from './loop-artifacts.js';
 import { writeLoopCheckpoint } from './loop-checkpoint.js';
+import { interruptLoopWorkers } from './loop-interrupt-registry.js';
 export async function writeLoopKillRequest(root, missionId, target) {
     const request = { schema: 'sks.loop-kill-request.v1', mission_id: missionId, target, requested_at: new Date().toISOString() };
     await writeJsonAtomic(loopKillRequestPath(root, missionId), request);
+    await interruptLoopWorkers({ root, missionId, target }).catch(() => undefined);
     return request;
 }
 export async function shouldKillLoop(root, missionId, loopId) {

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

@@ -1,5 +1,6 @@
 import { writeJsonAtomic } from '../fsx.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';
@@ -11,7 +12,9 @@ import { runLoopCheckerWorkers, runLoopMakerWorkers } from './loop-worker-runtim
 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'))
@@ -28,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 {

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)));

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