sneakoscope 3.1.0 → 3.1.2

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

@@ -6,6 +6,7 @@ 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 parallelism = input.parallelism || 'balanced';
     const maxLoops = Math.max(1, Math.min(32, input.maxLoops || 8));
     const domains = decomposeRequestIntoLoopDomains(input.request).slice(0, maxLoops);
     const actionNodes = domains.map((domain) => {
@@ -21,7 +22,8 @@ export async function planLoopsFromRequest(input) {
             dependencies: [],
             route: domain.id === 'docs' ? '$Loop' : '$Naruto',
             level: domain.id === 'docs' ? 'L1-assisted' : 'L2-action',
-            risk
+            risk,
+            parallelism
         });
         return { ...nodeBase, gates: selectLoopGates({ node: nodeBase, changedFiles: [...ownerScope.files, ...ownerScope.directories], risk }) };
     });
@@ -36,7 +38,8 @@ export async function planLoopsFromRequest(input) {
         dependencies: actionNodes.map((node) => node.loop_id),
         route: '$Integration',
         level: 'L1-assisted',
-        risk: integrationRisk
+        risk: integrationRisk,
+        parallelism
     });
     const integrationNode = {
         ...integrationBase,
@@ -86,8 +89,10 @@ export async function planLoopsFromRequest(input) {
     return plan;
 }
 function makeNode(input) {
+    const makerWorkerCount = dynamicMakerWorkerCount(input);
+    const checkerWorkerCount = dynamicCheckerWorkerCount(input);
     const budget = defaultLoopBudget({
-        max_subagents: input.route === '$Integration' ? 2 : 4,
+        max_subagents: input.route === '$Integration' ? 2 : Math.max(4, makerWorkerCount + checkerWorkerCount + 1),
         max_changed_files: input.ownerScope.files.length ? Math.max(4, input.ownerScope.files.length + 2) : 12
     });
     return {
@@ -105,14 +110,14 @@ function makeNode(input) {
         maker: {
             route: '$Naruto',
             role: input.route === '$Integration' ? 'planner' : input.loopId.includes('docs') ? 'writer' : 'implementer',
-            worker_count: input.route === '$Integration' ? 1 : 2,
+            worker_count: makerWorkerCount,
             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,
+            worker_count: checkerWorkerCount,
             fresh_session_required: true,
             stronger_model_required: input.risk.level === 'high' || input.risk.level === 'critical',
             required_before_next_iteration: input.level === 'L2-action'
@@ -133,6 +138,32 @@ function makeNode(input) {
         risk: input.risk
     };
 }
+// Maker parallelism scales with the loop's owned scope instead of a flat 2:
+// Naruto can fan out far wider, and a fixed count starved wide scopes while
+// over-provisioning single-file loops. Risk still clamps the ceiling so
+// critical work cannot stampede, and 'safe' mode keeps the old behavior.
+function dynamicMakerWorkerCount(input) {
+    if (input.route === '$Integration')
+        return 1;
+    const scopeSize = input.ownerScope.files.length + input.ownerScope.directories.length * 3;
+    const modeCap = input.parallelism === 'safe' ? 2 : input.parallelism === 'extreme' ? 8 : 6;
+    const riskCap = input.risk.level === 'critical' ? 2 : modeCap;
+    const riskFloor = input.risk.level === 'high' ? 3 : 2;
+    const scopeScaled = Math.max(riskFloor, Math.ceil(scopeSize / 3));
+    return Math.max(1, Math.min(modeCap, riskCap, scopeScaled));
+}
+// Checker workers are read-only GPT review lanes. They scale more conservatively
+// than makers, but wide/high-risk owner scopes get more than one fresh reviewer.
+function dynamicCheckerWorkerCount(input) {
+    if (input.route === '$Integration')
+        return 1;
+    const scopeSize = input.ownerScope.files.length + input.ownerScope.directories.length * 3;
+    const modeCap = input.parallelism === 'safe' ? 1 : input.parallelism === 'extreme' ? 4 : 3;
+    const riskFloor = input.risk.level === 'high' || input.risk.level === 'critical' ? 2 : 1;
+    const riskCap = input.risk.level === 'critical' ? Math.min(2, modeCap) : modeCap;
+    const scopeScaled = Math.max(riskFloor, Math.ceil(scopeSize / 6));
+    return Math.max(1, Math.min(modeCap, riskCap, scopeScaled));
+}
 function titleFromDomain(domainId) {
     return domainId === 'loop-general-coding' ? 'General coding loop' : `${domainId} loop`;
 }

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

@@ -0,0 +1,27 @@
+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) {
+    const request = await readJson(loopKillRequestPath(root, missionId), null);
+    return request?.target === 'all' || request?.target === loopId;
+}
+export async function checkpointCancelledLoop(root, node, iteration, phase) {
+    await writeLoopCheckpoint({
+        root,
+        mission_id: node.mission_id,
+        loop_id: node.loop_id,
+        iteration,
+        phase,
+        state_path: loopStatePath(root, node.mission_id, node.loop_id),
+        proof_path: loopProofPath(root, node.mission_id, node.loop_id),
+        resumable: true
+    });
+}
+//# sourceMappingURL=loop-runtime-control.js.map