sneakoscope 2.0.13 → 2.0.15

package/dist/scripts/naruto-parallel-patch-apply-check.js

@@ -1,41 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const patchApply = await importDist('core/naruto/naruto-parallel-patch-apply.js');
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-naruto-patch-'));
-const envelopes = Array.from({ length: 10 }, (_, index) => {
-    const file = `file-${index}.txt`;
-    return envelope(index + 1, file, `after-${index}`);
-});
-const result = await patchApply.applyNarutoPatchEnvelopes(root, envelopes, { dryRun: false });
-assertGate(result.ok === true, 'non-overlapping patch fixture must apply', result);
-assertGate(result.batch_count === 1 && result.parallel_apply_count === 1, 'non-overlapping patch fixture must group into a parallel batch', result);
-assertGate(result.results.every((row) => row.changed_files.length === 1 && Object.keys(row.before_hashes).length === 1 && Object.keys(row.after_hashes).length === 1), 'patch results must include before/after hashes and changed files', result);
-const rollback = await patchApply.rollbackNarutoPatchResult(root, result.results[0]);
-assertGate(rollback.ok === true && rollback.restored.length === 1, 'rollback must restore before content for a patch result', rollback);
-const conflict = await patchApply.applyNarutoPatchEnvelopes(root, [envelope(99, 'same.txt', 'a'), envelope(100, 'same.txt', 'b')], { dryRun: true });
-assertGate(conflict.conflicts.length >= 1, 'overlapping patch fixture must serialize or mark conflict', conflict);
-emitGate('naruto:parallel-patch-apply', {
-    batch_count: result.batch_count,
-    parallel_apply_count: result.parallel_apply_count,
-    conflict_count: conflict.conflicts.length,
-    rollback_restored: rollback.restored.length
-});
-function envelope(index, file, content) {
-    return {
-        schema: 'sks.agent-patch-envelope.v1',
-        source: 'fixture',
-        agent_id: `naruto-${index}`,
-        session_id: `session-${index}`,
-        slot_id: `slot-${index}`,
-        generation_index: 1,
-        task_slice_id: `NW-${index}`,
-        lease_id: `lease-${index}`,
-        allowed_paths: [file],
-        operations: [{ op: 'write', path: file, content }]
-    };
-}
-//# sourceMappingURL=naruto-parallel-patch-apply-check.js.map

package/dist/scripts/naruto-readonly-routing-check.js

@@ -1,116 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, exists, importDist, root } from './sks-1-18-gate-lib.js';
-const worker = await importDist('core/agents/agent-worker-pipeline.js');
-const cli = path.join(root, 'dist', 'bin', 'sks.js');
-assertGate(exists('dist/bin/sks.js'), 'dist/bin/sks.js missing (build first)');
-const readOnlyWorker = worker.validateAgentWorkerResult({
-    mission_id: 'M-readonly-routing',
-    agent_id: 'readonly-agent',
-    session_id: 'readonly-session',
-    persona_id: 'verifier',
-    task_slice_id: 'readonly-slice',
-    status: 'done',
-    backend: 'codex-sdk',
-    summary: 'Read-only worker inspected files without proposing a patch.',
-    findings: ['read-only inspection completed'],
-    proposed_changes: [],
-    changed_files: ['src/core/agents/agent-proof-evidence.ts'],
-    lease_compliance: { ok: true, violations: [] },
-    artifacts: [],
-    blockers: [],
-    confidence: 'fixture',
-    handoff_notes: '',
-    unverified: [],
-    writes: [],
-    no_patch_reason: {
-        ok: true,
-        reason: 'read_only_or_no_write_paths',
-        read_only_or_noop_evidence: true
-    },
-    verification: { status: 'passed', checks: ['readonly-no-patch-routing'] }
-});
-assertGate(readOnlyWorker.status === 'done' && !readOnlyWorker.blockers.includes('no_patch_generated'), 'read-only/no-write worker changed_files must not require patch envelopes', readOnlyWorker);
-const writeWorker = worker.validateAgentWorkerResult({
-    ...readOnlyWorker,
-    agent_id: 'write-agent',
-    session_id: 'write-session',
-    task_slice_id: 'write-slice',
-    changed_files: ['src/core/agents/agent-proof-evidence.ts'],
-    no_patch_reason: undefined
-});
-assertGate(writeWorker.status === 'blocked' && writeWorker.blockers.includes('no_patch_generated'), 'write-capable changed_files without patch envelope must still block', writeWorker);
-const readonlyRun = spawnSync(process.execPath, [
-    cli,
-    'naruto',
-    'run',
-    'readonly routing must inspect `src/core/agents/agent-proof-evidence.ts` and `package.json` without writes',
-    '--clones',
-    '4',
-    '--work-items',
-    '4',
-    '--backend',
-    'fake',
-    '--readonly',
-    '--json'
-], { cwd: root, encoding: 'utf8', timeout: 120000, maxBuffer: 6 * 1024 * 1024 });
-const readonlyJson = parseJson(readonlyRun.stdout);
-assertGate(readonlyRun.status === 0 && readonlyJson?.ok === true, 'readonly Naruto fake blackbox must exit ok', { status: readonlyRun.status, stdout: tail(readonlyRun.stdout), stderr: tail(readonlyRun.stderr) });
-assertGate(readonlyJson.proof === 'passed', 'readonly Naruto proof must pass', { proof: readonlyJson.proof, blockers: readonlyJson.run?.proof?.blockers });
-assertGate(readonlyJson.work_graph?.write_allowed_count === 0, 'readonly Naruto work graph must have zero write-allowed items', readonlyJson.work_graph);
-assertGate(Number(readonlyJson.role_distribution?.implementation_like_workers || 0) === 0, 'readonly Naruto role distribution must have zero implementation-like workers', readonlyJson.role_distribution);
-assertGate((readonlyJson.role_distribution?.entries || []).every((entry) => entry.write_allowed === false), 'readonly Naruto role distribution must deny writes for every role', readonlyJson.role_distribution);
-const readonlyRoot = path.join(root, '.sneakoscope', 'missions', readonlyJson.mission_id, 'agents');
-const readonlyProof = readJson(path.join(readonlyRoot, 'agent-proof-evidence.json'));
-const readonlyStrategy = readJson(path.join(readonlyRoot, 'user-request-strategy.json'));
-const readonlyPolicy = readJson(path.join(readonlyRoot, 'agent-parallel-write-policy.json'));
-assertGate(readonlyPolicy.write_mode === 'off' && readonlyPolicy.readonly === true, 'readonly run must force native write policy off', readonlyPolicy);
-assertGate(readonlyStrategy.gate?.write_task_count === 0, 'readonly strategy must not infer write targets from file mentions', readonlyStrategy.gate);
-assertGate(readonlyProof.changed_files_lease_checked === false, 'readonly no-write proof must skip changed_files write-lease checks', readonlyProof);
-assertGate(!(readonlyProof.blockers || []).some((blocker) => /no_patch_generated|lease_changed_file_violation/.test(String(blocker))), 'readonly proof must not contain patch/lease write blockers', readonlyProof.blockers || []);
-const writeRun = spawnSync(process.execPath, [
-    cli,
-    'naruto',
-    'run',
-    'write-capable routing must patch `README.md` through leased envelopes',
-    '--clones',
-    '3',
-    '--work-items',
-    '3',
-    '--backend',
-    'fake',
-    '--parallel-write',
-    '--json'
-], { cwd: root, encoding: 'utf8', timeout: 120000, maxBuffer: 6 * 1024 * 1024 });
-const writeJson = parseJson(writeRun.stdout);
-assertGate(writeRun.status === 0 && writeJson?.ok === true, 'write-capable Naruto fake blackbox must exit ok', { status: writeRun.status, stdout: tail(writeRun.stdout), stderr: tail(writeRun.stderr) });
-const writeRoot = path.join(root, '.sneakoscope', 'missions', writeJson.mission_id, 'agents');
-const writeStrategy = readJson(path.join(writeRoot, 'user-request-strategy.json'));
-const writePolicy = readJson(path.join(writeRoot, 'agent-parallel-write-policy.json'));
-assertGate(writePolicy.write_mode === 'parallel' && writePolicy.readonly === false, 'write-capable Naruto run must carry parallel write policy', writePolicy);
-assertGate(writeStrategy.gate?.write_task_count >= 1, 'write-capable strategy must retain explicit write target inference', writeStrategy.gate);
-emitGate('naruto:readonly-routing', {
-    readonly_mission_id: readonlyJson.mission_id,
-    write_mission_id: writeJson.mission_id,
-    readonly_write_tasks: readonlyStrategy.gate?.write_task_count,
-    write_write_tasks: writeStrategy.gate?.write_task_count
-});
-function readJson(file) {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-}
-function parseJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-}
-function tail(value, limit = 2000) {
-    const text = String(value || '');
-    return text.length <= limit ? text : text.slice(-limit);
-}
-//# sourceMappingURL=naruto-readonly-routing-check.js.map

package/dist/scripts/naruto-real-active-pool-check.js

@@ -1,39 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { buildNarutoWorkGraph } from '../core/naruto/naruto-work-graph.js';
-import { decideNarutoConcurrency } from '../core/naruto/naruto-concurrency-governor.js';
-import { runNarutoRealActivePool } from '../core/naruto/naruto-active-pool.js';
-const graph = buildNarutoWorkGraph({ requestedClones: 12, totalWorkItems: 24, writeCapable: true, maxActiveWorkers: 6 });
-const governor = decideNarutoConcurrency({
-    requestedClones: 12,
-    totalWorkItems: graph.total_work_items,
-    pendingWorkQueueSize: graph.total_work_items,
-    backend: 'codex-sdk',
-    hardware: { cpuCoreCount: 8, freeMemoryBytes: 32 * 1024 * 1024 * 1024, totalMemoryBytes: 64 * 1024 * 1024 * 1024, fileDescriptorLimit: 4096, processCount: 100, terminalRows: 40, remoteApiRateLimitBudget: 8 }
-});
-const target = { ...governor, safe_active_workers: Math.min(6, governor.safe_active_workers), safe_zellij_visible_panes: 3 };
-let spawned = 0;
-let collected = 0;
-let dashboardEvents = 0;
-const report = await runNarutoRealActivePool({
-    graph,
-    governor: target,
-    spawnWorker: async (item, placement) => {
-        spawned += 1;
-        return { id: item.id, item, placement, started_at: Date.now() };
-    },
-    collectWorker: async (handle) => {
-        collected += 1;
-        return { id: handle.id, ok: true, item: handle.item, placement: handle.placement, completed_at: Date.now() };
-    },
-    enqueueVerification: async () => undefined,
-    updateDashboard: async () => {
-        dashboardEvents += 1;
-    }
-});
-const processEvidence = report.worker_lifecycle.every((row) => row.pid == null || row.worker_artifact_dir != null);
-const ok = report.ok && spawned === graph.total_work_items && collected === graph.total_work_items && report.max_observed_active_workers >= target.safe_active_workers && dashboardEvents > graph.total_work_items && report.active_cap === target.safe_active_workers && processEvidence;
-assertGate(ok, 'Naruto real active pool must run spawn/collect lifecycle and refill to cap', { report, spawned, collected, dashboardEvents, target });
-emitGate('naruto:real-active-pool', { spawned, collected, active_cap: report.active_cap, max_observed_active_workers: report.max_observed_active_workers, refill_latency_ms_p95: report.refill_latency_ms_p95, active_pool_utilization: report.active_pool_utilization });
-//# sourceMappingURL=naruto-real-active-pool-check.js.map

package/dist/scripts/naruto-real-active-pool-runtime-check.js

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { buildNarutoWorkGraph } from '../core/naruto/naruto-work-graph.js';
-import { decideNarutoConcurrency } from '../core/naruto/naruto-concurrency-governor.js';
-import { runNarutoRealActivePool } from '../core/naruto/naruto-active-pool.js';
-import { collectActualNarutoWorker, spawnActualNarutoWorker } from '../core/naruto/naruto-real-worker-runtime.js';
-process.env.SKS_CODEX_SDK_FAKE = '1';
-const graph = buildNarutoWorkGraph({ requestedClones: 12, totalWorkItems: 24, writeCapable: false, maxActiveWorkers: 6 });
-const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-real-runtime-'));
-const missionId = `M-naruto-real-runtime-${process.pid}`;
-const governor = decideNarutoConcurrency({
-    requestedClones: 12,
-    totalWorkItems: graph.total_work_items,
-    pendingWorkQueueSize: graph.total_work_items,
-    backend: 'codex-sdk',
-    hardware: { cores: 8, freeMemoryBytes: 32 * 1024 * 1024 * 1024, totalMemoryBytes: 64 * 1024 * 1024 * 1024, fileDescriptorLimit: 4096, processCount: 100, terminalRows: 40, remoteApiRateLimitBudget: 8 }
-});
-let spawned = 0;
-let collected = 0;
-const target = { ...governor, safe_active_workers: Math.min(6, governor.safe_active_workers), safe_zellij_visible_panes: 3 };
-const report = await runNarutoRealActivePool({
-    graph,
-    governor: target,
-    spawnWorker: async (item, placement) => {
-        spawned += 1;
-        return spawnActualNarutoWorker({
-            root: tempRoot,
-            missionId,
-            item,
-            placement,
-            backend: 'fake',
-            visiblePaneCap: target.safe_zellij_visible_panes,
-            zellijSessionName: `sks-${missionId}`
-        });
-    },
-    collectWorker: async (handle) => {
-        collected += 1;
-        return collectActualNarutoWorker(handle);
-    },
-    enqueueVerification: async () => undefined,
-    updateDashboard: async () => undefined
-});
-const processEvidence = report.worker_lifecycle.every((row) => row.pid && row.worker_artifact_dir);
-const artifactEvidence = report.worker_lifecycle.every((row) => row.worker_artifact_dir
-    && fs.existsSync(path.join(row.worker_artifact_dir, 'worker-heartbeat.jsonl'))
-    && fs.existsSync(path.join(row.worker_artifact_dir, 'worker-result.json'))
-    && fs.existsSync(path.join(row.worker_artifact_dir, 'codex-control', 'codex-control-proof.json')));
-const ok = report.ok && spawned === graph.total_work_items && collected === graph.total_work_items && report.max_observed_active_workers >= target.safe_active_workers && report.active_pool_utilization >= 0.8 && processEvidence && artifactEvidence;
-assertGate(ok, 'Naruto real active pool runtime must include actual child process, heartbeat, and result evidence', { report, spawned, collected, processEvidence, artifactEvidence, tempRoot });
-emitGate('naruto:real-active-pool-runtime', report);
-//# sourceMappingURL=naruto-real-active-pool-runtime-check.js.map

package/dist/scripts/naruto-rebalance-policy-check.js

@@ -1,41 +0,0 @@
-#!/usr/bin/env node
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { rebalanceNarutoReadyWork } from '../core/naruto/naruto-rebalance-policy.js';
-const item = (id, dependencies = []) => ({
-    id,
-    kind: 'verification',
-    title: id,
-    target_paths: ['src/core/naruto/runtime.ts'],
-    readonly_paths: ['src/core/naruto/runtime.ts'],
-    write_paths: [],
-    required_role: 'verifier',
-    write_allowed: false,
-    verification_required: true,
-    dependencies,
-    can_run_in_parallel_with: [],
-    conflicts_with: [],
-    estimated_cost: { tokens: 1, latency_ms: 1, cpu_weight: 1, memory_mb: 1, gpu_weight: 0 },
-    lease_requirements: [],
-    acceptance: { requires_patch_envelope: false, requires_verification: true, requires_gpt_final: false }
-});
-const decisions = rebalanceNarutoReadyWork({
-    tasks: [item('A'), item('B', ['A'])],
-    workers: [{ id: 'idle-1', role: 'verifier', lane: 'src/core', alive: true, state: 'idle' }],
-    completedTaskIds: []
-});
-const inactiveOwner = rebalanceNarutoReadyWork({
-    tasks: [{ ...item('C'), owner: 'missing-worker' }],
-    workers: [{ id: 'idle-2', role: 'verifier', lane: 'src/core', alive: true, state: 'idle' }],
-    completedTaskIds: []
-});
-const writeConflict = rebalanceNarutoReadyWork({
-    tasks: [{ ...item('D'), write_paths: ['src/core/naruto/runtime.ts'], write_allowed: true }],
-    workers: [{ id: 'idle-3', role: 'verifier', lane: 'src/core', alive: true, state: 'idle' }],
-    completedTaskIds: [],
-    activeWritePaths: ['src/core/naruto/runtime.ts']
-});
-assertGate(decisions.length === 1 && decisions[0]?.task_id === 'A'
-    && inactiveOwner.length === 1 && inactiveOwner[0]?.worker_id === 'idle-2'
-    && writeConflict.length === 0, 'Naruto rebalance must assign dependency-ready work, reassign inactive owners, and skip active write conflicts', { decisions, inactiveOwner, writeConflict });
-emitGate('naruto:rebalance-policy', { decisions, inactiveOwner, writeConflict });
-//# sourceMappingURL=naruto-rebalance-policy-check.js.map

package/dist/scripts/naruto-role-distribution-check.js

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const workGraph = await importDist('core/naruto/naruto-work-graph.js');
-const roles = await importDist('core/naruto/naruto-role-policy.js');
-const roster = await importDist('core/agents/agent-roster.js');
-const graph = workGraph.buildNarutoWorkGraph({ requestedClones: 30, totalWorkItems: 30, writeCapable: true });
-const distribution = roles.buildNarutoRoleDistribution(graph.work_items);
-const cloneRoster = roster.buildNarutoCloneRoster({ clones: 30, prompt: 'implement, modify, test, verify, document, and resolve conflicts' });
-const writeCapableRoster = cloneRoster.roster.filter((row) => row.write_allowed === true);
-assertGate(distribution.ok === true, 'write-capable Naruto role distribution must pass', distribution);
-assertGate(distribution.verifier_only === false, 'default Naruto must not be verifier-only', distribution);
-assertGate(distribution.implementation_like_ratio >= 0.4, 'default Naruto must keep at least 40% implementation/modification/test roles', distribution);
-assertGate(writeCapableRoster.length >= Math.floor(cloneRoster.roster.length * 0.4), 'Naruto roster must include write-capable clone roles by default', { writeCapableRoster: writeCapableRoster.length, total: cloneRoster.roster.length });
-const readonlyGraph = workGraph.buildNarutoWorkGraph({ requestedClones: 8, readonly: true, writeCapable: false });
-const readonlyDistribution = roles.buildNarutoRoleDistribution(readonlyGraph.work_items, { readonly: true });
-assertGate(readonlyDistribution.ok === true, 'readonly Naruto route may use read-only verifier/research roles', readonlyDistribution);
-emitGate('naruto:role-distribution', {
-    implementation_like_ratio: distribution.implementation_like_ratio,
-    entries: distribution.entries,
-    write_capable_roster_count: writeCapableRoster.length
-});
-//# sourceMappingURL=naruto-role-distribution-check.js.map

package/dist/scripts/naruto-shadow-clone-swarm-check.js

@@ -1,153 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-// $Naruto Shadow Clone Swarm gate.
-// Proves the high-scale mode lifts the standard 20-agent ceiling to 100 clones WITHOUT
-// changing it for any other route, and that an end-to-end `sks naruto run` actually
-// schedules >20 concurrent clone sessions to completion with proof.
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root, exists } from './sks-1-18-gate-lib.js';
-const schema = await importDist('core/agents/agent-schema.js');
-const roster = await importDist('core/agents/agent-roster.js');
-const scheduler = await importDist('core/agents/agent-scheduler.js');
-const effortPolicy = await importDist('core/agents/agent-effort-policy.js');
-// 1) Naruto ceiling exists and is 100; standard ceiling untouched at 20.
-assertGate(schema.MAX_NARUTO_AGENT_COUNT === 100, 'MAX_NARUTO_AGENT_COUNT must be 100', { value: schema.MAX_NARUTO_AGENT_COUNT });
-assertGate(schema.MAX_AGENT_COUNT === 20, 'MAX_AGENT_COUNT must remain 20 (standard ceiling)', { value: schema.MAX_AGENT_COUNT });
-// 2) Cap is lifted ONLY when the naruto max is passed; default callers still clamp to 20.
-const narutoSlots = scheduler.normalizeTargetActiveSlots(100, schema.MAX_NARUTO_AGENT_COUNT);
-const defaultSlots = scheduler.normalizeTargetActiveSlots(100);
-assertGate(narutoSlots === 100, 'normalizeTargetActiveSlots(100, naruto-max) must be 100', { narutoSlots });
-assertGate(defaultSlots === 20, 'normalizeTargetActiveSlots(100) default must stay clamped to 20', { defaultSlots });
-// 3) A 100-clone roster builds 100 unique clones (no unique-persona ceiling).
-const fullRoster = roster.buildNarutoCloneRoster({ clones: 100, maxAgentCount: schema.MAX_NARUTO_AGENT_COUNT });
-const uniqueIds = new Set(fullRoster.roster.map((row) => row.id)).size;
-assertGate(fullRoster.agent_count === 100, 'clone roster must have 100 clones', { agent_count: fullRoster.agent_count });
-assertGate(uniqueIds === 100, 'clone roster ids must be unique', { uniqueIds });
-assertGate(fullRoster.max_agents === 100, 'clone roster max_agents must be 100', { max_agents: fullRoster.max_agents });
-// 4) Over-cap is clamped, not crashed.
-const overCap = roster.buildNarutoCloneRoster({ clones: 500, maxAgentCount: schema.MAX_NARUTO_AGENT_COUNT });
-assertGate(overCap.agent_count === 100, 'clones above the ceiling clamp to 100', { agent_count: overCap.agent_count });
-// 4b) Dynamic per-clone effort policy (like team mode), capped + always fast.
-//     A neutral/no-tool prompt yields a low/medium MIX: read-only personas -> low, writers -> medium.
-const effortRoster = roster.buildNarutoCloneRoster({ clones: 24, prompt: 'review and summarize the current findings', maxAgentCount: schema.MAX_NARUTO_AGENT_COUNT });
-const efforts = new Set(effortRoster.roster.map((row) => row.reasoning_effort));
-const tiers = new Set(effortRoster.roster.map((row) => row.service_tier));
-const fastFlags = new Set(effortRoster.roster.map((row) => row.fast_mode));
-assertGate([...efforts].every((e) => e === 'low' || e === 'medium'), 'naruto clone efforts must be only low/medium (never high/xhigh)', { efforts: [...efforts] });
-assertGate(efforts.has('low') && efforts.has('medium'), 'naruto effort must be dynamic: a no-tool prompt must yield both low and medium clones', { efforts: [...efforts] });
-assertGate([...tiers].length === 1 && tiers.has('fast'), 'every naruto clone must be fast service tier', { tiers: [...tiers] });
-assertGate([...fastFlags].length === 1 && fastFlags.has(true), 'every naruto clone must have fast_mode=true', { fastFlags: [...fastFlags] });
-// 4c) Unit rule: no tool use -> low; any tool use -> medium; always fast.
-const simple = effortPolicy.decideNarutoCloneEffort({ readonly: true, prompt: 'explain the architecture overview' });
-const toolWrite = effortPolicy.decideNarutoCloneEffort({ readonly: false, prompt: 'add a feature' });
-const toolReadCmd = effortPolicy.decideNarutoCloneEffort({ readonly: true, prompt: 'run the build and apply the migration' });
-assertGate(simple.reasoning_effort === 'low' && simple.service_tier === 'fast', 'no-tool read-only work must be low + fast', { simple });
-assertGate(toolWrite.reasoning_effort === 'medium' && toolWrite.service_tier === 'fast', 'writing clone (tool use) must be medium + fast', { toolWrite });
-assertGate(toolReadCmd.reasoning_effort === 'medium' && toolReadCmd.service_tier === 'fast', 'read-only work with tool/command signals must be medium + fast', { toolReadCmd });
-// 5) System-safe concurrency: never spawn the whole count at once; throttle to host capacity.
-const fakeSafe = roster.systemSafeNarutoConcurrency({ backend: 'fake' });
-const heavySafe = roster.systemSafeNarutoConcurrency({ backend: 'codex-sdk' });
-const lowFreeButCapable = roster.systemSafeNarutoConcurrency({
-    backend: 'codex-sdk',
-    cores: 10,
-    freeBytes: 512 * 1024 * 1024,
-    totalBytes: 16 * 1024 * 1024 * 1024
-});
-assertGate(fakeSafe.cap >= 1 && fakeSafe.cap <= schema.MAX_NARUTO_AGENT_COUNT, 'fake-backend concurrency cap must be in [1, 100]', { fakeSafe });
-// codex-sdk workers are network-bound (each mostly idle awaiting the Codex API),
-// so concurrency is bounded by MEMORY + the 100-clone ceiling, NOT by CPU cores: a
-// capable host may run up to MAX_NARUTO_AGENT_COUNT in parallel.
-assertGate(heavySafe.cap >= 1 && heavySafe.cap <= schema.MAX_NARUTO_AGENT_COUNT, 'heavy-backend concurrency cap must be in [1, 100]', { heavySafe });
-assertGate(heavySafe.cap <= fakeSafe.cap, 'heavy backend must throttle no looser than the light backend', { heavySafe, fakeSafe });
-assertGate(heavySafe.cores >= 1, 'must detect at least one core', { cores: heavySafe.cores });
-assertGate(lowFreeButCapable.cap >= 4, 'capable hosts must not collapse Naruto codex-sdk concurrency to 1 just because free memory is low', { lowFreeButCapable });
-// A big-memory host is NOT throttled by core count: simulate 64 GB and assert the
-// heavy backend scales well past the old 16-core-derived ceiling toward 100.
-const bigMemoryHost = roster.systemSafeNarutoConcurrency({ backend: 'codex-sdk', cores: 4, freeBytes: 48 * 1024 * 1024 * 1024, totalBytes: 64 * 1024 * 1024 * 1024 });
-assertGate(bigMemoryHost.cap >= 64, 'a 64 GB host must allow >= 64 parallel codex-sdk workers regardless of core count (network-bound, memory-budgeted)', { bigMemoryHost });
-// 6) End-to-end run: 24 clones (> standard 20 -> ceiling lifted) all complete, while
-//    release verification keeps live slots bounded so the gate stays hermetic under DAG load.
-const proofClones = 24;
-const proofConcurrency = 6;
-const cli = path.join(root, 'dist', 'bin', 'sks.js');
-const isolatedWorktreeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-shadow-wt-'));
-const childEnv = { ...process.env, SKS_WORKTREE_ROOT: isolatedWorktreeRoot };
-assertGate(exists('dist/bin/sks.js'), 'dist/bin/sks.js missing (build first)');
-const helpRun = spawnSync(process.execPath, [cli, 'naruto', '--help', '--json'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 30000, maxBuffer: 1024 * 1024 });
-const helpParsed = parseJson(helpRun.stdout);
-assertGate(helpRun.status === 0 && helpParsed?.action === 'help', 'sks naruto --help must emit help instead of launching a run', { status: helpRun.status, stdout: tail(helpRun.stdout), stderr: tail(helpRun.stderr) });
-const run = spawnSync(process.execPath, [
-    cli, 'naruto', 'run', 'shadow clone swarm gate proof',
-    '--clones', String(proofClones),
-    '--backend', 'fake',
-    '--work-items', String(proofClones),
-    '--concurrency', String(proofConcurrency),
-    '--json'
-], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 300000, maxBuffer: 8 * 1024 * 1024 });
-assertGate(run.status === 0, 'sks naruto run must exit 0', { status: run.status, stderr: tail(run.stderr) });
-const parsed = parseJson(run.stdout);
-assertGate(parsed !== null, 'sks naruto run must emit JSON', { stdout: tail(run.stdout) });
-assertGate(parsed.ok === true, 'naruto run must be ok', { ok: parsed.ok });
-assertGate(parsed.mode === 'NARUTO' && parsed.jutsu === 'kage_bunshin_no_jutsu', 'naruto run must report NARUTO mode', { mode: parsed.mode, jutsu: parsed.jutsu });
-assertGate(parsed.clones === proofClones, 'clone fan-out must use the requested count (> standard 20 ceiling)', { clones: parsed.clones });
-assertGate(parsed.max_clones === 100, 'naruto run must advertise the 100 ceiling', { max_clones: parsed.max_clones });
-assertGate(parsed.proof === 'passed', 'naruto run proof must pass', { proof: parsed.proof });
-// Throttle invariant: active concurrency never exceeds the requested count nor the host cap.
-assertGate(parsed.target_active_slots >= 1 && parsed.target_active_slots <= proofClones, 'active slots must be in [1, clones]', { target_active_slots: parsed.target_active_slots });
-assertGate(parsed.target_active_slots <= fakeSafe.cap, 'active slots must be throttled to the system-safe cap', { target_active_slots: parsed.target_active_slots, cap: fakeSafe.cap });
-assertGate(parsed.target_active_slots === proofConcurrency, 'release proof must keep Naruto live slots bounded while fan-out stays >20', { target_active_slots: parsed.target_active_slots, proofConcurrency });
-// Task 9.1: fan-out (clones) and live concurrency (target_active_slots) are reported
-// distinctly, and concurrency_capped truthfully reflects "N clones, running M at a time".
-assertGate(typeof parsed.concurrency_capped === 'boolean', 'naruto run must report concurrency_capped', { concurrency_capped: parsed.concurrency_capped });
-assertGate(parsed.concurrency_capped === (parsed.clones > parsed.target_active_slots), 'concurrency_capped must reflect clones > live slots', { clones: parsed.clones, target_active_slots: parsed.target_active_slots, concurrency_capped: parsed.concurrency_capped });
-assertGate(parsed.system && Number(parsed.system.safe_concurrency) >= 1, 'naruto run must report system safe_concurrency (host-derived cap)', { system: parsed.system });
-assertGate(parsed.work_graph?.write_allowed_count > 0 && parsed.work_graph?.mixed_work_kinds?.length > 1, 'naruto run must report a mixed work graph with write-capable items', { work_graph: parsed.work_graph });
-assertGate(Number(parsed.work_graph?.parallel_write_wave_count || 0) > 0, 'naruto run must expose at least one parallel write-capable wave with non-overlapping leases', { work_graph: parsed.work_graph });
-assertGate(parsed.role_distribution?.verifier_only === false, 'naruto run proof/status must distinguish active worker roles beyond verifier-only', { role_distribution: parsed.role_distribution });
-assertGate(Number(parsed.role_distribution?.implementation_like_ratio || 0) >= 0.4, 'naruto run must include implementation-like role distribution', { role_distribution: parsed.role_distribution });
-const commandGraphPath = path.join(root, '.sneakoscope', 'missions', parsed.mission_id, 'agents', 'naruto-work-graph.json');
-const commandGraph = JSON.parse(fs.readFileSync(commandGraphPath, 'utf8'));
-const writePaths = commandGraph.work_items.filter((row) => row.write_allowed).flatMap((row) => row.write_paths);
-assertGate(new Set(writePaths).size > 1, 'naruto command default patch-envelope leases must be per work item, not one shared write path', { sample: writePaths.slice(0, 8), unique: new Set(writePaths).size });
-assertGate(commandGraph.active_waves.some((wave) => wave.write_paths.length > 1), 'naruto command graph must contain a parallel write wave when route-local patch envelopes do not overlap', { waves: commandGraph.active_waves.slice(0, 3) });
-const state = parsed.run?.scheduler?.state || parsed.run?.scheduler || {};
-assertGate(Number(state.completed_count) === Number(parsed.work_graph?.total_work_items || 0) && Number(state.completed_count) >= proofClones, 'all clone work items must complete despite throttling', { completed_count: state.completed_count, total_work_items: parsed.work_graph?.total_work_items, proofClones });
-const explicitConcurrency = spawnSync(process.execPath, [cli, 'naruto', 'run', 'explicit concurrency', '--clones', '6', '--backend', 'fake', '--work-items', '6', '--concurrency', '6', '--json'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 120000, maxBuffer: 4 * 1024 * 1024 });
-const explicitParsed = parseJson(explicitConcurrency.stdout);
-assertGate(explicitConcurrency.status === 0 && explicitParsed?.target_active_slots === 6, 'explicit --concurrency must let Naruto use the requested parallel slot count', { status: explicitConcurrency.status, target_active_slots: explicitParsed?.target_active_slots });
-// 7) A small request is NOT throttled below what was asked (cap only ever reduces, never inflates).
-const small = spawnSync(process.execPath, [cli, 'naruto', 'run', 'tiny', '--clones', '2', '--backend', 'fake', '--work-items', '2', '--json'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 120000, maxBuffer: 4 * 1024 * 1024 });
-const smallParsed = parseJson(small.stdout);
-assertGate(small.status === 0 && smallParsed?.target_active_slots === 2, 'a 2-clone run must run 2 concurrently (no over-throttle)', { status: small.status, target_active_slots: smallParsed?.target_active_slots });
-emitGate('naruto:shadow-clone-swarm', {
-    max_naruto_agent_count: schema.MAX_NARUTO_AGENT_COUNT,
-    standard_ceiling: schema.MAX_AGENT_COUNT,
-    default_clamp: defaultSlots,
-    naruto_slots_at_100: narutoSlots,
-    proof_clones: proofClones,
-    proof_concurrency: proofConcurrency,
-    target_active_slots: parsed.target_active_slots,
-    fake_safe_cap: fakeSafe.cap,
-    heavy_safe_cap: heavySafe.cap,
-    low_free_capable_cap: lowFreeButCapable.cap,
-    cores: heavySafe.cores,
-    completed_count: state.completed_count,
-    mission_id: parsed.mission_id,
-    isolated_worktree_root: isolatedWorktreeRoot
-});
-function parseJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-}
-function tail(value, limit = 2000) {
-    const text = String(value || '');
-    return text.length <= limit ? text : text.slice(-limit);
-}
-//# sourceMappingURL=naruto-shadow-clone-swarm-check.js.map

package/dist/scripts/naruto-verification-pool-check.js

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const workGraph = await importDist('core/naruto/naruto-work-graph.js');
-const governorMod = await importDist('core/naruto/naruto-concurrency-governor.js');
-const verificationDag = await importDist('core/naruto/naruto-verification-dag.js');
-const verificationPool = await importDist('core/naruto/naruto-verification-pool.js');
-const graph = workGraph.buildNarutoWorkGraph({ requestedClones: 8, totalWorkItems: 12, writeCapable: true });
-const governor = governorMod.decideNarutoConcurrency({
-    requestedClones: 8,
-    totalWorkItems: 12,
-    backend: 'fake',
-    hardware: {
-        cores: 4,
-        loadAverage: [0, 0, 0],
-        remoteApiRateLimitBudget: 8,
-        fileDescriptorLimit: 4096,
-        processCount: 1,
-        zellijPaneCount: 0,
-        diskIoPressure: 0,
-        freeMemoryBytes: 8 * 1024 * 1024 * 1024,
-        totalMemoryBytes: 16 * 1024 * 1024 * 1024
-    }
-});
-const dag = verificationDag.buildNarutoVerificationDag(graph, { cwd: root, command: 'node -e "process.exit(0)"' });
-const report = await verificationPool.runNarutoVerificationPool(dag, { ...governor, verification_parallel: 4 }, { cwd: root });
-assertGate(report.ok === true, 'verification pool must pass all fixture shards', report);
-assertGate(report.safe_concurrency === 4, 'verification pool must use its own safe concurrency', report);
-assertGate(report.task_count > 1, 'verification pool must run multiple shards', report);
-assertGate(report.cpu_heavy_cap_respected && report.io_heavy_cap_respected && report.api_rate_cap_respected, 'verification pool must respect resource caps', report);
-emitGate('naruto:verification-pool', {
-    task_count: report.task_count,
-    safe_concurrency: report.safe_concurrency,
-    passed: report.passed
-});
-//# sourceMappingURL=naruto-verification-pool-check.js.map

package/dist/scripts/naruto-work-graph-check.js

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const workGraph = await importDist('core/naruto/naruto-work-graph.js');
-const graph = workGraph.buildNarutoWorkGraph({
-    requestedClones: 24,
-    totalWorkItems: 30,
-    writeCapable: true,
-    targetPaths: Array.from({ length: 30 }, (_, index) => `src/fixture-${index}.ts`),
-    maxActiveWorkers: 8
-});
-const validation = workGraph.validateNarutoWorkGraph(graph);
-assertGate(graph.ok === true && validation.ok === true, 'Naruto work graph must validate', { graph_blockers: graph.blockers, validation });
-assertGate(graph.total_work_items >= graph.requested_clones * 2, 'write-capable work graph must create at least 2x requested clone count', { total: graph.total_work_items, requested: graph.requested_clones });
-assertGate(graph.mixed_work_kinds.length > 4, 'work graph must contain mixed work kinds, not only verification', { kinds: graph.mixed_work_kinds });
-assertGate(graph.write_allowed_count > 0, 'write-capable Naruto graph must include write_allowed work items', { write_allowed_count: graph.write_allowed_count });
-assertGate(graph.active_waves.every((wave) => wave.conflict_count === 0), 'active waves must not overlap write leases', { waves: graph.active_waves });
-emitGate('naruto:work-graph', {
-    total_work_items: graph.total_work_items,
-    mixed_work_kinds: graph.mixed_work_kinds,
-    write_allowed_count: graph.write_allowed_count,
-    wave_count: graph.active_waves.length
-});
-//# sourceMappingURL=naruto-work-graph-check.js.map

package/dist/scripts/naruto-worktree-coding-blackbox.js

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { makeGitFixture, run } from './lib/git-worktree-fixture.js';
-const managerMod = await importDist('core/git/git-worktree-manager.js');
-const diffMod = await importDist('core/git/git-worktree-diff.js');
-const mergeMod = await importDist('core/git/git-worktree-merge-queue.js');
-const repo = makeGitFixture('naruto-worktree-blackbox');
-process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-blackbox-'));
-const allocations = [];
-for (const file of ['a.txt', 'b.txt']) {
-    const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-naruto-blackbox', workerId: file.replace('.txt', ''), slotId: file.replace('.txt', '') });
-    fs.writeFileSync(path.join(allocation.worktree_path, file), `${file}\nworker-change\n`);
-    allocations.push(allocation);
-}
-assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main worktree must remain unchanged before integration');
-const diffs = [];
-for (const allocation of allocations) {
-    diffs.push(await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: allocation.worktree_path, missionId: 'M-naruto-blackbox', workerId: allocation.worker_id }));
-}
-const integration = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-naruto-blackbox', workerId: 'integration', slotId: 'integration' });
-const report = await mergeMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: integration.worktree_path, diffs });
-assertGate(report.ok === true && report.applied_count === 2, 'integration worktree merge report must apply worker diffs', report);
-assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main worktree must remain unchanged after integration queue');
-emitGate('naruto:worktree-coding:blackbox', { allocations: allocations.length, applied_count: report.applied_count });
-//# sourceMappingURL=naruto-worktree-coding-blackbox.js.map

package/dist/scripts/naruto-worktree-coding-check.js

@@ -1,44 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { makeGitFixture, makeNonGitFixture } from './lib/git-worktree-fixture.js';
-const capabilityMod = await importDist('core/git/git-worktree-capability.js');
-const workGraphMod = await importDist('core/naruto/naruto-work-graph.js');
-const activePoolMod = await importDist('core/naruto/naruto-active-pool.js');
-const governorMod = await importDist('core/naruto/naruto-concurrency-governor.js');
-const repo = makeGitFixture('naruto-worktree-coding');
-process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-wt-'));
-const capability = await capabilityMod.evaluateGitWorktreeCapability({ root: repo, missionId: 'M-naruto-wt', requireGitWorktree: process.argv.includes('--require-real') });
-const policy = {
-    mode: capability.mode,
-    required: capability.mode === 'git-worktree',
-    main_repo_root: capability.detection.root,
-    worktree_root: capability.root_resolution?.root || null,
-    fallback_reason: capability.mode === 'git-worktree' ? null : capability.blockers.join(';')
-};
-const graph = workGraphMod.buildNarutoWorkGraph({
-    requestedClones: 8,
-    totalWorkItems: 12,
-    writeCapable: true,
-    targetPaths: Array.from({ length: 12 }, (_, index) => `src/wt-${index}.ts`),
-    maxActiveWorkers: 4,
-    worktreePolicy: policy
-});
-const governor = governorMod.decideNarutoConcurrency({ requestedClones: 8, totalWorkItems: 12, pendingWorkQueueSize: 12, backend: 'fake' });
-const pool = await activePoolMod.runNarutoActivePool({ graph, governor: { ...governor, safe_active_workers: 4 } });
-assertGate(capability.ok === true && capability.mode === 'git-worktree', 'Git Naruto coding fixture must use git-worktree mode', capability);
-assertGate(graph.worktree_policy.mode === 'git-worktree', 'Naruto work graph must carry git-worktree policy', graph.worktree_policy);
-assertGate(graph.work_items.filter((item) => item.write_allowed).every((item) => item.worktree?.allocation_required === true), 'write-capable work items must require worktree allocation', graph.work_items);
-assertGate(pool.worktree_allocation_required_count > 0, 'active pool must plan worktree allocations for write work', pool);
-const nonGit = makeNonGitFixture('naruto-worktree-non-git');
-const nonGitCapability = await capabilityMod.evaluateGitWorktreeCapability({ root: nonGit, missionId: 'M-naruto-non-git' });
-assertGate(nonGitCapability.mode === 'patch-envelope-only' && nonGitCapability.worktree_probe_attempted === false, 'non-Git Naruto must degrade without worktree probe', nonGitCapability);
-emitGate('naruto:worktree-coding', {
-    worktree_mode: graph.worktree_policy.mode,
-    allocation_required_count: pool.worktree_allocation_required_count,
-    non_git_mode: nonGitCapability.mode
-});
-//# sourceMappingURL=naruto-worktree-coding-check.js.map