sneakoscope 2.0.13 → 2.0.15

package/dist/scripts/memory-summary-rebuild-check.js

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import assert from 'node:assert/strict';
-import fs from 'node:fs/promises';
-import { spawnSync } from 'node:child_process';
-import path from 'node:path';
-const root = process.cwd();
-const wiki = spawnSync(process.execPath, [path.join(root, 'dist/bin/sks.js'), 'wiki', 'rebuild-summary', '--json'], {
-    cwd: root,
-    encoding: 'utf8',
-    env: { ...process.env, SKS_SKIP_NPM_FRESHNESS_CHECK: '1', CI: 'true' },
-    timeout: 60_000
-});
-assert.equal(wiki.status, 0, wiki.stderr || wiki.stdout);
-const summary = JSON.parse(wiki.stdout);
-assert.equal(summary.schema, 'sks.memory-summary.v2');
-assert.equal(summary.summaries.triwiki.schema_version, 2);
-assert.equal(summary.summaries.wrongness.schema_version, 2);
-await fs.rm(path.join(root, '.sneakoscope/wiki/memory-summary.json'), { force: true });
-await fs.rm(path.join(root, '.sneakoscope/wiki/memory-summary.md'), { force: true });
-console.log(JSON.stringify({ schema: 'sks.memory-summary-rebuild-check.v1', ok: true, summary: summary.summaries }, null, 2));
-//# sourceMappingURL=memory-summary-rebuild-check.js.map

package/dist/scripts/mutation-callsite-coverage-check.js

@@ -1,180 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-// Repo-wide risky mutation callsite gate. Every raw mutation must be either a
-// guarded call or an external allowlist entry with a concrete function/symbol and
-// reason. The allowlist is intentionally data, not code, so unused/stale entries
-// fail the release gate.
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const allowlistPath = path.join(root, 'safety-mutation-allowlist.json');
-const allowlist = readAllowlist();
-const allowlistHits = new Set();
-const scanFiles = listScanFiles();
-const covered = [];
-const allowlisted = [];
-const uncovered = [];
-const GUARD_CALL = /\bguarded(WriteFile|Rm|Rename|Chmod|Xattr|Chflags|GlobalCodexConfigWrite|ProcessKill|PackageInstall|SkillSnapshotPromotion|Apply)\(/;
-const RISKY = [
-    { kind: 'write_file', token: 'fs.writeFile', re: /\bfs\.writeFile\(/ },
-    { kind: 'write_file', token: 'fs.promises.writeFile', re: /\bfs\.promises\.writeFile\(/ },
-    { kind: 'write_file', token: 'fsp.writeFile', re: /\bfsp\.writeFile\(/ },
-    { kind: 'write_file', token: 'writeFileSync', re: /\b(?:fs\.)?writeFileSync\(/ },
-    { kind: 'rm', token: 'fs.rm', re: /\bfs\.rm\(/ },
-    { kind: 'rm', token: 'fsp.rm', re: /\bfsp\.rm\(/ },
-    { kind: 'rm', token: 'rmSync', re: /\b(?:fs\.)?rmSync\(/ },
-    { kind: 'unlink', token: 'unlink', re: /\b(?:fs\.|fsp\.)?unlink\(/ },
-    { kind: 'unlink', token: 'unlinkSync', re: /\b(?:fs\.)?unlinkSync\(/ },
-    { kind: 'rename', token: 'rename', re: /\b(?:fs\.|fsp\.)?rename\(/ },
-    { kind: 'rename', token: 'renameSync', re: /\b(?:fs\.)?renameSync\(/ },
-    { kind: 'chmod', token: 'chmod', re: /\b(?:fs\.|fsp\.)?chmod\(/ },
-    { kind: 'chmod', token: 'chmodSync', re: /\b(?:fs\.)?chmodSync\(/ },
-    { kind: 'process_kill', token: 'process.kill', re: /\bprocess\.kill\(/ },
-    { kind: 'package_install', token: 'runProcess(npm/brew)', re: /runProcess\(\s*(?:npmBin|['"](?:npm|brew)['"])/ },
-    { kind: 'package_install', token: 'spawn(npm install)', re: /\bspawn(?:Sync)?\(\s*['"]npm['"][\s\S]{0,80}(?:install|i)\b/ },
-    { kind: 'xattr', token: 'xattr', re: /runProcess\(\s*['"]xattr['"]/ },
-    { kind: 'chflags', token: 'chflags', re: /runProcess\(\s*['"]chflags['"]/ },
-    { kind: 'codex_home_write', token: 'codex config write', re: /(?:~\/\.codex|CODEX_HOME|auth\.json|config\.toml)/ }
-];
-for (const rel of scanFiles) {
-    const text = fs.readFileSync(path.join(root, rel), 'utf8');
-    const lines = text.split('\n');
-    let currentSymbol = 'module';
-    for (let i = 0; i < lines.length; i += 1) {
-        const line = lines[i];
-        currentSymbol = symbolFromLine(line) || currentSymbol;
-        if (isIgnoredLine(line))
-            continue;
-        if (GUARD_CALL.test(line)) {
-            covered.push({ file: rel, line: i + 1, symbol: currentSymbol, kind: 'guarded_call', snippet: snippet(line) });
-        }
-        for (const risky of RISKY) {
-            if (!risky.re.test(line))
-                continue;
-            if (risky.kind === 'package_install' && !packageMutationOnLine(line))
-                continue;
-            if (risky.kind === 'codex_home_write' && !codexHomeMutationOnLine(line))
-                continue;
-            if (risky.kind === 'process_kill' && processKillIsLivenessProbe(line))
-                continue;
-            const entry = { file: rel, line: i + 1, symbol: currentSymbol, kind: risky.kind, token: risky.token, snippet: snippet(line) };
-            const allow = findAllow(entry);
-            if (allow) {
-                allowlistHits.add(allow.id);
-                allowlisted.push({ ...entry, reason: allow.reason });
-            }
-            else {
-                uncovered.push(entry);
-            }
-        }
-    }
-}
-const unused_allowlist = allowlist.filter((entry) => !allowlistHits.has(entry.id)).map(({ id, file, symbol, token, reason }) => ({ id, file, symbol, token, reason }));
-const blanket_allowlist = allowlist.filter((entry) => !entry.symbol || entry.symbol === '*' || !entry.token || entry.token === '*');
-const ok = uncovered.length === 0 && unused_allowlist.length === 0 && blanket_allowlist.length === 0;
-const report = {
-    schema: 'sks.mutation-callsite-coverage.v2',
-    ok,
-    repo_wide: true,
-    allowlist_path: 'safety-mutation-allowlist.json',
-    scanned_file_count: scanFiles.length,
-    covered,
-    allowlisted,
-    uncovered,
-    unused_allowlist,
-    blanket_allowlist
-};
-const reportDir = path.join(root, '.sneakoscope', 'reports');
-fs.mkdirSync(reportDir, { recursive: true });
-fs.writeFileSync(path.join(reportDir, 'mutation-callsite-coverage.json'), `${JSON.stringify(report, null, 2)}\n`);
-assertGate(ok, 'repo-wide risky mutation call sites must be guarded or allowlisted-with-reason', {
-    scanned_file_count: scanFiles.length,
-    uncovered,
-    unused_allowlist,
-    blanket_allowlist
-});
-emitGate('safety:mutation-callsite-coverage', {
-    scanned_file_count: scanFiles.length,
-    covered: covered.length,
-    allowlisted: allowlisted.length,
-    uncovered: uncovered.length
-});
-function readAllowlist() {
-    const raw = JSON.parse(fs.readFileSync(allowlistPath, 'utf8'));
-    assertGate(raw.schema === 'sks.safety-mutation-allowlist.v1', 'mutation allowlist schema mismatch', raw);
-    assertGate(Array.isArray(raw.entries), 'mutation allowlist entries must be an array', raw);
-    return raw.entries.map((entry, index) => {
-        for (const key of ['file', 'symbol', 'token', 'reason']) {
-            assertGate(typeof entry[key] === 'string' && entry[key].trim().length > 0, `allowlist entry missing ${key}`, { index, entry });
-        }
-        assertGate(entry.reason.length >= 12, 'allowlist reason must be concrete', { index, entry });
-        return { ...entry, id: `${entry.file}:${entry.symbol}:${entry.token}:${index}` };
-    });
-}
-function listScanFiles() {
-    const files = [];
-    walk(path.join(root, 'src'), (file) => {
-        const relative = rel(file);
-        if (relative.startsWith('src/scripts/'))
-            return;
-        if (file.endsWith('.ts'))
-            files.push(relative);
-    });
-    walk(path.join(root, 'src', 'scripts'), (file) => {
-        if (!file.endsWith('.ts'))
-            return;
-        const base = path.basename(file);
-        if (/(install|publish|release|doctor|codex|zellij|migration)/i.test(base))
-            files.push(rel(file));
-    });
-    return files.sort();
-}
-function walk(dir, visit) {
-    let entries = [];
-    try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        const file = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            if (!['node_modules', 'dist', 'target'].includes(entry.name))
-                walk(file, visit);
-        }
-        else if (entry.isFile()) {
-            visit(file);
-        }
-    }
-}
-function findAllow(entry) {
-    return allowlist.find((allow) => entry.file === allow.file && entry.symbol === allow.symbol && entry.token === allow.token);
-}
-function symbolFromLine(line) {
-    const match = line.match(/(?:export\s+)?(?:async\s+)?function\s+([A-Za-z0-9_$]+)/)
-        || line.match(/(?:const|let|var)\s+([A-Za-z0-9_$]+)\s*=\s*(?:async\s*)?\(/)
-        || line.match(/class\s+([A-Za-z0-9_$]+)/);
-    return match?.[1] || null;
-}
-function isIgnoredLine(line) {
-    const trimmed = line.trim();
-    return !trimmed || trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*');
-}
-function packageMutationOnLine(line) {
-    return /\b(?:install|i|add|uninstall|remove|publish)\b/.test(line);
-}
-function processKillIsLivenessProbe(line) {
-    return /\bprocess\.kill\([^,\n]+,\s*0\s*\)/.test(line);
-}
-function codexHomeMutationOnLine(line) {
-    return /\b(?:writeTextAtomic|writeJsonAtomic|writeFileSync|fs\.writeFile|fs\.promises\.writeFile|fsp\.writeFile|fs\.rm|fsp\.rm|fs\.rename|fsp\.rename|fs\.chmod|fsp\.chmod|copyFile|open)\b/.test(line)
-        && /(?:~\/\.codex|CODEX_HOME|codexHome|codexLbHome|auth\.json|config\.toml)/.test(line);
-}
-function snippet(line) {
-    return line.trim().slice(0, 160);
-}
-function rel(file) {
-    return path.relative(root, file).split(path.sep).join('/');
-}
-//# sourceMappingURL=mutation-callsite-coverage-check.js.map

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

@@ -1,39 +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 governorMod = await importDist('core/naruto/naruto-concurrency-governor.js');
-const activePool = await importDist('core/naruto/naruto-active-pool.js');
-const graph = workGraph.buildNarutoWorkGraph({ requestedClones: 20, totalWorkItems: 20, writeCapable: true, maxActiveWorkers: 5 });
-const governor = governorMod.decideNarutoConcurrency({
-    requestedClones: 20,
-    totalWorkItems: 20,
-    pendingWorkQueueSize: 20,
-    backend: 'fake',
-    hardware: { remoteApiRateLimitBudget: 5, fileDescriptorLimit: 4096, freeMemoryBytes: 8 * 1024 * 1024 * 1024, totalMemoryBytes: 16 * 1024 * 1024 * 1024 }
-});
-const report = activePool.simulateNarutoActivePool({ graph, governor: { ...governor, safe_active_workers: 5 } });
-assertGate(report.ok === true, 'active pool must drain cleanly', report);
-assertGate(report.max_observed_active_workers <= 5, 'active pool must never exceed safe cap', report);
-assertGate(report.max_observed_write_lease_conflicts === 0, 'active pool must never run overlapping write leases concurrently', report);
-assertGate(report.completed_count >= graph.total_work_items, 'active pool must complete all base work items', report);
-assertGate(report.refill_events >= 5, 'active pool must refill slots as work drains', report);
-assertGate(report.duplicate_execution_count === 0, 'active pool must not duplicate work without retry', report);
-const sameLeaseGraph = workGraph.buildNarutoWorkGraph({
-    requestedClones: 10,
-    totalWorkItems: 10,
-    writeCapable: true,
-    targetPaths: ['src/shared-fixture.ts'],
-    maxActiveWorkers: 5
-});
-const sameLeaseReport = activePool.simulateNarutoActivePool({ graph: sameLeaseGraph, governor: { ...governor, safe_active_workers: 5 } });
-assertGate(sameLeaseReport.ok === true, 'same-file work graph must drain without overlapping write leases', sameLeaseReport);
-assertGate(sameLeaseReport.max_observed_write_lease_conflicts === 0, 'same-file write items must be serialized or interleaved with read-only work only', sameLeaseReport);
-emitGate('naruto:active-pool', {
-    safe_active_workers: report.safe_active_workers,
-    completed_count: report.completed_count,
-    refill_events: report.refill_events,
-    max_observed_active_workers: report.max_observed_active_workers,
-    same_lease_max_write_conflicts: sameLeaseReport.max_observed_write_lease_conflicts
-});
-//# sourceMappingURL=naruto-active-pool-check.js.map

package/dist/scripts/naruto-actual-worker-control-plane-check.js

@@ -1,56 +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 { collectActualNarutoWorker, spawnActualNarutoWorker } from '../core/naruto/naruto-real-worker-runtime.js';
-import { narutoCommand } from '../core/commands/naruto-command.js';
-process.env.SKS_CODEX_SDK_FAKE = '1';
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-actual-worker-'));
-const graph = buildNarutoWorkGraph({ requestedClones: 1, totalWorkItems: 1, readonly: true, writeCapable: false });
-const item = graph.work_items[0];
-const handle = await spawnActualNarutoWorker({
-    root,
-    missionId: `M-naruto-actual-worker-${process.pid}`,
-    item,
-    placement: { placement: 'headless', visible_index: null, reason: 'check' },
-    backend: 'fake',
-    visiblePaneCap: 0
-});
-const collected = await collectActualNarutoWorker(handle);
-const result = JSON.parse(fs.readFileSync(path.join(handle.worker_artifact_dir, 'worker-result.json'), 'utf8'));
-const fullRoute = await narutoCommand([
-    'run',
-    'Naruto actual worker full command control plane check',
-    '--json',
-    '--backend',
-    'fake',
-    '--backend-explicit',
-    '--clones',
-    '2',
-    '--work-items',
-    '2',
-    '--readonly',
-    '--no-open-zellij',
-    '--smoke'
-]);
-const missionRoot = path.join(process.cwd(), '.sneakoscope', 'missions', fullRoute.mission_id || '', 'agents', 'naruto-real-workers');
-const fullWorkerResults = fs.existsSync(missionRoot)
-    ? fs.readdirSync(missionRoot).map((name) => {
-        const file = path.join(missionRoot, name, 'worker-result.json');
-        return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')) : null;
-    }).filter(Boolean)
-    : [];
-const ok = collected.ok === true
-    && result.ok === true
-    && result.control_plane_result?.worker_result_path
-    && result.control_plane_result?.structured_output_valid === true
-    && fullRoute.active_pool?.real_runtime?.runtime_source_of_truth === 'pre_run_smoke_only'
-    && fullRoute.runtime_source_of_truth === 'agent-orchestrator-scheduler'
-    && fullWorkerResults.length >= 1
-    && fullWorkerResults.every((row) => row.control_plane_result?.structured_output_valid === true);
-assertGate(ok, 'Naruto actual worker must call Codex Control Plane directly and through the explicit full-route smoke path', { collected, result, fullRoute, fullWorkerResults });
-emitGate('naruto:actual-worker-control-plane', { collected, result, full_route_mission_id: fullRoute.mission_id, full_worker_result_count: fullWorkerResults.length });
-//# sourceMappingURL=naruto-actual-worker-control-plane-check.js.map

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

@@ -1,33 +0,0 @@
-#!/usr/bin/env node
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { allocateNarutoTasksToWorkers, chooseNarutoTaskOwner } from '../core/naruto/naruto-allocation-policy.js';
-const base = {
-    kind: 'implementation',
-    title: 'impl',
-    target_paths: ['src/core/naruto/runtime.ts'],
-    readonly_paths: [],
-    write_paths: ['src/core/naruto/runtime.ts'],
-    required_role: 'implementer',
-    write_allowed: true,
-    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: [{ path: 'src/core/naruto/runtime.ts', kind: 'write' }],
-    acceptance: { requires_patch_envelope: true, requires_verification: true, requires_gpt_final: true }
-};
-const workers = [
-    { id: 'w1', role: 'implementer', lane: 'src/core' },
-    { id: 'w2', role: 'verifier', lane: 'src/scripts' }
-];
-const decision = chooseNarutoTaskOwner({ ...base, id: 'T1' }, workers);
-const blocked = chooseNarutoTaskOwner({ ...base, id: 'T2', dependencies: ['T0'] }, workers);
-const assignments = allocateNarutoTasksToWorkers([{ ...base, id: 'T1' }, { ...base, id: 'T2', required_role: 'verifier' }], workers);
-const ok = decision.owner === 'w1'
-    && decision.score >= 24
-    && blocked.score === Number.NEGATIVE_INFINITY
-    && assignments.length === 2;
-assertGate(ok, 'Naruto allocation policy must score role/lane overlap and block incomplete dependencies with -Infinity', { decision, blocked, assignments });
-emitGate('naruto:allocation-policy', { decision, blocked, assignments });
-//# sourceMappingURL=naruto-allocation-policy-check.js.map

package/dist/scripts/naruto-allocation-runtime-wiring-check.js

@@ -1,92 +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 { runNativeAgentOrchestrator } from '../core/agents/agent-orchestrator.js';
-import { buildNarutoCloneRoster } from '../core/agents/agent-roster.js';
-import { buildNarutoWorkGraph } from '../core/naruto/naruto-work-graph.js';
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-runtime-wiring-'));
-const roster = buildNarutoCloneRoster({ clones: 3, readonly: true, prompt: 'runtime wiring check' });
-const graph = buildNarutoWorkGraph({
-    requestedClones: 3,
-    totalWorkItems: 3,
-    readonly: true,
-    writeCapable: false,
-    allocationAssignments: [
-        assignment('NW-000001', 'naruto_clone_001', 42),
-        assignment('NW-000002', 'naruto_clone_002', 41),
-        assignment('NW-000003', 'naruto_clone_999', 1)
-    ]
-});
-const result = await runNativeAgentOrchestrator({
-    root,
-    route: '$Naruto',
-    routeCommand: 'sks naruto run',
-    routeBlackboxKind: 'allocation_runtime_wiring_gate',
-    prompt: 'Naruto allocation runtime wiring check',
-    roster,
-    agents: 3,
-    concurrency: 2,
-    targetActiveSlots: 2,
-    desiredWorkItemCount: 3,
-    minimumWorkItems: 3,
-    backend: 'fake',
-    backendExplicit: true,
-    mock: true,
-    readonly: true,
-    nativeCliSwarm: false,
-    narutoMode: true,
-    narutoWorkGraph: graph,
-    narutoAllocationPolicy: { schema: 'sks.naruto-allocation-policy.v1', ok: true, assignments: graph.work_items.map((item) => ({ task_id: item.id, owner: item.owner })) },
-    narutoRebalancePolicy: { schema: 'sks.naruto-rebalance-policy.v1', ok: true, decisions: [] }
-});
-const ledgerRoot = path.join(root, result.ledger_root || '.');
-const wiring = JSON.parse(fs.readFileSync(path.join(ledgerRoot, 'naruto-runtime-wiring.json'), 'utf8'));
-const queue = JSON.parse(fs.readFileSync(path.join(ledgerRoot, 'agent-work-queue.json'), 'utf8'));
-const owners = queue.items.map((item) => item.slice?.owner_agent_id);
-const runtimeProofs = (result.results || []).map((row) => row.naruto_runtime).filter(Boolean);
-const schedulerOk = result.scheduler?.state?.completed_count === 3
-    && result.scheduler?.state?.failed_count === 0
-    && result.scheduler?.state?.blocked_count === 0
-    && result.scheduler?.state?.pending_queue_drained === true
-    && Array.isArray(result.scheduler?.state?.blockers)
-    && result.scheduler.state.blockers.length === 0;
-const ok = schedulerOk
-    && wiring.ok === true
-    && wiring.scheduler_slice_count === 3
-    && owners.includes('naruto_clone_001')
-    && owners.includes('naruto_clone_002')
-    && wiring.slice_owners.some((row) => row.original_owner === 'naruto_clone_999' && row.rebalanced === true)
-    && runtimeProofs.length === 3
-    && runtimeProofs.every((row) => row.source_of_truth === 'agent-orchestrator-scheduler');
-assertGate(ok, 'Naruto allocation must be wired into scheduler slices, queue ownership, and worker runtime proof', {
-    result_ok: result.ok,
-    result_proof_blockers: result.proof?.blockers || [],
-    scheduler: result.scheduler?.state || null,
-    wiring,
-    owners,
-    runtimeProofs
-});
-emitGate('naruto:allocation-runtime-wiring', {
-    wiring,
-    owners,
-    scheduler_ok: schedulerOk,
-    runtime_proof_count: runtimeProofs.length
-});
-function assignment(taskId, owner, score) {
-    return {
-        task_id: taskId,
-        owner,
-        allocation_reason: `fixture owner ${owner}`,
-        allocation_score: score,
-        hints: {
-            role: 'verifier',
-            paths: ['src/core/naruto/runtime.ts'],
-            domains: ['src/core/naruto'],
-            writePaths: []
-        }
-    };
-}
-//# sourceMappingURL=naruto-allocation-runtime-wiring-check.js.map

package/dist/scripts/naruto-concurrency-governor-check.js

@@ -1,53 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const governorMod = await importDist('core/naruto/naruto-concurrency-governor.js');
-const normal = governorMod.decideNarutoConcurrency({
-    requestedClones: 200,
-    totalWorkItems: 340,
-    pendingWorkQueueSize: 340,
-    backend: 'codex-sdk',
-    zellijVisiblePaneCap: 12,
-    hardware: {
-        cores: 32,
-        loadAverage: [0, 0, 0],
-        freeMemoryBytes: 48 * 1024 * 1024 * 1024,
-        totalMemoryBytes: 64 * 1024 * 1024 * 1024,
-        fileDescriptorLimit: 4096,
-        localLlmMaxParallelRequests: 4,
-        remoteApiRateLimitBudget: 32,
-        terminalRows: 40,
-        terminalColumns: 140
-    }
-});
-const pressure = governorMod.decideNarutoConcurrency({
-    requestedClones: 200,
-    totalWorkItems: 340,
-    pendingWorkQueueSize: 340,
-    backend: 'codex-sdk',
-    zellijVisiblePaneCap: 12,
-    hardware: {
-        cores: 8,
-        loadAverage: [16, 16, 16],
-        freeMemoryBytes: 256 * 1024 * 1024,
-        totalMemoryBytes: 4 * 1024 * 1024 * 1024,
-        fileDescriptorLimit: 128,
-        localLlmMaxParallelRequests: 4,
-        remoteApiRateLimitBudget: 32,
-        zellijPaneCount: 12,
-        diskIoPressure: 0.9
-    }
-});
-assertGate(normal.safe_active_workers >= 32 && normal.safe_active_workers <= 100, 'requested_clones=200 fixture must cap active workers safely while allowing aggressive process-pool fanout', { normal });
-assertGate(normal.safe_zellij_visible_panes === 12 && normal.headless_workers === normal.safe_active_workers - 12, 'zellij visible panes must stay within UI cap', { normal });
-assertGate(normal.local_llm_parallel <= 4, 'local LLM active requests must respect max_parallel_requests=4', { normal });
-assertGate(pressure.safe_active_workers < normal.safe_active_workers, 'memory/load pressure fixture must decrease active workers', { normal: normal.safe_active_workers, pressure: pressure.safe_active_workers });
-assertGate(pressure.backpressure === 'saturated' || pressure.backpressure === 'throttled', 'pressure fixture must report backpressure', { pressure });
-emitGate('naruto:concurrency-governor', {
-    requested_clones: normal.requested_clones,
-    total_work_items: normal.total_work_items,
-    safe_active_workers: normal.safe_active_workers,
-    safe_zellij_visible_panes: normal.safe_zellij_visible_panes,
-    pressure_safe_active_workers: pressure.safe_active_workers
-});
-//# sourceMappingURL=naruto-concurrency-governor-check.js.map

package/dist/scripts/naruto-extreme-parallelism-check.js

@@ -1,22 +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';
-const graph = buildNarutoWorkGraph({ requestedClones: 100, writeCapable: true, maxActiveWorkers: 32 });
-const governor = decideNarutoConcurrency({
-    requestedClones: 100,
-    totalWorkItems: graph.total_work_items,
-    pendingWorkQueueSize: graph.total_work_items,
-    backend: 'codex-sdk',
-    hardware: { cores: 16, loadAverage: [1, 1, 1], freeMemoryBytes: 64 * 1024 * 1024 * 1024, totalMemoryBytes: 128 * 1024 * 1024 * 1024, fileDescriptorLimit: 8192, processCount: 100, terminalRows: 48, remoteApiRateLimitBudget: 32, localLlmMaxParallelRequests: 8 }
-});
-const report = {
-    schema: 'sks.naruto-extreme-parallelism-check.v1',
-    ok: graph.total_work_items >= 200 && governor.safe_active_workers >= 16 && governor.safe_zellij_visible_panes <= governor.safe_active_workers && governor.safe_zellij_visible_panes <= 8 && graph.mixed_work_kinds.length >= 6,
-    graph: { total_work_items: graph.total_work_items, mixed_work_kinds: graph.mixed_work_kinds, write_allowed_count: graph.write_allowed_count },
-    governor
-};
-assertGate(report.ok, 'Naruto extreme parallelism must fan out >=2x clones and keep a high safe active pool', report);
-emitGate('naruto:extreme-parallelism', report);
-//# sourceMappingURL=naruto-extreme-parallelism-check.js.map

package/dist/scripts/naruto-extreme-parallelism-real-check.js

@@ -1,43 +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: 100, totalWorkItems: 48, writeCapable: true, maxActiveWorkers: 12 });
-const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-extreme-real-'));
-const missionId = `M-naruto-extreme-real-${process.pid}`;
-const governor = decideNarutoConcurrency({
-    requestedClones: 100,
-    totalWorkItems: graph.total_work_items,
-    pendingWorkQueueSize: graph.total_work_items,
-    backend: 'fake',
-    hardware: { cores: 16, loadAverage: [1, 1, 1], freeMemoryBytes: 64 * 1024 * 1024 * 1024, totalMemoryBytes: 128 * 1024 * 1024 * 1024, fileDescriptorLimit: 8192, processCount: 100, terminalRows: 48, remoteApiRateLimitBudget: 32, localLlmMaxParallelRequests: 8 }
-});
-const target = { ...governor, safe_active_workers: Math.min(12, governor.safe_active_workers), safe_zellij_visible_panes: Math.min(4, governor.safe_zellij_visible_panes) };
-const report = await runNarutoRealActivePool({
-    graph,
-    governor: target,
-    spawnWorker: async (item, placement) => spawnActualNarutoWorker({
-        root: tempRoot,
-        missionId,
-        item,
-        placement,
-        backend: 'fake',
-        visiblePaneCap: target.safe_zellij_visible_panes,
-        zellijSessionName: `sks-${missionId}`
-    }),
-    collectWorker: async (handle) => collectActualNarutoWorker(handle),
-    enqueueVerification: async () => undefined,
-    updateDashboard: async () => undefined
-});
-const actualArtifacts = report.worker_lifecycle.every((row) => row.pid && row.worker_artifact_dir && fs.existsSync(path.join(row.worker_artifact_dir, 'worker-result.json')));
-const ok = report.ok && report.max_observed_active_workers >= Math.ceil(target.safe_active_workers * 0.8) && report.active_pool_utilization >= 0.8 && report.headless_workers > 0 && report.visible_workers <= graph.total_work_items && actualArtifacts;
-assertGate(ok, 'Naruto extreme parallelism must use actual child process active-pool lifecycle near cap with headless overflow', { report, target, actualArtifacts, tempRoot });
-emitGate('naruto:extreme-parallelism-real', report);
-//# sourceMappingURL=naruto-extreme-parallelism-real-check.js.map

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

@@ -1,34 +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 packMod = await importDist('core/naruto/naruto-gpt-final-pack.js');
-const graph = workGraph.buildNarutoWorkGraph({ requestedClones: 100, totalWorkItems: 120, writeCapable: true });
-const roleDistribution = roles.buildNarutoRoleDistribution(graph.work_items);
-const patchEnvelopes = Array.from({ length: 120 }, (_, index) => ({ id: index, token: 'sk-testsecret1234567890', file: `f-${index}.ts` }));
-const logs = Array.from({ length: 40 }, (_, index) => `log ${index} api_key=secret-${index}`);
-const pack = packMod.buildNarutoGptFinalPack({
-    missionId: 'M-naruto-pack',
-    graph,
-    roleDistribution,
-    changedFiles: ['src/a.ts', 'src/a.ts', 'src/b.ts'],
-    patchEnvelopes,
-    verificationResults: [{ ok: true }],
-    failedShards: [{ id: 'failed-1' }],
-    conflictMap: [{ path: 'src/a.ts' }],
-    rollbackPlan: { token: 'sk-abc12345678901234567' },
-    logs
-});
-const serialized = JSON.stringify(pack);
-assertGate(pack.bounded === true && pack.secrets_redacted === true, 'GPT final pack must be bounded and redacted', pack);
-assertGate(pack.patch_envelopes.length === 100, '100 worker results must compress to bounded patch envelope count', { count: pack.patch_envelopes.length });
-assertGate(pack.representative_logs.length === 12, 'representative logs must be bounded', { count: pack.representative_logs.length });
-assertGate(!serialized.includes('secret-') && !serialized.includes('sk-testsecret'), 'secrets must be redacted from final pack', pack);
-assertGate(pack.role_distribution.ok === true && pack.work_graph_summary.write_allowed_count > 0, 'final pack must include role distribution and write work summary', pack);
-emitGate('naruto:gpt-final-pack', {
-    patch_envelopes: pack.patch_envelopes.length,
-    representative_logs: pack.representative_logs.length,
-    changed_files: pack.changed_files
-});
-//# sourceMappingURL=naruto-gpt-final-pack-check.js.map

package/dist/scripts/naruto-orchestrator-runtime-source-check.js

@@ -1,70 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { narutoCommand } from '../core/commands/naruto-command.js';
-const summary = await narutoCommand([
-    'run',
-    'Naruto orchestrator runtime source artifact check',
-    '--json',
-    '--backend',
-    'fake',
-    '--clones',
-    '2',
-    '--work-items',
-    '2',
-    '--readonly',
-    '--no-open-zellij'
-]);
-const ledgerRoot = path.join(process.cwd(), '.sneakoscope', 'missions', summary.mission_id || '', 'agents');
-const realPool = readJson(path.join(ledgerRoot, 'naruto-real-active-pool.json'));
-const wiring = readJson(path.join(ledgerRoot, 'naruto-runtime-wiring.json'));
-const artifactText = collectText(ledgerRoot);
-const ok = summary.runtime_source_of_truth === 'agent-orchestrator-scheduler'
-    && summary.pre_run_real_active_pool_source === 'skipped'
-    && realPool?.status === 'skipped'
-    && realPool?.runtime_source_of_truth === 'agent-orchestrator-scheduler'
-    && realPool?.reason === 'pre_run_smoke_disabled_for_production'
-    && wiring?.source_of_truth === 'naruto-work-graph'
-    && artifactText.includes('agent-orchestrator-scheduler')
-    && artifactText.includes('pre_run_smoke_never_owns_production_runtime');
-assertGate(ok, 'Naruto production runtime source of truth must be proven by command artifacts, not source-string checks', {
-    summary,
-    realPool,
-    wiring
-});
-emitGate('naruto:orchestrator-runtime-source', {
-    mission_id: summary.mission_id,
-    runtime_source_of_truth: summary.runtime_source_of_truth,
-    pre_run_real_active_pool_source: summary.pre_run_real_active_pool_source,
-    real_pool_status: realPool?.status || null,
-    wiring_ok: wiring?.ok === true
-});
-function readJson(file) {
-    try {
-        return JSON.parse(fs.readFileSync(file, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-function collectText(root) {
-    const chunks = [];
-    const stack = [root];
-    while (stack.length) {
-        const current = stack.pop();
-        if (!current || !fs.existsSync(current))
-            continue;
-        const stat = fs.statSync(current);
-        if (stat.isDirectory()) {
-            for (const child of fs.readdirSync(current))
-                stack.push(path.join(current, child));
-            continue;
-        }
-        if (!/\.(json|jsonl)$/.test(current))
-            continue;
-        chunks.push(fs.readFileSync(current, 'utf8'));
-    }
-    return chunks.join('\n');
-}
-//# sourceMappingURL=naruto-orchestrator-runtime-source-check.js.map