sneakoscope 2.0.15 → 2.0.17

package/dist/core/commands/naruto-command.js

@@ -19,6 +19,7 @@ import { buildNarutoGptFinalPack } from '../naruto/naruto-gpt-final-pack.js';
 import { planNarutoZellijDashboard } from '../zellij/zellij-naruto-dashboard.js';
 import { checkPromptPlaceholders } from '../prompt/prompt-placeholder-guard.js';
 import { evaluateGitWorktreeCapability } from '../git/git-worktree-capability.js';
+import { buildRuntimeProofSummary, renderRuntimeProofSummary } from '../agents/runtime-proof-summary.js';
 const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
 const NARUTO_ROUTE = '$Naruto';
 // $Naruto — Shadow Clone Swarm (影分身 / Kage Bunshin no Jutsu).
@@ -37,6 +38,8 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
         return narutoDashboard(parsed);
     if (parsed.action === 'workers')
         return narutoWorkers(parsed);
+    if (parsed.action === 'proof')
+        return narutoProof(parsed);
     return narutoRun(parsed);
 }
 async function narutoRun(parsed) {
@@ -165,10 +168,12 @@ async function narutoRun(parsed) {
         requestedClones: roster.agent_count,
         totalWorkItems: workGraph.total_work_items,
         pendingWorkQueueSize: workGraph.total_work_items,
-        backend: schedulerBackend
+        backend: schedulerBackend,
+        parallelismMode: parsed.parallelism
     });
     const backendMinimum = schedulerBackend === 'fake' ? roster.agent_count : Math.min(roster.agent_count, 2);
-    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || Math.max(governor.safe_active_workers, backendMinimum), safe.cap));
+    const activeCap = parsed.parallelism === 'safe' ? safe.cap : MAX_NARUTO_AGENT_COUNT;
+    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || Math.max(governor.safe_active_workers, backendMinimum), activeCap));
     const zellijVisiblePanes = Math.max(1, Math.min(activeSlots, governor.safe_zellij_visible_panes));
     const activePool = await runNarutoActivePool({ graph: workGraph, governor: { ...governor, safe_active_workers: activeSlots } });
     const runPreRunSmoke = parsed.smoke === true || process.env.SKS_NARUTO_PRE_RUN_SMOKE === '1';
@@ -281,6 +286,20 @@ async function narutoRun(parsed) {
         prompt: parsed.prompt
     });
     let liveZellij = null;
+    if (!parsed.json) {
+        console.log('$Naruto starting:');
+        console.log('  clones requested: ' + roster.agent_count);
+        console.log('  work items: ' + workGraph.total_work_items);
+        console.log('  target active workers: ' + activeSlots);
+        console.log('  visible panes: ' + zellijVisiblePanes);
+        console.log('  headless workers: ' + Math.max(0, activeSlots - zellijVisiblePanes));
+        console.log('  backend: ' + schedulerBackend);
+        console.log('  parallelism mode: ' + parsed.parallelism);
+        if (activeSlots < roster.agent_count)
+            console.log('  cap reasons: ' + (governor.reasons.join(', ') || 'host safety cap'));
+        if (parsed.parallelism !== 'safe' && activeSlots < 10)
+            console.log('  warning: active workers below 10 in non-safe mode');
+    }
     if (!parsed.json && !parsed.mock && !parsed.noOpenZellij) {
         liveZellij = await launchZellijLayout({
             root,
@@ -356,8 +375,11 @@ async function narutoRun(parsed) {
         narutoRebalancePolicy: rebalancePolicy,
         json: parsed.json
     });
+    const parallelRuntime = result.parallel_runtime_proof || null;
     const nativeProofOk = result.proof?.ok === true || result.proof?.status === 'passed';
     const finalAccepted = result.proof?.status === 'passed' || result.proof?.gpt_final_status === 'approved';
+    const parallelRuntimeOk = !parsed.mock || roster.agent_count < 16 || (parallelRuntime?.passed === true
+        && Number(parallelRuntime.max_observed_active_workers || 0) >= Math.min(16, activeSlots));
     await writeJsonAtomic(path.join(mission.dir, 'naruto-gate.json'), {
         schema: 'sks.naruto-gate.v1',
         passed: result.ok === true && nativeProofOk && finalAccepted,
@@ -374,9 +396,10 @@ async function narutoRun(parsed) {
         gpt_final_pack_ready: true,
         zellij_dashboard_ready: zellijDashboard.ok === true,
         native_agent_proof: nativeProofOk,
+        parallel_runtime_proof: parallelRuntimeOk,
         final_arbiter_accepted: finalAccepted,
         session_cleanup: result.proof?.all_sessions_closed === true || nativeProofOk,
-        blockers: result.proof?.blockers || [],
+        blockers: [...(result.proof?.blockers || []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate'])],
         updated_at: nowIso()
     });
     await setCurrent(root, {
@@ -442,6 +465,15 @@ async function narutoRun(parsed) {
                 worker_lifecycle_sample: realActivePoolSmoke.worker_lifecycle.slice(0, 5)
             }
         },
+        parallel_runtime: parallelRuntime ? {
+            proof_path: path.join(result.ledger_root || '', 'parallel-runtime-proof.json'),
+            max_observed_active_workers: parallelRuntime.max_observed_active_workers,
+            unique_worker_pids: parallelRuntime.unique_worker_pids,
+            speedup_ratio: parallelRuntime.speedup_ratio,
+            visible_panes: parallelRuntime.visible_panes,
+            headless_workers: parallelRuntime.headless_workers,
+            passed: parallelRuntime.passed
+        } : null,
         local_worker: localWorkerSummary,
         proof: result.proof?.status || 'missing',
         run: compactNarutoRunResult(result),
@@ -455,6 +487,13 @@ async function narutoRun(parsed) {
         console.log('Backend: ' + result.backend);
         console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
         console.log('Proof: ' + summary.proof);
+        if (summary.parallel_runtime) {
+            console.log('$Naruto parallel proof:');
+            console.log('  max active workers: ' + summary.parallel_runtime.max_observed_active_workers);
+            console.log('  unique PIDs: ' + summary.parallel_runtime.unique_worker_pids);
+            console.log('  speedup: ' + summary.parallel_runtime.speedup_ratio + 'x');
+            console.log('  result: ' + (summary.parallel_runtime.passed ? 'passed' : 'blocked'));
+        }
         if (summary.zellij?.ok && summary.zellij.capability?.status === 'ok')
             console.log('Zellij: prepared ' + zellijVisiblePanes + ' visible active clone lane(s) in ' + summary.zellij.session_name + '; dashboard tracks ' + Math.max(0, activeSlots - zellijVisiblePanes) + ' headless active worker(s)');
         else if (summary.zellij?.ok)
@@ -666,6 +705,16 @@ async function narutoWorkers(parsed) {
         console.log(`Active ${summary.active} · completed ${summary.completed} · failed ${summary.failed} · visible ${summary.visible_worker_panes.length} · headless ${summary.headless_workers.length}`);
     });
 }
+async function narutoProof(parsed) {
+    const root = await sksRoot();
+    const id = parsed.missionId && parsed.missionId !== 'latest' ? parsed.missionId : await findLatestMission(root);
+    if (!id)
+        return emit(parsed, { schema: NARUTO_RESULT_SCHEMA, ok: false, action: 'proof', status: 'missing_mission' }, () => console.log('No Naruto mission found.'));
+    const summary = await buildRuntimeProofSummary(root, id);
+    return emit(parsed, { ...summary, action: 'proof' }, () => {
+        console.log(renderRuntimeProofSummary(summary));
+    });
+}
 async function narutoHelp(parsed) {
     const help = {
         schema: NARUTO_RESULT_SCHEMA,
@@ -675,7 +724,8 @@ async function narutoHelp(parsed) {
         description: 'Shadow Clone Swarm: fan out up to ' + MAX_NARUTO_AGENT_COUNT + ' parallel clone sessions.',
         usage: [
             'sks naruto run "<task>" [--clones N] [--backend codex-sdk|fake|ollama] [--local-model|--no-ollama] [--work-items N] [--real] [--readonly] [--json]',
-            'sks naruto status [--mission <id>] [--json]'
+            'sks naruto status [--mission <id>] [--json]',
+            'sks naruto proof latest [--json]'
         ],
         defaults: { clones: DEFAULT_NARUTO_CLONES, max_clones: MAX_NARUTO_AGENT_COUNT, backend: 'codex-sdk' }
     };
@@ -690,7 +740,7 @@ function parseNarutoArgs(args = []) {
     if (hasFlag(args, '--help') || hasFlag(args, '-h'))
         args = ['help', ...args.filter((arg) => arg !== '--help' && arg !== '-h')];
     const first = args[0] && !String(args[0]).startsWith('--') ? String(args[0]) : '';
-    const actions = new Set(['run', 'status', 'help', 'dashboard', 'workers']);
+    const actions = new Set(['run', 'status', 'help', 'dashboard', 'workers', 'proof']);
     const action = (actions.has(first) ? first : 'run');
     const rest = action === first ? args.slice(1) : args;
     const json = hasFlag(args, '--json');
@@ -707,7 +757,7 @@ function parseNarutoArgs(args = []) {
     const readonly = hasFlag(args, '--readonly') || hasFlag(args, '--read-only');
     const writeModeRaw = String(readOption(args, '--write-mode', hasFlag(args, '--parallel-write') ? 'parallel' : '') || '');
     const writeMode = (['proof-safe', 'parallel', 'serial', 'off'].includes(writeModeRaw) ? writeModeRaw : null);
-    const positionalMission = action === 'dashboard' || action === 'workers' || action === 'status'
+    const positionalMission = action === 'dashboard' || action === 'workers' || action === 'status' || action === 'proof'
         ? positionalArgs(rest, new Set()).find((arg) => /^latest$|^M-/.test(arg))
         : null;
     const missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', positionalMission || 'latest')));
@@ -716,9 +766,16 @@ function parseNarutoArgs(args = []) {
     const noOpenZellij = hasFlag(args, '--no-open-zellij') || hasFlag(args, '--no-zellij');
     const attach = hasFlag(args, '--attach');
     const smoke = hasFlag(args, '--smoke');
-    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url']);
+    const parallelism = normalizeParallelism(readOption(args, '--parallelism', 'extreme'));
+    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url', '--parallelism']);
     const prompt = positionalArgs(rest, valueFlags).join(' ').trim() || 'Naruto shadow clone swarm run';
-    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach, smoke };
+    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach, smoke, parallelism };
+}
+function normalizeParallelism(value) {
+    const text = String(value || 'extreme').toLowerCase();
+    if (text === 'safe' || text === 'balanced' || text === 'extreme')
+        return text;
+    return 'extreme';
 }
 async function writeNarutoArtifacts(ledgerRoot, artifacts) {
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-work-graph.json'), artifacts.workGraph);