sneakoscope 2.0.14 → 2.0.16

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

package/dist/scripts/naruto-worktree-gpt-final-check.js

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const workGraphMod = await importDist('core/naruto/naruto-work-graph.js');
-const rolesMod = await importDist('core/naruto/naruto-role-policy.js');
-const packMod = await importDist('core/naruto/naruto-gpt-final-pack.js');
-const policy = {
-    mode: 'git-worktree',
-    required: true,
-    main_repo_root: '/repo',
-    worktree_root: '/cache/sks/worktrees/repo/M-final',
-    fallback_reason: null
-};
-const graph = workGraphMod.buildNarutoWorkGraph({ requestedClones: 6, totalWorkItems: 8, writeCapable: true, worktreePolicy: policy });
-const roleDistribution = rolesMod.buildNarutoRoleDistribution(graph.work_items);
-const worktreeDiff = {
-    schema: 'sks.git-worktree-diff.v1',
-    ok: true,
-    mission_id: 'M-final',
-    worker_id: 'worker-1',
-    main_repo_root: '/repo',
-    worktree_path: '/cache/wt/worker-1',
-    branch: 'sks/M/worker-1',
-    changed_files: ['src/a.ts'],
-    diff: 'diff --git a/src/a.ts b/src/a.ts\n',
-    diff_bytes: 37
-};
-const pack = packMod.buildNarutoGptFinalPack({
-    missionId: 'M-final',
-    graph,
-    roleDistribution,
-    changedFiles: ['src/a.ts'],
-    worktreePolicy: policy,
-    worktreeDiffs: [worktreeDiff],
-    localLlmMetrics: { participated: true, final_status: 'draft_until_gpt_final' }
-});
-assertGate(pack.worktree_policy.mode === 'git-worktree', 'GPT final pack must include worktree policy', pack.worktree_policy);
-assertGate(pack.worktree_diffs.length === 1, 'GPT final pack must include bounded worktree diffs', pack);
-assertGate(pack.local_llm_metrics.final_status === 'draft_until_gpt_final', 'local LLM output must remain draft until GPT final', pack.local_llm_metrics);
-assertGate(pack.bounded === true && pack.secrets_redacted === true, 'GPT final pack must stay bounded/redacted', pack);
-emitGate('naruto:worktree-gpt-final', {
-    worktree_mode: pack.worktree_policy.mode,
-    worktree_diffs: pack.worktree_diffs.length
-});
-//# sourceMappingURL=naruto-worktree-gpt-final-check.js.map

package/dist/scripts/naruto-worktree-zellij-ui-check.js

@@ -1,28 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const dashboardMod = await importDist('core/zellij/zellij-naruto-dashboard.js');
-const plan = dashboardMod.planNarutoZellijDashboard({
-    targetActiveWorkers: 10,
-    visiblePaneCap: 6,
-    roles: ['implementer', 'verifier'],
-    backend: 'codex-sdk',
-    worktreePolicy: {
-        mode: 'git-worktree',
-        required: true,
-        main_repo_root: '/repo',
-        worktree_root: '/cache/sks/worktrees/repo/M',
-        fallback_reason: null
-    }
-});
-assertGate(plan.ok === true, 'Naruto worktree Zellij dashboard must pass', plan);
-assertGate(plan.worktree_mode === 'git-worktree', 'dashboard must carry worktree mode', plan);
-assertGate(plan.worktree_labels.length === plan.visible_worker_panes, 'visible panes must have worktree labels', plan);
-assertGate(plan.pane_titles.every((title) => title.includes('WT:') && title.includes('branch:')), 'pane titles must include worktree id and branch', plan.pane_titles);
-assertGate(plan.headless_workers === 4, 'dashboard must still expose headless worker count', plan);
-emitGate('naruto:worktree-zellij-ui', {
-    visible_worker_panes: plan.visible_worker_panes,
-    headless_workers: plan.headless_workers,
-    sample_title: plan.pane_titles[0]
-});
-//# sourceMappingURL=naruto-worktree-zellij-ui-check.js.map

package/dist/scripts/naruto-zellij-dynamic-right-column-check.js

@@ -1,48 +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, root } from './sks-1-18-gate-lib.js';
-const requireReal = process.argv.includes('--require-real') || process.env.SKS_REQUIRE_ZELLIJ === '1';
-const naruto = fs.readFileSync(path.join(root, 'src/core/commands/naruto-command.ts'), 'utf8');
-const worker = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-worker-pane-manager.ts'), 'utf8');
-const swarm = fs.readFileSync(path.join(root, 'src/core/agents/native-cli-session-swarm.ts'), 'utf8');
-const realGeometryProof = requireReal ? runRealGeometryProof() : null;
-const report = {
-    schema: 'sks.naruto-zellij-dynamic-right-column-check.v1',
-    ok: true,
-    require_real: requireReal,
-    initial_main_only: /slotCount:\s*0/.test(naruto),
-    passes_session_name: naruto.includes('zellijSessionName: liveZellij?.session_name'),
-    passes_worker_placement: naruto.includes("workerPlacement: parsed.json || parsed.noOpenZellij ? 'process' : 'zellij-pane'"),
-    passes_visible_cap: naruto.includes('zellijVisiblePaneCap: zellijVisiblePanes'),
-    worker_uses_right_column: worker.includes("rightColumnMode: 'spawn-on-first-worker'") || swarm.includes("rightColumnMode: 'spawn-on-first-worker'"),
-    real_geometry_proof: realGeometryProof
-};
-report.ok = report.initial_main_only
-    && report.passes_session_name
-    && report.passes_worker_placement
-    && report.passes_visible_cap
-    && report.worker_uses_right_column
-    && (!requireReal || realGeometryProof?.ok === true);
-assertGate(report.ok, 'Naruto must use dynamic right-column worker panes in interactive mode', report);
-emitGate('naruto:zellij-dynamic-right-column', report);
-function runRealGeometryProof() {
-    const res = spawnSync('npm', ['run', 'zellij:right-column-real-geometry', '--silent', '--', '--require-real'], {
-        cwd: root,
-        env: { ...process.env, SKS_REQUIRE_ZELLIJ: '1' },
-        encoding: 'utf8',
-        maxBuffer: 20 * 1024 * 1024
-    });
-    return {
-        ok: res.status === 0,
-        exit_code: res.status,
-        stdout_tail: tail(res.stdout),
-        stderr_tail: tail(res.stderr)
-    };
-}
-function tail(text) {
-    return String(text || '').split('\n').slice(-30).join('\n');
-}
-//# sourceMappingURL=naruto-zellij-dynamic-right-column-check.js.map

package/dist/scripts/naruto-zellij-massive-ui-check.js

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const dashboardMod = await importDist('core/zellij/zellij-naruto-dashboard.js');
-const plan = dashboardMod.planNarutoZellijDashboard({
-    targetActiveWorkers: 32,
-    visiblePaneCap: 12,
-    completed: 8,
-    failed: 1,
-    backpressure: 'normal',
-    roles: ['implementer', 'modifier', 'test_writer', 'verifier'],
-    backend: 'codex-sdk'
-});
-assertGate(plan.ok === true, 'Naruto Zellij dashboard plan must pass', plan);
-assertGate(plan.visible_worker_panes === 12, 'targetActiveWorkers=32 and visiblePaneCap=12 must create 12 visible panes', plan);
-assertGate(plan.headless_workers === 20, 'remaining active workers must be listed as headless', plan);
-assertGate(plan.pane_titles.every((title) => /slot-\d+\/gen-1 · .+ · codex-sdk · active/.test(title)), 'pane titles must include slot/gen/role/backend/status', plan);
-emitGate('naruto:zellij-massive-ui', {
-    visible_worker_panes: plan.visible_worker_panes,
-    headless_workers: plan.headless_workers,
-    dashboard: plan.dashboard
-});
-//# sourceMappingURL=naruto-zellij-massive-ui-check.js.map

package/dist/scripts/non-recursive-pipeline-check.js

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { nonRecursivePipelineMarkdown, scanNonRecursivePipelinePolicy } from '../core/agents/agent-recursion-guard.js';
-const scriptDir = path.dirname(fileURLToPath(import.meta.url));
-const defaultRoot = path.resolve(scriptDir, '..');
-const args = process.argv.slice(2);
-const root = path.resolve(readFlag('--root') || defaultRoot);
-const json = args.includes('--json');
-const noWrite = args.includes('--no-write');
-const outputDir = path.join(root, '.sneakoscope', 'reports');
-const report = scanNonRecursivePipelinePolicy(collectScanRecords(root));
-if (!noWrite) {
-    fs.mkdirSync(outputDir, { recursive: true });
-    fs.writeFileSync(path.join(outputDir, 'non-recursive-pipeline-report.json'), `${JSON.stringify(report, null, 2)}\n`);
-    fs.writeFileSync(path.join(outputDir, 'non-recursive-pipeline-report.md'), nonRecursivePipelineMarkdown(report));
-}
-if (json)
-    console.log(JSON.stringify(report, null, 2));
-else
-    console.log(`non-recursive-pipeline: ${report.ok ? 'pass' : 'blocked'} (${report.violations.length} violation(s), ${report.scanned_records.length} record(s), ${report.elapsed_ms}ms)`);
-if (!report.ok || !report.performance_ok || !report.secret_redaction_ok)
-    process.exitCode = 1;
-function readFlag(name) {
-    const idx = args.indexOf(name);
-    return idx >= 0 ? args[idx + 1] : null;
-}
-function collectScanRecords(scanRoot) {
-    const candidates = [
-        ['src/core/agents/agent-worker-pipeline.ts', 'source'],
-        ['src/core/agents/agent-recursion-guard.ts', 'source'],
-        ['src/core/agents/agent-runner-process.ts', 'source'],
-        ['src/core/agents/agent-runner-codex-exec.ts', 'source'],
-        ['docs/agent-non-recursive-pipeline.md', 'docs'],
-        ['docs/native-agent-kernel.md', 'docs']
-    ];
-    const records = [];
-    for (const [rel, channel] of candidates) {
-        const full = path.join(scanRoot, rel);
-        if (!fs.existsSync(full) || !fs.statSync(full).isFile())
-            continue;
-        records.push({ path: rel, channel, text: fs.readFileSync(full, 'utf8') });
-    }
-    records.push({
-        path: '.sneakoscope/reports/agent-worker.stdout.fixture.txt',
-        channel: 'stdout',
-        text: 'agent worker completed local slice; no nested route requested'
-    });
-    records.push({
-        path: '.sneakoscope/reports/agent-worker.stderr.fixture.txt',
-        channel: 'stderr',
-        text: 'agent worker stderr clean; no recursive SKS command emitted'
-    });
-    records.push({
-        path: '.sneakoscope/reports/agent-result.fixture.json',
-        channel: 'agent_result',
-        text: JSON.stringify({
-            schema: 'sks.agent-result.v1',
-            status: 'done',
-            recursion_guard: { ok: true, violations: [] },
-            blockers: []
-        })
-    });
-    return records;
-}
-//# sourceMappingURL=non-recursive-pipeline-check.js.map

package/dist/scripts/npm-publish-performance-check.js

@@ -1,65 +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, root } from './sks-1-18-gate-lib.js';
-const MAX_FILES = Number(process.env.SKS_MAX_PACK_FILES || 1200);
-const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || 1536 * 1024);
-const BUDGET_MS = Number(process.env.SKS_PACK_BUDGET_MS || 30000);
-function runNpmPack() {
-    const npmCli = process.env.npm_execpath; // set when invoked via `npm run`
-    const argv = ['pack', '--dry-run', '--json', '--ignore-scripts'];
-    const res = npmCli
-        ? spawnSync(process.execPath, [npmCli, ...argv], { cwd: root, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 })
-        : spawnSync('npm', argv, { cwd: root, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
-    return res;
-}
-function writeReport(report) {
-    const out = path.join(root, '.sneakoscope', 'reports', 'npm-publish-performance.json');
-    fs.mkdirSync(path.dirname(out), { recursive: true });
-    fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-}
-const t0 = Date.now();
-const res = runNpmPack();
-const packMs = Date.now() - t0;
-let info;
-if (res.status === 0) {
-    try {
-        const parsed = JSON.parse(res.stdout);
-        info = Array.isArray(parsed) ? parsed[0] : parsed;
-    }
-    catch {
-        info = undefined;
-    }
-}
-if (!info) {
-    // Real-check gate: never fail when npm is unreachable / pack unavailable.
-    const report = { ok: true, integration_optional: true, reason: 'npm_pack_unavailable' };
-    writeReport(report);
-    emitGate('publish:dry-run-performance', { integration_optional: true });
-    process.exit(0);
-}
-const report = {
-    schema: 'sks.npm-publish-performance.v1',
-    ok: info.entryCount <= MAX_FILES && info.size <= MAX_PACKED,
-    pack_ms: packMs,
-    slowest_phase: 'pack',
-    file_count: info.entryCount,
-    packed_bytes: info.size,
-    unpacked_bytes: info.unpackedSize,
-    over_budget: packMs > BUDGET_MS,
-    warnings: packMs > BUDGET_MS ? ['pack_slower_than_budget'] : [],
-    blockers: [
-        ...(info.entryCount > MAX_FILES ? ['pack_file_count_over_limit'] : []),
-        ...(info.size > MAX_PACKED ? ['pack_size_over_limit'] : [])
-    ]
-};
-writeReport(report);
-if (report.blockers.length) {
-    assertGate(false, 'npm_publish_performance_blockers', { blockers: report.blockers, report });
-}
-// A slow pack is a WARNING only, not a blocker.
-console.log(JSON.stringify(report, null, 2));
-process.exit(0);
-//# sourceMappingURL=npm-publish-performance-check.js.map