sneakoscope 3.0.4 → 3.1.1

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

@@ -0,0 +1,63 @@
+export function defaultLoopBudget(overrides = {}) {
+    return {
+        max_iterations: 2,
+        max_wall_ms: 15 * 60 * 1000,
+        max_model_calls: 8,
+        max_subagents: 4,
+        max_tokens_estimate: 120000,
+        max_changed_files: 16,
+        max_patch_bytes: 256000,
+        ...overrides
+    };
+}
+export function validateLoopPlan(plan) {
+    const blockers = [
+        ...(plan.schema !== 'sks.loop-plan.v1' ? ['loop_plan_schema_invalid'] : []),
+        ...(!plan.mission_id ? ['loop_plan_mission_id_missing'] : []),
+        ...(!plan.request ? ['loop_plan_request_missing'] : []),
+        ...(!plan.integration_loop_id ? ['loop_plan_integration_loop_missing'] : []),
+        ...(plan.graph.nodes.length === 0 ? ['loop_plan_nodes_missing'] : []),
+        ...(!plan.graph.nodes.some((node) => node.loop_id === plan.integration_loop_id) ? ['loop_plan_integration_node_missing'] : [])
+    ];
+    const ids = new Set();
+    for (const node of plan.graph.nodes) {
+        const result = validateLoopNode(node);
+        blockers.push(...result.blockers);
+        if (ids.has(node.loop_id))
+            blockers.push(`loop_node_duplicate:${node.loop_id}`);
+        ids.add(node.loop_id);
+    }
+    for (const edge of plan.graph.edges) {
+        if (!ids.has(edge.from) || !ids.has(edge.to))
+            blockers.push(`loop_edge_unknown:${edge.from}->${edge.to}`);
+    }
+    return { ok: blockers.length === 0, blockers };
+}
+export function validateLoopNode(node) {
+    const blockers = [
+        ...(node.schema !== 'sks.loop-node.v1' ? [`loop_node_schema_invalid:${node.loop_id}`] : []),
+        ...(!node.loop_id ? ['loop_node_id_missing'] : []),
+        ...(!node.mission_id ? [`loop_node_mission_missing:${node.loop_id}`] : []),
+        ...(!node.state_file ? [`loop_state_file_missing:${node.loop_id}`] : []),
+        ...(!node.run_log_file ? [`loop_run_log_file_missing:${node.loop_id}`] : []),
+        ...(!node.owner_scope ? [`loop_owner_scope_missing:${node.loop_id}`] : []),
+        ...validateLoopBudget(node.budget).blockers.map((blocker) => `${node.loop_id}:${blocker}`),
+        ...(node.level === 'L3-unattended' && ['high', 'critical'].includes(node.risk.level) ? [`loop_l3_risk_blocked:${node.loop_id}`] : []),
+        ...(node.level === 'L2-action' && !node.checker.required_before_next_iteration ? [`loop_action_checker_missing:${node.loop_id}`] : [])
+    ];
+    return { ok: blockers.length === 0, blockers };
+}
+export function validateLoopBudget(budget) {
+    const blockers = [];
+    for (const [key, value] of Object.entries(budget)) {
+        if (!Number.isFinite(value) || value < 0)
+            blockers.push(`loop_budget_invalid:${key}`);
+    }
+    if (budget.max_iterations < 1)
+        blockers.push('loop_budget_iterations_missing');
+    return { ok: blockers.length === 0, blockers };
+}
+export function allGateIds(gates) {
+    return [...new Set([...gates.triage, ...gates.local, ...gates.checker, ...gates.integration, ...gates.final])];
+}
+//# sourceMappingURL=loop-schema.js.map

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

@@ -0,0 +1,61 @@
+import { appendJsonl, readJson, writeJsonAtomic } from '../fsx.js';
+import { loopRunLogPath, loopStatePath } from './loop-artifacts.js';
+export async function readLoopState(root, missionId, loopId) {
+    return readJson(loopStatePath(root, missionId, loopId), null);
+}
+export async function writeLoopState(root, state) {
+    await writeJsonAtomic(loopStatePath(root, state.mission_id, state.loop_id), state);
+    return state;
+}
+export async function appendLoopRunLog(root, missionId, loopId, event) {
+    await appendJsonl(loopRunLogPath(root, missionId, loopId), { ts: event.ts || new Date().toISOString(), ...event });
+}
+export async function updateLoopState(root, missionId, loopId, patch) {
+    const current = await readLoopState(root, missionId, loopId);
+    if (!current)
+        throw new Error(`loop_state_missing:${loopId}`);
+    const next = {
+        ...current,
+        ...patch,
+        acting_on: { ...current.acting_on, ...(patch.acting_on || {}) },
+        handoff: { ...current.handoff, ...(patch.handoff || {}) },
+        budget_used: { ...current.budget_used, ...(patch.budget_used || {}) },
+        updated_at: new Date().toISOString()
+    };
+    await writeLoopState(root, next);
+    return next;
+}
+export function initialLoopState(input) {
+    return {
+        schema: 'sks.loop-state.v1',
+        mission_id: input.missionId,
+        loop_id: input.loopId,
+        status: 'planned',
+        iteration: 0,
+        acting_on: {
+            files: input.files,
+            worktree_id: input.worktreeId || null,
+            branch: input.branch || null
+        },
+        current_phase: 'triage',
+        last_action: null,
+        last_gate_result: null,
+        last_checker_result: null,
+        blockers: [],
+        handoff: {
+            required: false,
+            reason: null,
+            artifact: null
+        },
+        budget_used: {
+            wall_ms: 0,
+            model_calls: 0,
+            subagents: 0,
+            iterations: 0,
+            changed_files: 0,
+            patch_bytes: 0
+        },
+        updated_at: new Date().toISOString()
+    };
+}
+//# sourceMappingURL=loop-state.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

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

@@ -0,0 +1,275 @@
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
+import { ensureDir, nowIso, readJson, runProcess, writeJsonAtomic } from '../fsx.js';
+import { loopNodeRoot } from './loop-artifacts.js';
+import { buildLoopCheckerPrompt, buildLoopMakerPrompt } from './loop-worker-prompts.js';
+export async function runLoopMakerWorkers(input) {
+    return runLoopWorkers({ ...input, phase: 'maker' });
+}
+export async function runLoopCheckerWorkers(input) {
+    return runLoopWorkers({ ...input, phase: 'checker', noMutation: true });
+}
+async function runLoopWorkers(input) {
+    if (shouldUseFixture(input))
+        return runLoopWorkerFixture(input);
+    return runLoopWorkerNative(input);
+}
+// `noMutation` used to force fixture mode here, which silently turned EVERY
+// checker run into a deterministic fixture (checkers always pass
+// noMutation: true for read-only semantics) — real model verification never
+// happened. Fixture mode is now an explicit, separate test-only signal.
+function shouldUseFixture(input) {
+    const requested = input.fixture === true || process.env.SKS_LOOP_RUNTIME_FIXTURE === '1';
+    if (!requested)
+        return false;
+    const allowed = loopFixtureAllowed(input);
+    if (!allowed.ok) {
+        throw new Error(`loop_fixture_runtime_forbidden:${allowed.reason}`);
+    }
+    return true;
+}
+async function runLoopWorkerNative(input) {
+    const prompt = input.phase === 'maker'
+        ? buildLoopMakerPrompt({ plan: input.plan, node: input.node, worktreePath: input.worktree?.path || null })
+        : buildLoopCheckerPrompt({ plan: input.plan, node: input.node, makerArtifacts: input.makerArtifacts || [] });
+    const workerCount = input.phase === 'maker' ? input.node.maker.worker_count : input.node.checker.worker_count;
+    const workGraph = buildLoopNarutoWorkGraph(input, workerCount);
+    // Root-cause-1 fix: keep the ORCHESTRATOR root on the MAIN repo (input.root), not the
+    // loop worktree. All zellij/right-column/slot-telemetry state derives from the orchestrator
+    // root, so anchoring it on input.root makes the SLOTS snapshot land under
+    // <main repo>/.sneakoscope/missions/<missionId>/... where the main session's anchor + slot
+    // renderer panes watch it (previously it landed under the worktree and went permanently stale).
+    // The loop worktree is still where workers cwd + write: it is threaded through the per-worker
+    // `worktree` opt below, which launchWorker reads as ctx.opts.worktree -> workerCwd.
+    const insideZellij = Boolean(process.env.SKS_ZELLIJ_SESSION_NAME || process.env.ZELLIJ);
+    const visiblePaneCap = Math.min(resolveLoopVisiblePaneCap(workerCount), Math.max(1, workerCount));
+    const zellijPlacementOpts = insideZellij ? {
+        workerPlacement: 'zellij-pane',
+        ...(process.env.SKS_ZELLIJ_SESSION_NAME ? { zellijSessionName: process.env.SKS_ZELLIJ_SESSION_NAME } : {}),
+        zellijVisiblePaneCap: visiblePaneCap
+    } : {};
+    const orchestrator = await runNativeAgentOrchestrator({
+        root: input.root,
+        missionId: input.plan.mission_id,
+        prompt,
+        route: '$Naruto',
+        backend: 'codex-sdk',
+        readonly: input.phase === 'checker',
+        workspaceWrite: input.phase === 'maker',
+        desiredWorkItemCount: workGraph.total_work_items,
+        minimumWorkItems: 1,
+        maxAgentCount: Math.max(1, workerCount),
+        targetActiveSlots: Math.max(1, workerCount),
+        visualLaneCount: visiblePaneCap,
+        narutoMode: true,
+        narutoWorkGraph: workGraph,
+        ...zellijPlacementOpts,
+        ...(input.worktree?.path ? {
+            worktree: {
+                id: input.worktree.id || `loop-${input.node.loop_id}-${input.phase}`,
+                path: input.worktree.path,
+                branch: input.worktree.branch || 'unknown',
+                main_repo_root: input.root
+            }
+        } : {}),
+        gitWorktreePolicy: input.worktree?.path ? {
+            mode: 'patch-envelope-only',
+            required: false,
+            main_repo_root: input.root,
+            worktree_root: input.worktree.path,
+            fallback_reason: null
+        } : null
+    });
+    return normalizeNativeResult(input, orchestrator);
+}
+async function normalizeNativeResult(input, result) {
+    const artifacts = collectArtifactPaths(result);
+    const changedFiles = stringArray(result?.changed_files || result?.proof?.changed_files || result?.results?.flatMap?.((row) => row?.changed_files || []));
+    const blockers = [
+        ...(result?.ok === true ? [] : ['loop_worker_native_orchestrator_not_ok']),
+        ...stringArray(result?.blockers || result?.proof?.blockers)
+    ];
+    const proofPath = path.join(loopNodeRoot(input.root, input.plan.mission_id, input.node.loop_id), input.phase, 'worker-runtime-result.json');
+    const normalized = {
+        schema: 'sks.loop-worker-run-result.v1',
+        ok: blockers.length === 0,
+        mission_id: input.plan.mission_id,
+        loop_id: input.node.loop_id,
+        phase: input.phase,
+        worker_count: input.phase === 'maker' ? input.node.maker.worker_count : input.node.checker.worker_count,
+        backend: 'native-agent-orchestrator',
+        artifacts,
+        patch_candidates: input.phase === 'maker' ? artifacts.filter((artifact) => artifact.includes('patch')) : [],
+        checker_findings: input.phase === 'checker' ? artifacts.filter((artifact) => artifact.includes('checker') || artifact.includes('finding')) : [],
+        changed_files: changedFiles,
+        blockers: [...new Set(blockers)],
+        runtime_proof_path: proofPath,
+        worker_ids: stringArray(result?.results?.map?.((row) => row?.agent_id || row?.id)),
+        session_ids: stringArray(result?.results?.map?.((row) => row?.session_id))
+    };
+    await writeJsonAtomic(proofPath, { ...normalized, native_result_summary: summarizeNativeResult(result), generated_at: nowIso() });
+    return normalized;
+}
+async function runLoopWorkerFixture(input) {
+    const dir = path.join(loopNodeRoot(input.root, input.plan.mission_id, input.node.loop_id), input.phase);
+    await ensureDir(dir);
+    const resultPath = path.join(dir, 'worker-runtime-result.json');
+    const childInputPath = path.join(dir, 'worker-fixture-intake.json');
+    await writeJsonAtomic(childInputPath, {
+        schema: 'sks.loop-worker-fixture-intake.v1',
+        root: input.root,
+        mission_id: input.plan.mission_id,
+        loop_id: input.node.loop_id,
+        phase: input.phase,
+        worker_count: input.phase === 'maker' ? input.node.maker.worker_count : input.node.checker.worker_count,
+        result_path: resultPath,
+        owner_scope: input.node.owner_scope,
+        maker_artifacts: input.makerArtifacts || []
+    });
+    const child = await runProcess(process.execPath, [fixtureChildEntrypoint(), childInputPath], {
+        cwd: input.root,
+        timeoutMs: input.timeoutMs || 30000,
+        maxOutputBytes: 64 * 1024
+    });
+    const result = await readJson(resultPath, null);
+    if (!result) {
+        return {
+            schema: 'sks.loop-worker-run-result.v1',
+            ok: false,
+            mission_id: input.plan.mission_id,
+            loop_id: input.node.loop_id,
+            phase: input.phase,
+            worker_count: 0,
+            backend: 'deterministic-fixture',
+            artifacts: [],
+            patch_candidates: [],
+            checker_findings: [],
+            changed_files: [],
+            blockers: [`loop_worker_fixture_child_missing_result:${child.code}`],
+            runtime_proof_path: resultPath,
+            worker_ids: [],
+            session_ids: []
+        };
+    }
+    return {
+        ...result,
+        ok: result.ok && child.code === 0,
+        blockers: [
+            ...result.blockers,
+            ...(child.code === 0 ? [] : [`loop_worker_fixture_child_exit:${child.code}`])
+        ]
+    };
+}
+function buildLoopNarutoWorkGraph(input, workerCount) {
+    const workItems = Array.from({ length: Math.max(1, workerCount) }, (_, index) => {
+        const id = `${input.node.loop_id}-${input.phase}-${index + 1}`;
+        const writeAllowed = input.phase === 'maker';
+        return {
+            id,
+            kind: writeAllowed ? 'code_modification' : 'verification',
+            title: `${input.phase} worker ${index + 1} for ${input.node.loop_id}`,
+            target_paths: [...input.node.owner_scope.files, ...input.node.owner_scope.directories],
+            readonly_paths: input.phase === 'checker' ? [...input.node.owner_scope.files, ...input.node.owner_scope.directories] : [],
+            write_paths: writeAllowed ? [...input.node.owner_scope.files, ...input.node.owner_scope.directories] : [],
+            required_role: input.phase,
+            write_allowed: writeAllowed,
+            verification_required: input.phase === 'checker',
+            dependencies: [],
+            can_run_in_parallel_with: [],
+            conflicts_with: [],
+            estimated_cost: { tokens: 8000, latency_ms: 30000, cpu_weight: 1, memory_mb: 512, gpu_weight: 0 },
+            lease_requirements: input.node.owner_scope.files.map((file) => ({ path: file, kind: writeAllowed ? 'write' : 'read' })),
+            acceptance: { requires_patch_envelope: writeAllowed, requires_verification: !writeAllowed, requires_gpt_final: input.node.risk.requires_gpt_final },
+            owner: input.node.loop_id,
+            allocation_reason: 'loop-worker-runtime',
+            allocation_score: 1,
+            allocation_hints: null,
+            lane: input.phase,
+            worktree: {
+                mode: input.worktree?.path ? 'patch-envelope-only' : 'git-worktree',
+                required: input.node.worktree.required,
+                allocation_required: false
+            }
+        };
+    });
+    return {
+        schema: 'sks.naruto-work-graph.v1',
+        route: '$Naruto',
+        requested_clones: workerCount,
+        total_work_items: workItems.length,
+        readonly: input.phase === 'checker',
+        write_capable: input.phase === 'maker',
+        work_items: workItems,
+        active_waves: [{ wave_id: `${input.node.loop_id}-${input.phase}`, work_item_ids: workItems.map((item) => item.id), write_paths: workItems.flatMap((item) => item.write_paths), conflict_count: 0 }],
+        mixed_work_kinds: [...new Set(workItems.map((item) => item.kind))],
+        write_allowed_count: workItems.filter((item) => item.write_allowed).length,
+        worktree_policy: {
+            mode: input.worktree?.path ? 'patch-envelope-only' : 'git-worktree',
+            required: input.node.worktree.required,
+            main_repo_root: input.root,
+            worktree_root: null,
+            fallback_reason: input.worktree?.path ? 'loop_worktree_already_allocated' : null
+        },
+        blockers: [],
+        ok: true
+    };
+}
+function collectArtifactPaths(result) {
+    return stringArray([
+        result?.ledger_root,
+        result?.proof?.artifact,
+        ...(Array.isArray(result?.results) ? result.results.flatMap((row) => row?.artifacts || row?.patch_queue_refs || []) : [])
+    ]);
+}
+function summarizeNativeResult(result) {
+    return {
+        ok: result?.ok === true,
+        status: result?.status || null,
+        mission_id: result?.mission_id || null,
+        backend: result?.backend || null,
+        result_count: Array.isArray(result?.results) ? result.results.length : 0,
+        blockers: stringArray(result?.blockers || result?.proof?.blockers).slice(0, 20)
+    };
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.flat().map((item) => String(item || '').trim()).filter(Boolean))];
+}
+// Visible pane cap for loop workers: defaults to min(4, workers) so the right
+// column stays readable; SKS_ZELLIJ_VISIBLE_PANE_CAP overrides for tall
+// terminals (overflow workers run headless and stay visible in SLOTS rows).
+function resolveLoopVisiblePaneCap(workerCount) {
+    const fromEnv = Number(process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || 0);
+    if (Number.isFinite(fromEnv) && fromEnv >= 1)
+        return Math.floor(fromEnv);
+    return Math.min(4, Math.max(1, workerCount));
+}
+function fixtureChildEntrypoint() {
+    return fileURLToPath(new URL('../../scripts/loop-worker-fixture-child.js', import.meta.url));
+}
+function loopFixtureAllowed(input) {
+    const argv = process.argv.join(' ');
+    const scriptIsCheck = /(?:^|\s)(?:.*[\/\\])?(?:dist|src)[\/\\]scripts[\/\\][^\s]*(?:check|blackbox)\.(?:js|ts)(?:\s|$)/.test(argv);
+    const explicitTestEnv = process.env.NODE_ENV === 'test'
+        || process.env.SKS_TEST_RUNTIME_FIXTURE_ALLOWED === '1'
+        || process.env.VITEST_WORKER_ID !== undefined
+        || process.env.JEST_WORKER_ID !== undefined
+        || process.env.NODE_V8_COVERAGE !== undefined;
+    const tempRoot = isUnderTempRoot(input.root) && /^M-check-/.test(input.plan.mission_id);
+    if (scriptIsCheck)
+        return { ok: true, reason: 'release_check_script' };
+    if (explicitTestEnv)
+        return { ok: true, reason: 'test_environment' };
+    if (tempRoot)
+        return { ok: true, reason: 'hermetic_temp_loop_check' };
+    return { ok: false, reason: 'fixture_requires_test_context' };
+}
+function isUnderTempRoot(root) {
+    const normalizedRoot = path.resolve(root);
+    const tempRoot = path.resolve(os.tmpdir());
+    return normalizedRoot === tempRoot || normalizedRoot.startsWith(`${tempRoot}${path.sep}`);
+}
+//# sourceMappingURL=loop-worker-runtime.js.map

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

@@ -0,0 +1,92 @@
+import path from 'node:path';
+import { exists, nowIso, writeJsonAtomic } from '../fsx.js';
+import { allocateWorkerWorktree } from '../git/git-worktree-manager.js';
+import { gitOutputLine, runGitCommand } from '../git/git-worktree-runner.js';
+import { loopNodeRoot } from './loop-artifacts.js';
+export async function allocateLoopWorktree(input) {
+    const blockers = [];
+    let worktreeId = null;
+    let worktreePath = null;
+    let branch = null;
+    let baseRef = null;
+    if (input.node.worktree.required && !input.noMutation) {
+        const gitPresent = await exists(path.join(input.root, '.git'));
+        if (!gitPresent) {
+            blockers.push('loop_worktree_required_but_git_missing');
+        }
+        else {
+            const allocation = await allocateWorkerWorktree({
+                repoRoot: input.root,
+                missionId: input.plan.mission_id,
+                workerId: input.node.loop_id,
+                slotId: input.node.loop_id,
+                generationIndex: 1,
+                branchPrefix: input.node.worktree.branch_prefix
+            }).catch((err) => ({ ok: false, blockers: [`loop_worktree_allocate_exception:${err instanceof Error ? err.message : String(err)}`] }));
+            if (allocation.ok) {
+                worktreeId = allocation.worker_id || input.node.loop_id;
+                worktreePath = allocation.worktree_path || null;
+                branch = allocation.branch || null;
+                baseRef = allocation.base_ref || null;
+            }
+            else {
+                blockers.push(...stringArray(allocation.blockers));
+            }
+        }
+    }
+    const record = {
+        schema: 'sks.loop-worktree.v1',
+        loop_id: input.node.loop_id,
+        worktree_id: worktreeId,
+        path: worktreePath,
+        branch,
+        base_ref: baseRef,
+        allocated_at: nowIso(),
+        cleanup_policy: input.node.worktree.cleanup,
+        blockers
+    };
+    await writeJsonAtomic(path.join(loopNodeRoot(input.root, input.plan.mission_id, input.node.loop_id), 'worktree.json'), record);
+    return record;
+}
+export async function computeLoopDiff(input) {
+    const cwd = input.worktreePath || input.root;
+    const blockers = [];
+    const names = await runGitCommand(cwd, ['diff', '--name-only', 'HEAD'], { timeoutMs: 30000 }).catch(() => null);
+    const stat = await runGitCommand(cwd, ['diff', '--stat', 'HEAD'], { timeoutMs: 30000 }).catch(() => null);
+    const diff = await runGitCommand(cwd, ['diff', '--binary', '--full-index', 'HEAD'], { timeoutMs: 60000 }).catch(() => null);
+    if (!names?.ok)
+        blockers.push('loop_git_diff_name_only_failed');
+    if (!diff?.ok)
+        blockers.push('loop_git_diff_failed');
+    const changedFiles = [...new Set((names?.stdout || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean))];
+    blockers.push(...enforceLoopOwnerScope(changedFiles, input.ownerScope));
+    return {
+        changed_files: changedFiles,
+        patch_bytes: Buffer.byteLength(diff?.stdout || ''),
+        diff_stat: stat ? gitOutputLine(stat) || stat.stdout.slice(-4000) : '',
+        blockers: [...new Set(blockers)]
+    };
+}
+export function enforceLoopOwnerScope(changedFiles, ownerScope) {
+    const blockers = [];
+    for (const file of changedFiles) {
+        if (!isInOwnerScope(file, ownerScope))
+            blockers.push(`loop_owner_scope_violation:${file}`);
+    }
+    return blockers;
+}
+function isInOwnerScope(file, ownerScope) {
+    const normalized = normalizePath(file);
+    if (ownerScope.files.map(normalizePath).includes(normalized))
+        return true;
+    return ownerScope.directories.map(normalizePath).some((dir) => normalized === dir || normalized.startsWith(`${dir}/`));
+}
+function normalizePath(value) {
+    return String(value || '').replace(/\\/g, '/').replace(/^\.\/+/, '');
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((item) => String(item || '').trim()).filter(Boolean);
+}
+//# sourceMappingURL=loop-worktree-runtime.js.map

package/dist/core/naruto/naruto-finalizer.js

@@ -5,14 +5,19 @@ export function evaluateNarutoFinalizer(input = {}) {
     const blockers = [
         ...(gptFinalRequired && !gptFinalAccepted ? ['naruto_local_worker_output_needs_gpt_final_arbiter'] : [])
     ];
+    const finalStatus = blockers.length ? 'blocked' : input.applyPatches === true ? 'accepted' : 'draft';
+    const applyFinalized = finalStatus === 'accepted';
     return {
         schema: 'sks.naruto-finalizer.v1',
         local_participated: localParticipated,
         gpt_final_required: gptFinalRequired,
-        final_status: blockers.length ? 'blocked' : input.applyPatches === true ? 'accepted' : 'draft',
+        final_status: finalStatus,
         final_patch_source: gptFinalRequired ? 'gpt_final_arbiter' : 'deterministic_no_local',
         blockers,
-        ok: blockers.length === 0
+        run_ok: blockers.length === 0,
+        release_proof_allowed: applyFinalized,
+        apply_finalized: applyFinalized,
+        ok: applyFinalized
     };
 }
 //# sourceMappingURL=naruto-finalizer.js.map

package/dist/core/naruto/naruto-loop-mesh.js

@@ -0,0 +1,39 @@
+import { writeJsonAtomic } from '../fsx.js';
+import { loopRoot } from '../loops/loop-artifacts.js';
+import { runLoopPlan } from '../loops/loop-runtime.js';
+import { routeNarutoLoopWorker } from './naruto-loop-worker-router.js';
+export async function runNarutoLoopMesh(input) {
+    const routes = input.plan.graph.nodes.flatMap((node) => [routeNarutoLoopWorker(node, 'maker'), routeNarutoLoopWorker(node, 'checker')]);
+    const activeWorkerBudget = splitActiveWorkerBudget(input.plan, input.parallelism);
+    await writeJsonAtomic(`${loopRoot(input.root, input.plan.mission_id)}/naruto-loop-worker-routes.json`, {
+        schema: 'sks.naruto-loop-worker-routes.v1',
+        mission_id: input.plan.mission_id,
+        active_worker_budget: activeWorkerBudget,
+        routes
+    });
+    return runLoopPlan({
+        root: input.root,
+        plan: input.plan,
+        parallelism: input.parallelism,
+        ...(input.dryRun === undefined ? {} : { dryRun: input.dryRun }),
+        ...(input.noMutation === undefined ? {} : { noMutation: input.noMutation })
+    });
+}
+export function splitActiveWorkerBudget(plan, parallelism) {
+    const cap = parallelism === 'safe' ? 8 : parallelism === 'extreme' ? 32 : 16;
+    const integrationReserved = 2;
+    const nonIntegration = plan.graph.nodes.filter((node) => node.route !== '$Integration');
+    const perLoopCap = Math.max(2, Math.floor((cap - integrationReserved) / Math.max(1, nonIntegration.length)));
+    const perLoop = nonIntegration.map((node) => ({
+        loop_id: node.loop_id,
+        maker_checker_workers: Math.min(perLoopCap, node.maker.worker_count + node.checker.worker_count)
+    }));
+    const used = perLoop.reduce((sum, row) => sum + row.maker_checker_workers, integrationReserved);
+    return {
+        global_active_workers: cap,
+        integration_reserved: integrationReserved,
+        per_loop: perLoop,
+        headroom: Math.max(0, cap - used)
+    };
+}
+//# sourceMappingURL=naruto-loop-mesh.js.map

package/dist/core/naruto/naruto-loop-worker-router.js

@@ -0,0 +1,38 @@
+export function routeNarutoLoopWorker(node, role) {
+    const domain = node.loop_id.replace(/^loop-/, '');
+    const roles = roleLabels(domain);
+    const gates = [...node.gates.triage, ...node.gates.local, ...node.gates.checker, ...node.gates.integration, ...node.gates.final];
+    return {
+        schema: 'sks.naruto-loop-worker-route.v1',
+        loop_id: node.loop_id,
+        maker_role: roles.maker,
+        checker_role: roles.checker,
+        prompt: [
+            `loop purpose: ${node.purpose}`,
+            `role: ${role === 'maker' ? roles.maker : roles.checker}`,
+            `owner files: ${node.owner_scope.files.join(', ') || '-'}`,
+            `owner directories: ${node.owner_scope.directories.join(', ') || '-'}`,
+            `gates: ${gates.join(', ') || '-'}`,
+            `state file: ${node.state_file}`,
+            `budget: ${JSON.stringify(node.budget)}`,
+            `collision policy: ${node.owner_scope.collision_policy}`,
+            'Do not mutate outside owner scope.'
+        ].join('\n'),
+        allowed_files: node.owner_scope.files,
+        allowed_directories: node.owner_scope.directories,
+        gates,
+        mutation_outside_owner_scope_allowed: false
+    };
+}
+function roleLabels(domain) {
+    if (domain.includes('zellij'))
+        return { maker: 'zellij implementer', checker: 'zellij QA/verifier' };
+    if (domain.includes('release'))
+        return { maker: 'release optimizer', checker: 'release gate verifier' };
+    if (domain.includes('research'))
+        return { maker: 'source shard/synthesis', checker: 'final reviewer' };
+    if (domain.includes('codex'))
+        return { maker: 'capability/probe implementer', checker: 'real probe verifier' };
+    return { maker: `${domain} implementer`, checker: `${domain} checker` };
+}
+//# sourceMappingURL=naruto-loop-worker-router.js.map