sneakoscope 4.0.13 → 4.0.15

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

@@ -0,0 +1,92 @@
+#!/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

@@ -0,0 +1,53 @@
+#!/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

@@ -0,0 +1,22 @@
+#!/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

@@ -0,0 +1,43 @@
+#!/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

@@ -0,0 +1,34 @@
+#!/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-loop-maker-checker-check.js

@@ -0,0 +1,3 @@
+import { runLoopDirectiveCheck } from './loop-directive-check-lib.js';
+await runLoopDirectiveCheck('naruto:loop-maker-checker');
+//# sourceMappingURL=naruto-loop-maker-checker-check.js.map

package/dist/scripts/naruto-loop-mesh-blackbox.js

@@ -0,0 +1,3 @@
+import { runLoopDirectiveCheck } from './loop-directive-check-lib.js';
+await runLoopDirectiveCheck('naruto:loop-mesh-blackbox');
+//# sourceMappingURL=naruto-loop-mesh-blackbox.js.map

package/dist/scripts/naruto-loop-mesh-check.js

@@ -0,0 +1,3 @@
+import { runLoopDirectiveCheck } from './loop-directive-check-lib.js';
+await runLoopDirectiveCheck('naruto:loop-mesh');
+//# sourceMappingURL=naruto-loop-mesh-check.js.map

package/dist/scripts/naruto-loop-worker-router-check.js

@@ -0,0 +1,3 @@
+import { runLoopDirectiveCheck } from './loop-directive-check-lib.js';
+await runLoopDirectiveCheck('naruto:loop-worker-router');
+//# sourceMappingURL=naruto-loop-worker-router-check.js.map

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

@@ -0,0 +1,70 @@
+#!/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

package/dist/scripts/naruto-parallel-gate-consistency-check.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const command = readText('src/core/commands/naruto-command.ts');
+assertGate(command.includes('passed: result.ok === true && nativeProofOk && finalAccepted && parallelRuntimeOk'), 'Naruto gate passed condition must include parallelRuntimeOk');
+assertGate(command.includes('naruto_parallel_runtime_proof_below_gate'), 'Naruto gate must keep blocker for insufficient parallel runtime proof');
+emitGate('naruto:parallel-gate-consistency');
+//# sourceMappingURL=naruto-parallel-gate-consistency-check.js.map

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

@@ -0,0 +1,41 @@
+#!/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-parallel-runtime-proof-check.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const orchestrator = readText('src/core/agents/agent-orchestrator.ts');
+const command = readText('src/core/commands/naruto-command.ts');
+assertGate(orchestrator.includes('writeParallelRuntimeProof') && orchestrator.includes('parallel_runtime_proof'), 'orchestrator must write parallel runtime proof');
+assertGate(command.includes('parallel_runtime') && command.includes('parallel_runtime_proof_below_gate'), 'Naruto result/gate must include parallel runtime proof');
+emitGate('naruto:parallel-runtime-proof');
+//# sourceMappingURL=naruto-parallel-runtime-proof-check.js.map

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

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { decideNarutoConcurrency } from '../core/naruto/naruto-concurrency-governor.js';
+import { DEFAULT_NARUTO_CLONES } from '../core/agents/agent-schema.js';
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+assertGate(DEFAULT_NARUTO_CLONES === 32, 'default Naruto clones must be 32');
+const extreme = decideNarutoConcurrency({ requestedClones: 32, totalWorkItems: 64, backend: 'fake', parallelismMode: 'extreme' });
+const safe = decideNarutoConcurrency({ requestedClones: 32, totalWorkItems: 64, backend: 'fake', parallelismMode: 'safe' });
+assertGate(extreme.parallelism_mode === 'extreme' && safe.parallelism_mode === 'safe', 'governor must record parallelism mode', { extreme, safe });
+assertGate(readText('src/core/commands/naruto-command.ts').includes('--parallelism'), 'Naruto CLI must parse --parallelism');
+emitGate('naruto:parallelism-mode', { extreme, safe });
+//# sourceMappingURL=naruto-parallelism-mode-check.js.map

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

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const src = readText('src/core/commands/naruto-command.ts');
+for (const token of ['$Naruto starting:', 'clones requested:', 'target active workers:', '$Naruto parallel proof:', 'speedup:'])
+    assertGate(src.includes(token), `Naruto UX token missing: ${token}`);
+emitGate('naruto:parallelism-ux');
+//# sourceMappingURL=naruto-parallelism-ux-check.js.map

package/dist/scripts/naruto-proof-message-summary-check.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const naruto = readText('src/core/commands/naruto-command.ts');
+const summary = readText('src/core/agents/runtime-proof-summary.ts');
+assertGate(naruto.includes('--messages 20') && naruto.includes('maxMessages: parsed.messages'), 'naruto proof CLI must accept --messages and forward limit');
+assertGate(summary.includes('Recent worker messages:') && summary.includes('[done]') && summary.includes('[fail]'), 'runtime proof summary renderer must show worker message summary');
+emitGate('naruto:proof-message-summary');
+//# sourceMappingURL=naruto-proof-message-summary-check.js.map

package/dist/scripts/naruto-proof-zellij-stacked-summary-check.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-naruto-proof-zellij-'));
+const missionId = 'M-naruto-proof-zellij';
+const dir = path.join(tmp, '.sneakoscope', 'missions', missionId);
+const agents = path.join(dir, 'agents');
+await fs.mkdir(path.join(dir, 'zellij'), { recursive: true });
+await fs.mkdir(agents, { recursive: true });
+await fs.writeFile(path.join(agents, 'parallel-runtime-proof.json'), JSON.stringify({
+    schema: 'sks.parallel-runtime-proof.v1',
+    mission_id: missionId,
+    max_observed_active_workers: 32,
+    unique_worker_pids: 32,
+    max_observed_model_calls: 12,
+    speedup_ratio: 6.8,
+    visible_panes: 8,
+    headless_workers: 24,
+    passed: true,
+    blockers: []
+}, null, 2));
+await fs.writeFile(path.join(agents, 'agent-scheduler-state.json'), JSON.stringify({ target_active_slots: 32, max_observed_active_slots: 32, largest_batch_size: 32, scheduler_utilization: 0.91 }, null, 2));
+await fs.writeFile(path.join(dir, 'zellij', 'slot-telemetry.snapshot.json'), JSON.stringify({ schema: 'sks.zellij-slot-telemetry-snapshot.v1', mission_id: missionId, updated_at: new Date(Date.now() - 500).toISOString(), slots: {}, counts: {} }, null, 2));
+await fs.writeFile(path.join(dir, 'zellij-right-column-state.json'), JSON.stringify({ schema: 'sks.zellij-right-column-state.v1', mission_id: missionId, session_name: 'fixture', status: 'active', slot_column_anchor_pane_id: 'terminal_1', visible_worker_panes: [], headless_workers: [], blockers: [] }, null, 2));
+await fs.writeFile(path.join(tmp, 'agent-zellij-pane-launch-ledger.jsonl'), Array.from({ length: 8 }, (_, i) => JSON.stringify({
+    schema: 'sks.agent-zellij-pane-launch.v1',
+    mission_id: missionId,
+    slot_id: `slot-${String(i + 1).padStart(3, '0')}`,
+    worker_stacked_requested: i > 0,
+    worker_stacked_applied: i > 0,
+    worker_stacked_fallback_mode: i > 0 ? 'native-stacked' : null,
+    worker_stacked_capability: { supports_stacked_panes: true, parsed_version: '0.43.1' },
+    slot_column_anchor_pane_id: 'terminal_1'
+})).join('\n') + '\n');
+await fs.writeFile(path.join(dir, 'zellij', 'pane-creation-lock-events.jsonl'), [40, 70, 120, 180, 220, 260, 310, 350].map((wait, i) => JSON.stringify({ schema: 'sks.zellij-pane-creation-lock-metrics.v1', mission_id: missionId, slot_id: `slot-${i}`, wait_ms: wait, held_ms: 300 })).join('\n') + '\n');
+const cli = path.join(root, 'dist', 'bin', 'sks.js');
+const res = spawnSync(process.execPath, [cli, 'naruto', 'proof', 'latest'], { cwd: tmp, encoding: 'utf8', timeout: 30000 });
+assertGate(res.status === 0, 'sks naruto proof latest failed', { stdout: res.stdout, stderr: res.stderr });
+for (const token of ['Zellij stacked panes: 7/7 applied', 'Stack fallback: 0', 'Pane lock wait p95: 350ms', 'SLOTS anchors: 1']) {
+    assertGate(res.stdout.includes(token), `naruto proof output missing ${token}`, { stdout: res.stdout });
+}
+emitGate('naruto:proof-zellij-stacked-summary', { command: 'sks naruto proof latest' });
+//# sourceMappingURL=naruto-proof-zellij-stacked-summary-check.js.map

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

@@ -0,0 +1,119 @@
+#!/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');
+const childEnv = { ...process.env, SKS_DISABLE_GIT_WORKTREE: '1' };
+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',
+    '--no-open-zellij'
+], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 600000, 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',
+    '--no-open-zellij'
+], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 600000, 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