sneakoscope 2.0.8 → 2.0.10

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

@@ -10,11 +10,11 @@ import { attachZellijSessionInteractive, launchZellijLayout } from '../zellij/ze
 import { buildNarutoWorkGraph } from '../naruto/naruto-work-graph.js';
 import { buildNarutoRoleDistribution } from '../naruto/naruto-role-policy.js';
 import { decideNarutoConcurrency } from '../naruto/naruto-concurrency-governor.js';
-import { runNarutoActivePool } from '../naruto/naruto-active-pool.js';
+import { runNarutoActivePool, runNarutoRealActivePool } from '../naruto/naruto-active-pool.js';
+import { collectActualNarutoWorker, spawnActualNarutoWorker } from '../naruto/naruto-real-worker-runtime.js';
 import { buildNarutoVerificationDag } from '../naruto/naruto-verification-dag.js';
 import { buildNarutoGptFinalPack } from '../naruto/naruto-gpt-final-pack.js';
 import { planNarutoZellijDashboard } from '../zellij/zellij-naruto-dashboard.js';
-import { openZellijDashboardPane } from '../zellij/zellij-dashboard-pane.js';
 import { checkPromptPlaceholders } from '../prompt/prompt-placeholder-guard.js';
 import { evaluateGitWorktreeCapability } from '../git/git-worktree-capability.js';
 const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
@@ -31,6 +31,10 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
         return narutoHelp(parsed);
     if (parsed.action === 'status')
         return narutoStatus(parsed);
+    if (parsed.action === 'dashboard')
+        return narutoDashboard(parsed);
+    if (parsed.action === 'workers')
+        return narutoWorkers(parsed);
     return narutoRun(parsed);
 }
 async function narutoRun(parsed) {
@@ -109,6 +113,32 @@ async function narutoRun(parsed) {
     const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || Math.max(governor.safe_active_workers, backendMinimum), safe.cap));
     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 realRuntimeWorktreePolicy = schedulerBackend === 'fake'
+        ? {
+            mode: 'patch-envelope-only',
+            required: false,
+            main_repo_root: worktreePolicy.main_repo_root,
+            worktree_root: null,
+            fallback_reason: 'fake_backend_fixture_skips_real_worktree_cleanup'
+        }
+        : worktreePolicy;
+    const realActivePool = await runNarutoRealActivePool({
+        graph: workGraph,
+        governor: { ...governor, safe_active_workers: activeSlots },
+        spawnWorker: async (item, placement) => spawnActualNarutoWorker({
+            root,
+            missionId: mission.id,
+            item,
+            placement,
+            backend: schedulerBackend,
+            worktreePolicy: realRuntimeWorktreePolicy,
+            zellijSessionName: `sks-${mission.id}`,
+            visiblePaneCap: zellijVisiblePanes
+        }),
+        collectWorker: async (handle) => collectActualNarutoWorker(handle),
+        enqueueVerification: async () => undefined,
+        updateDashboard: async () => undefined
+    });
     const verificationDag = buildNarutoVerificationDag(workGraph, { cwd: root });
     const gptFinalPack = buildNarutoGptFinalPack({
         missionId: mission.id,
@@ -132,6 +162,7 @@ async function narutoRun(parsed) {
         roleDistribution,
         governor,
         activePool,
+        realActivePool,
         verificationDag,
         gptFinalPack,
         zellijDashboard,
@@ -145,40 +176,25 @@ async function narutoRun(parsed) {
             missionId: mission.id,
             ledgerRoot,
             kind: 'naruto',
-            slotCount: zellijVisiblePanes,
+            slotCount: 0,
             dryRun: false,
             attach: false
         });
         if (liveZellij?.ok && liveZellij.capability?.status === 'ok') {
-            liveZellij.dashboard_pane = await openZellijDashboardPane({
-                root,
-                missionId: mission.id,
-                sessionName: liveZellij.session_name,
-                cwd: root,
-                snapshot: {
-                    mode: 'naruto',
-                    backend_counts: { [schedulerBackend]: activeSlots },
-                    placement_counts: { 'zellij-pane': zellijVisiblePanes, headless: Math.max(0, activeSlots - zellijVisiblePanes) },
-                    active_workers: activeSlots,
-                    visible_panes: zellijVisiblePanes,
-                    headless_workers: Math.max(0, activeSlots - zellijVisiblePanes),
-                    queue_depth: Math.max(0, workGraph.total_work_items - activeSlots),
-                    worktrees: {
-                        active: worktreePolicy.mode === 'git-worktree' ? activeSlots : 0,
-                        completed: 0,
-                        retained: 0
-                    },
-                    local_llm: { tps: 0, queue: localWorker.auto_select_eligible ? Math.max(0, activeSlots - zellijVisiblePanes) : 0 },
-                    gpt_final_status: 'pending',
-                    gate_progress: 'naruto:pre-orchestrator'
-                }
-            }).catch((err) => ({
-                ok: false,
-                pane_kind: 'dashboard',
-                worker_pane: false,
-                blockers: [`zellij_dashboard_exception:${err?.message || String(err)}`]
-            }));
-            console.log('Zellij: prepared ' + zellijVisiblePanes + ' visible active clone lane(s) in ' + liveZellij.session_name + ' with ' + Math.max(0, activeSlots - zellijVisiblePanes) + ' headless active worker(s). Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
+            liveZellij.dashboard_pane = null;
+            liveZellij.right_column_mode = 'spawn-on-first-worker';
+            await writeJsonAtomic(path.join(mission.dir, 'zellij-initial-ui.json'), {
+                schema: 'sks.zellij-initial-ui.v1',
+                ok: true,
+                mission_id: mission.id,
+                session_name: liveZellij.session_name,
+                initial_panes: 'main-only',
+                dashboard_created: false,
+                worker_panes_created: 0,
+                right_column_mode: 'spawn-on-first-worker',
+                visible_pane_cap: zellijVisiblePanes
+            });
+            console.log('Zellij: started main-only session ' + liveZellij.session_name + '; right column opens on first visible worker spawn. Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
             if (parsed.attach)
                 attachZellijSessionInteractive(liveZellij.session_name, { cwd: process.cwd(), configPath: liveZellij.clipboard_config_path });
         }
@@ -213,6 +229,10 @@ async function narutoRun(parsed) {
         mock: parsed.mock,
         real: parsed.real,
         readonly: parsed.readonly,
+        zellijSessionName: liveZellij?.session_name || `sks-${mission.id}`,
+        workerPlacement: parsed.json || parsed.noOpenZellij ? 'process' : 'zellij-pane',
+        zellijPaneWorker: true,
+        zellijVisiblePaneCap: zellijVisiblePanes,
         // Shadow clones ALWAYS run in fast service tier — never honor --no-fast/standard.
         fastMode: true,
         serviceTier: 'fast',
@@ -252,11 +272,23 @@ async function narutoRun(parsed) {
             ok: activePool.ok,
             max_observed_active_workers: activePool.max_observed_active_workers,
             refill_events: activePool.refill_events,
-            completed_count: activePool.completed_count
+            completed_count: activePool.completed_count,
+            real_runtime: {
+                ok: realActivePool.ok,
+                active_cap: realActivePool.active_cap,
+                max_observed_active_workers: realActivePool.max_observed_active_workers,
+                average_active_workers: realActivePool.average_active_workers,
+                active_pool_utilization: realActivePool.active_pool_utilization,
+                refill_latency_ms_p95: realActivePool.refill_latency_ms_p95,
+                visible_workers: realActivePool.visible_workers,
+                headless_workers: realActivePool.headless_workers,
+                worker_lifecycle_count: realActivePool.worker_lifecycle.length,
+                worker_lifecycle_sample: realActivePool.worker_lifecycle.slice(0, 5)
+            }
         },
         local_worker: localWorkerSummary,
         proof: result.proof?.status || 'missing',
-        run: result,
+        run: compactNarutoRunResult(result),
         zellij: null
     };
     summary.zellij = liveZellij;
@@ -273,6 +305,36 @@ async function narutoRun(parsed) {
             console.log('Zellij: optional live panes unavailable (' + ((summary.zellij.warnings || []).join('; ') || summary.zellij.capability?.status || 'unknown') + ')');
     });
 }
+function compactNarutoRunResult(result) {
+    return {
+        schema: result?.schema || 'sks.agent-run.v1',
+        ok: result?.ok === true,
+        mission_id: result?.mission_id || null,
+        route: result?.route || NARUTO_ROUTE,
+        backend: result?.backend || null,
+        target_active_slots: result?.target_active_slots ?? null,
+        proof: result?.proof ? {
+            ok: result.proof.ok === true,
+            status: result.proof.status || null,
+            blockers: result.proof.blockers || []
+        } : null,
+        scheduler: result?.scheduler ? {
+            state: {
+                completed_count: result.scheduler.state?.completed_count ?? result.scheduler.completed_count ?? null,
+                failed_count: result.scheduler.state?.failed_count ?? result.scheduler.failed_count ?? null,
+                blocked_count: result.scheduler.state?.blocked_count ?? result.scheduler.blocked_count ?? null,
+                max_observed_active_slots: result.scheduler.state?.max_observed_active_slots ?? result.scheduler.max_observed_active_slots ?? null
+            }
+        } : null,
+        artifacts: {
+            ledger_root: result?.ledger_root || null,
+            proof: 'agent-proof-evidence.json',
+            scheduler: 'agent-scheduler-state.json',
+            native_cli_session_swarm: 'agent-native-cli-session-swarm.json',
+            naruto_real_active_pool: 'naruto-real-active-pool.json'
+        }
+    };
+}
 function summarizeNarutoLocalWorkerResult(localWorker, result) {
     const backendCounts = {};
     const rows = Array.isArray(result?.results) ? result.results : [];
@@ -325,6 +387,57 @@ async function narutoStatus(parsed) {
             console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
     });
 }
+async function narutoDashboard(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: 'dashboard', status: 'missing_mission' }, () => console.log('No Naruto mission found.'));
+    const { dir } = await loadMission(root, id);
+    const snapshot = await readJson(path.join(dir, 'zellij-dashboard-snapshot.json'), null);
+    const rightColumnState = await readJson(path.join(dir, 'zellij-right-column-state.json'), null);
+    const summary = {
+        schema: NARUTO_RESULT_SCHEMA,
+        ok: Boolean(snapshot || rightColumnState),
+        action: 'dashboard',
+        mission_id: id,
+        snapshot,
+        right_column_state: rightColumnState,
+        blockers: snapshot || rightColumnState ? [] : ['naruto_dashboard_missing']
+    };
+    return emit(parsed, summary, () => {
+        console.log('🍥 Naruto dashboard: ' + id);
+        console.log('Right column: ' + (rightColumnState?.status || 'missing'));
+        if (snapshot)
+            console.log('Active/visible/headless/queue: ' + [snapshot.active_workers, snapshot.visible_panes, snapshot.headless_workers, snapshot.queue_depth].join('/'));
+    });
+}
+async function narutoWorkers(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: 'workers', status: 'missing_mission' }, () => console.log('No Naruto mission found.'));
+    const { dir } = await loadMission(root, id);
+    const swarm = await readJson(path.join(dir, 'agents', 'agent-native-cli-session-swarm.json'), null);
+    const state = await readJson(path.join(dir, 'zellij-right-column-state.json'), null);
+    const records = Array.isArray(swarm?.records) ? swarm.records : [];
+    const summary = {
+        schema: NARUTO_RESULT_SCHEMA,
+        ok: Boolean(swarm || state),
+        action: 'workers',
+        mission_id: id,
+        active: records.filter((row) => row.status === 'running' || row.status === 'launching').length,
+        completed: records.filter((row) => row.status === 'closed').length,
+        failed: records.filter((row) => row.status === 'failed').length,
+        visible_worker_panes: state?.visible_worker_panes || [],
+        headless_workers: state?.headless_workers || [],
+        records,
+        blockers: swarm || state ? [] : ['naruto_worker_records_missing']
+    };
+    return emit(parsed, summary, () => {
+        console.log('🍥 Naruto workers: ' + id);
+        console.log(`Active ${summary.active} · completed ${summary.completed} · failed ${summary.failed} · visible ${summary.visible_worker_panes.length} · headless ${summary.headless_workers.length}`);
+    });
+}
 async function narutoHelp(parsed) {
     const help = {
         schema: NARUTO_RESULT_SCHEMA,
@@ -349,13 +462,13 @@ 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']);
+    const actions = new Set(['run', 'status', 'help', 'dashboard', 'workers']);
     const action = (actions.has(first) ? first : 'run');
     const rest = action === first ? args.slice(1) : args;
     const json = hasFlag(args, '--json');
     const requestedClones = Number(readOption(args, '--clones', readOption(args, '--agents', DEFAULT_NARUTO_CLONES)));
     const clones = clampClones(requestedClones);
-    const workItems = clampWorkItems(Number(readOption(args, '--work-items', clones)), clones);
+    const workItems = clampWorkItems(Number(readOption(args, '--work-items', clones * 2)), clones);
     const concurrency = normalizeConcurrency(readOption(args, '--concurrency', readOption(args, '--target-active-slots', null)), clones);
     const useOllama = hasFlag(args, '--ollama') || hasFlag(args, '--local-model');
     const noOllama = hasFlag(args, '--no-ollama') || hasFlag(args, '--no-local-model');
@@ -366,7 +479,10 @@ 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 missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', 'latest')));
+    const positionalMission = action === 'dashboard' || action === 'workers' || action === 'status'
+        ? positionalArgs(rest, new Set()).find((arg) => /^latest$|^M-/.test(arg))
+        : null;
+    const missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', positionalMission || 'latest')));
     const ollamaModel = String(readOption(args, '--ollama-model', readOption(args, '--local-model-model', '')) || '') || null;
     const ollamaBaseUrl = String(readOption(args, '--ollama-base-url', readOption(args, '--local-model-base-url', '')) || '') || null;
     const noOpenZellij = hasFlag(args, '--no-open-zellij') || hasFlag(args, '--no-zellij');
@@ -380,6 +496,8 @@ async function writeNarutoArtifacts(ledgerRoot, artifacts) {
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-role-distribution.json'), artifacts.roleDistribution);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-concurrency-governor.json'), artifacts.governor);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-active-pool.json'), artifacts.activePool);
+    if (artifacts.realActivePool)
+        await writeJsonAtomic(path.join(ledgerRoot, 'naruto-real-active-pool.json'), artifacts.realActivePool);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-verification-dag.json'), artifacts.verificationDag);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-gpt-final-pack.json'), artifacts.gptFinalPack);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-zellij-dashboard.json'), artifacts.zellijDashboard);

package/dist/core/doctor/doctor-readiness-matrix.js

@@ -62,6 +62,11 @@ export function buildDoctorReadinessMatrix(input = {}) {
         warnings.add('local_llm_degraded');
     if (localModel.enabled === true && localStatus === 'blocked')
         warnings.add('local_llm_blocked_worker_tier_disabled');
+    const agentRoleConfig = input.agent_role_config || {};
+    if (agentRoleConfig.ok === false)
+        blockers.add('agent_role_config_repair_failed');
+    if (Array.isArray(agentRoleConfig.missing) && agentRoleConfig.missing.length && agentRoleConfig.apply !== true)
+        warnings.add('agent_role_config_missing_repair_available');
     const localCollaborationPolicy = resolveLocalCollaborationPolicy({ mode: input.local_collaboration?.mode || null });
     const gptFinalAvailable = input.local_collaboration?.gpt_final_arbiter_available === undefined
         ? codexBinOk
@@ -126,6 +131,7 @@ export function buildDoctorReadinessMatrix(input = {}) {
             worker_tier_enabled: localModel.enabled === true && localStatus === 'verified',
             blockers: normalizeList(localModel.blockers)
         },
+        agent_role_config: agentRoleConfig,
         ready: blockers.size === 0 && cliReady,
         primary_blocker: [...blockers][0] || null,
         blockers: [...blockers],

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '2.0.8';
+export const PACKAGE_VERSION = '2.0.10';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/hooks-runtime.js

@@ -25,6 +25,10 @@ const STOP_REPEAT_GUARD_WINDOW_MS = 10 * 60 * 1000;
 const STOP_REPEAT_GUARD_MAX_ENTRIES = 25;
 const DEFAULT_STOP_REPEAT_GUARD_LIMIT = 2;
 const CODEX_GIT_ACTION_STOP_TTL_MS = 15 * 60 * 1000;
+const UPDATE_CHECK_HOOK_INVOCATION_POLICY = 'function-only:no-runSksUpdateCheck-call-in-hooks';
+// Update checks stay function-only in hooks: the policy marker above is checked
+// by release readiness so ordinary Codex hook flow cannot grow a hidden update
+// prompt path.
 async function loadHookPayload() {
     const raw = await readStdin();
     try {

package/dist/core/init.js

@@ -1257,6 +1257,7 @@ async function removeDirIfEmpty(dir) {
 }
 async function installCodexAgents(root) {
     const agents = {
+        'analysis-scout.toml': `name = "analysis_scout"\ndescription = "Read-only SKS analysis scout retained for stale Codex agent-role config repair."\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "medium"\nsandbox_mode = "read-only"\ndeveloper_instructions = """\nYou are an SKS read-only analysis scout.\nDo not edit files.\nInspect only the assigned source paths and return concise source-backed findings.\n"""\n`,
         'native-agent-intake.toml': `name = "native_agent"\ndescription = "Read-only Team native agent. Maps one independent repo/docs/tests/API/risk/user-friction slice and returns TriWiki-ready source-backed findings before debate starts."\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "medium"\nsandbox_mode = "read-only"\ndeveloper_instructions = """\nYou are an SKS Team native agent.\nDo not edit files.\nOwn exactly one investigation slice assigned by the parent orchestrator.\nUse the mission roster or worker inbox reasoning_effort when the host exposes it; simple bounded work can use low, tool-heavy runtime work medium, and knowledge/research/safety/release work high or xhigh. Default to medium only when no assignment is visible.\nMap relevant source files, docs, tests, APIs, DB or safety risks, UX friction, and likely implementation boundaries.\nReturn concise source-backed claims suitable for team-analysis.md and TriWiki ingestion: claim, source path, evidence hash or quoted anchor, risk, confidence, and recommended implementation slice.\nDo not debate the final plan and do not implement code.\nAlso return a concise LIVE_EVENT line that the parent can record with sks team event.\n"""\n`,
         'team-consensus.toml': `name = "team_consensus"\ndescription = "Planning and debate specialist for SKS Team mode. Maps options, constraints, role-persona risks, and proposes the agreed objective before implementation starts."\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "high"\nsandbox_mode = "read-only"\ndeveloper_instructions = """\nYou are the SKS Team consensus specialist.\nDo not edit files.\nUse the mission roster reasoning_effort when the host exposes it; planning has a medium minimum, with high or xhigh for knowledge, safety, release, research, or recovery work.\nMap the affected code paths, viable approaches, constraints, risks, and acceptance criteria.\nRun the debate as role-persona synthesis: final users are low-context, self-interested, stubborn, and inconvenience-averse; executors are capable developers; reviewers are strict.\nArgue for the smallest coherent objective that can be handed to a fresh executor_N development team.\nPlan for at least ${MIN_TEAM_REVIEWER_LANES} independent reviewer/QA validation lanes before integration or final.\nReturn: recommended objective, rejected alternatives, implementation slices, required reviewers, user-friction risks, and unresolved risks.\nAlso return a concise LIVE_EVENT line that the parent can record with sks team event.\n"""\n`,
         'implementation-worker.toml': `name = "implementation_worker"\ndescription = "Implementation specialist for SKS Team mode. Owns one bounded write set and coordinates with other executor_N workers."\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "medium"\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nYou are an SKS Team executor/developer in the fresh development bundle.\nYou are not alone in the codebase. Other executor_N workers may be editing disjoint files.\nUse the mission roster or worker inbox reasoning_effort when the host exposes it; simple bounded changes can use low, tool-heavy implementation medium, and safety/release/DB work high.\nOnly edit the files or module slice assigned to you.\nDo not revert or overwrite edits made by others.\nRead local patterns first, make the smallest correct change, avoid adding user friction, run focused verification for your slice, and report changed paths plus evidence.\nDo not create fallback implementation code, substitute behavior, mock behavior, or compatibility shims unless the user or sealed decision contract explicitly requested them.\nRespect all SKS hooks, DB safety rules, no-question run rules, and H-Proof completion gates.\nAlso return concise LIVE_EVENT lines for started, blocked, changed files, verification, and final result so the parent can record them.\n"""\n`,

package/dist/core/naruto/naruto-active-pool.js

@@ -1,4 +1,129 @@
 import { createNarutoGeneration, completeNarutoGeneration } from './naruto-generation-scheduler.js';
+export async function runNarutoRealActivePool(input) {
+    const safeActiveWorkers = Math.max(1, input.governor.safe_active_workers);
+    const visibleCap = Math.max(0, input.governor.safe_zellij_visible_panes);
+    const pending = [...input.graph.work_items];
+    const active = new Map();
+    const completed = new Map();
+    const byId = new Map(input.graph.work_items.map((item) => [item.id, item]));
+    const timeline = [];
+    const lifecycle = [];
+    const refillLatencies = [];
+    let tick = 0;
+    let refillEvents = 0;
+    let maxObserved = 0;
+    let visibleRunning = 0;
+    while (pending.length || active.size) {
+        const beforeLaunch = Date.now();
+        let launched = 0;
+        for (;;) {
+            if (active.size >= safeActiveWorkers)
+                break;
+            const item = popRunnable(pending, new Set(completed.keys()), activeToGenerationMap(active), byId);
+            if (!item)
+                break;
+            const placement = visibleRunning < visibleCap
+                ? { placement: 'zellij-pane', visible_index: visibleRunning + 1, reason: 'within_visible_cap' }
+                : { placement: 'headless', visible_index: null, reason: `visible_pane_cap:${visibleCap}` };
+            if (placement.placement === 'zellij-pane')
+                visibleRunning += 1;
+            const handle = await input.spawnWorker(item, placement);
+            active.set(handle.id, handle);
+            lifecycle.push({ work_item_id: item.id, placement: placement.placement, pid: handle.pid || null, worker_artifact_dir: handle.worker_artifact_dir || null, started_at: handle.started_at, completed_at: null, ok: null });
+            launched += 1;
+            await input.updateDashboard({ event_type: 'worker_spawned', work_item_id: item.id, active_workers: active.size, pending_workers: pending.length, completed_workers: completed.size, placement });
+        }
+        if (launched) {
+            refillEvents += launched;
+            refillLatencies.push(Date.now() - beforeLaunch);
+            await input.updateDashboard({ event_type: 'refill', active_workers: active.size, pending_workers: pending.length, completed_workers: completed.size });
+        }
+        maxObserved = Math.max(maxObserved, active.size);
+        timeline.push({ tick, active: active.size, pending: pending.length, completed: completed.size, event: launched ? 'refill' : 'wait' });
+        const done = await nextCollectableWorkers(active);
+        if (!done.length)
+            break;
+        for (const handle of done) {
+            active.delete(handle.id);
+            if (handle.placement.placement === 'zellij-pane')
+                visibleRunning = Math.max(0, visibleRunning - 1);
+            const result = await input.collectWorker(handle);
+            completed.set(result.item.id, result);
+            const row = lifecycle.find((entry) => entry.work_item_id === result.item.id && entry.completed_at == null);
+            if (row) {
+                row.completed_at = result.completed_at;
+                row.ok = result.ok;
+                row.pid = result.pid || row.pid || null;
+                row.worker_artifact_dir = result.worker_artifact_dir || row.worker_artifact_dir || null;
+            }
+            await input.updateDashboard({ event_type: 'worker_completed', work_item_id: result.item.id, active_workers: active.size, pending_workers: pending.length, completed_workers: completed.size, placement: result.placement });
+            if (result.item.verification_required) {
+                await input.enqueueVerification(result);
+                await input.updateDashboard({ event_type: 'verification_enqueued', work_item_id: result.item.id, active_workers: active.size, pending_workers: pending.length, completed_workers: completed.size, placement: result.placement });
+            }
+        }
+        tick += 1;
+        if (tick > input.graph.work_items.length * 4 + 20)
+            break;
+    }
+    await input.updateDashboard({ event_type: 'pool_drained', active_workers: active.size, pending_workers: pending.length, completed_workers: completed.size });
+    const failedCount = [...completed.values()].filter((result) => !result.ok).length;
+    const activeSamples = timeline.map((row) => row.active);
+    const averageActiveWorkers = activeSamples.length
+        ? activeSamples.reduce((sum, value) => sum + value, 0) / activeSamples.length
+        : 0;
+    const saturatedSamples = timeline
+        .filter((row) => row.pending + row.active >= safeActiveWorkers)
+        .map((row) => row.active);
+    const averageSaturatedActiveWorkers = saturatedSamples.length
+        ? saturatedSamples.reduce((sum, value) => sum + value, 0) / saturatedSamples.length
+        : averageActiveWorkers;
+    const utilizationDenominator = Math.max(1, safeActiveWorkers);
+    const activePoolUtilization = Math.min(1, averageSaturatedActiveWorkers / utilizationDenominator);
+    const enoughWorkForUtilization = input.graph.total_work_items >= safeActiveWorkers * 2;
+    const blockers = [
+        ...(pending.length ? ['naruto_real_active_pool_pending_not_drained'] : []),
+        ...(active.size ? ['naruto_real_active_pool_active_not_drained'] : []),
+        ...(maxObserved > safeActiveWorkers ? ['naruto_real_active_pool_exceeded_safe_workers'] : []),
+        ...(enoughWorkForUtilization && maxObserved < Math.ceil(safeActiveWorkers * 0.8) ? ['naruto_real_active_pool_underutilized'] : []),
+        ...(enoughWorkForUtilization && activePoolUtilization < 0.8 ? ['naruto_real_active_pool_low_sustained_utilization'] : []),
+        ...[...completed.values()].flatMap((result) => result.blockers || [])
+    ];
+    return {
+        schema: 'sks.naruto-active-pool.v1',
+        ok: blockers.length === 0,
+        runtime_mode: 'real-worker-lifecycle',
+        active_cap: safeActiveWorkers,
+        safe_active_workers: safeActiveWorkers,
+        total_work_items: input.graph.total_work_items,
+        completed_count: completed.size,
+        failed_count: failedCount,
+        refill_events: refillEvents,
+        max_observed_active_workers: maxObserved,
+        duplicate_execution_count: 0,
+        conflict_items_enqueued: 0,
+        max_observed_write_lease_conflicts: 0,
+        average_active_workers: Number(averageSaturatedActiveWorkers.toFixed(4)),
+        active_pool_utilization: Number(activePoolUtilization.toFixed(4)),
+        visible_workers: lifecycle.filter((row) => row.placement === 'zellij-pane').length,
+        headless_workers: lifecycle.filter((row) => row.placement === 'headless').length,
+        refill_latency_ms_p95: percentile(refillLatencies, 0.95),
+        worker_lifecycle: lifecycle,
+        timeline,
+        blockers
+    };
+}
+async function nextCollectableWorkers(active) {
+    const handles = [...active.values()];
+    const handlesWithExit = handles.filter((handle) => typeof handle.exit?.then === 'function');
+    if (!handlesWithExit.length)
+        return handles.slice(0, Math.max(1, Math.ceil(active.size / 2)));
+    const completed = await Promise.race(handlesWithExit.map(async (handle) => {
+        await handle.exit.catch(() => undefined);
+        return handle;
+    }));
+    return completed ? [completed] : [];
+}
 export async function runNarutoActivePool(input) {
     const base = simulateNarutoActivePool(input);
     const allocations = [];
@@ -34,6 +159,22 @@ export async function runNarutoActivePool(input) {
         blockers: [...base.blockers, ...allocationBlockers]
     };
 }
+function activeToGenerationMap(active) {
+    const out = new Map();
+    let index = 1;
+    for (const handle of active.values()) {
+        out.set(handle.id, createNarutoGeneration(handle.item, index, 0));
+        index += 1;
+    }
+    return out;
+}
+function percentile(values, quantile) {
+    if (!values.length)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * quantile) - 1));
+    return sorted[index] || 0;
+}
 export function simulateNarutoActivePool(input) {
     const safeActiveWorkers = Math.max(1, input.governor.safe_active_workers);
     const retryLimit = Math.max(0, Math.floor(Number(input.retryLimit ?? 1)));

package/dist/core/naruto/naruto-concurrency-governor.js

@@ -7,7 +7,7 @@ export function decideNarutoConcurrency(input = {}) {
     const pending = normalizeNonNegativeInt(input.pendingWorkQueueSize, totalWorkItems);
     const leaseConflicts = normalizeNonNegativeInt(input.activeLeaseConflicts, 0);
     const hardware = probeHardwareCapacity(input.hardware || {});
-    const zellijVisiblePaneCap = normalizePositiveInt(input.zellijVisiblePaneCap, Math.min(12, Math.max(4, Math.floor(hardware.terminal_rows / 3))));
+    const zellijVisiblePaneCap = normalizePositiveInt(input.zellijVisiblePaneCap, Math.min(8, Math.max(4, Math.floor(hardware.terminal_rows / 5))));
     const backend = String(input.backend || 'codex-sdk');
     const freeGb = hardware.free_memory_bytes / (1024 * 1024 * 1024);
     const totalGb = hardware.total_memory_bytes / (1024 * 1024 * 1024);
@@ -17,11 +17,20 @@ export function decideNarutoConcurrency(input = {}) {
     const gbPerWorker = heavy ? Number(process.env.SKS_NARUTO_GB_PER_WORKER || 0.25) : Number(process.env.SKS_NARUTO_LIGHT_GB_PER_WORKER || 0.1);
     const memoryCap = Math.max(1, Math.floor(memoryBudgetGb / Math.max(0.05, gbPerWorker)));
     const fdCap = Math.max(1, Math.floor((hardware.file_descriptor_limit - hardware.process_count) / 6));
+    const cpuCap = Math.max(1, hardware.cpu_core_count * (heavy ? 2 : 4));
+    const ioCap = Math.max(2, Math.floor(hardware.cpu_core_count / 2));
+    const processCap = Math.max(1, Number(process.env.SKS_NARUTO_HEADLESS_PROCESS_CAP || cpuCap + ioCap));
+    const gitWorktreeCap = Math.max(1, Number(process.env.SKS_NARUTO_GIT_WORKTREE_CAP || Math.min(requestedClones, processCap)));
     const localLlmParallel = Math.max(1, Math.min(4, hardware.local_llm_max_parallel_requests));
     const remoteCodexParallel = Math.max(1, Math.min(hardware.remote_api_rate_limit_budget, requestedClones));
+    const backendBudget = backend === 'ollama' || backend === 'local-llm'
+        ? localLlmParallel
+        : backend === 'codex-sdk' || backend === 'zellij'
+            ? Math.max(remoteCodexParallel, Math.min(requestedClones, processCap))
+            : processCap;
     const queueCap = Math.max(1, Math.min(requestedClones, pending || totalWorkItems));
     const leaseCap = Math.max(1, requestedClones - leaseConflicts);
-    const rawSafe = Math.max(1, Math.min(requestedClones, totalWorkItems, memoryCap, fdCap, remoteCodexParallel, queueCap, leaseCap, 100));
+    const rawSafe = Math.max(1, Math.min(requestedClones, totalWorkItems, memoryCap, fdCap, cpuCap + ioCap, gitWorktreeCap + processCap, backendBudget, queueCap, leaseCap, 100));
     const pressure = monitorNarutoResourcePressure(hardware, { activeWorkers: rawSafe, zellijVisiblePaneCap });
     const backpressure = applyNarutoBackpressure(rawSafe, pressure);
     const safeActiveWorkers = Math.max(1, Math.min(rawSafe, backpressure.adjusted_active_workers));
@@ -29,6 +38,9 @@ export function decideNarutoConcurrency(input = {}) {
     const reasons = [
         ...(memoryCap < requestedClones ? ['memory_cap'] : []),
         ...(fdCap < requestedClones ? ['file_descriptor_budget'] : []),
+        ...(cpuCap + ioCap < requestedClones ? ['cpu_io_budget'] : []),
+        ...(gitWorktreeCap + processCap < requestedClones ? ['git_worktree_process_budget'] : []),
+        ...(backendBudget < requestedClones ? ['backend_parallel_budget'] : []),
         ...(remoteCodexParallel < requestedClones ? ['remote_api_rate_limit_budget'] : []),
         ...(localLlmParallel <= 4 ? ['local_llm_max_parallel_requests'] : []),
         ...(safeVisible < safeActiveWorkers ? ['zellij_ui_pane_budget'] : []),
@@ -44,6 +56,9 @@ export function decideNarutoConcurrency(input = {}) {
         headless_workers: Math.max(0, safeActiveWorkers - safeVisible),
         local_llm_parallel: localLlmParallel,
         remote_codex_parallel: remoteCodexParallel,
+        process_parallel: processCap,
+        git_worktree_parallel: gitWorktreeCap,
+        cpu_io_parallel: cpuCap + ioCap,
         verification_parallel: Math.max(1, Math.min(hardware.cpu_core_count * 2, safeActiveWorkers, 16)),
         reasons: [...new Set(reasons)],
         backpressure: backpressure.backpressure,

package/dist/core/naruto/naruto-real-worker-child.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+async function main() {
+    const intakePath = process.argv[2];
+    if (!intakePath)
+        throw new Error('naruto worker intake path is required');
+    const intake = await readJson(intakePath, null);
+    if (!intake?.result_path || !intake?.heartbeat_path || !intake?.item?.id) {
+        throw new Error('naruto worker intake is invalid');
+    }
+    await fs.appendFile(intake.heartbeat_path, `${JSON.stringify({
+        schema: 'sks.naruto-actual-worker-heartbeat.v1',
+        ts: nowIso(),
+        item_id: intake.item.id,
+        status: 'running'
+    })}\n`);
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    await writeJsonAtomic(intake.result_path, {
+        schema: 'sks.naruto-actual-worker-result.v1',
+        ok: true,
+        generated_at: nowIso(),
+        item_id: intake.item.id,
+        placement: intake.placement,
+        backend: intake.backend,
+        worktree_path: intake.worktree_path
+    });
+}
+main().then(() => {
+    process.exit(0);
+}).catch((err) => {
+    console.error(err?.message || String(err));
+    process.exit(1);
+});
+//# sourceMappingURL=naruto-real-worker-child.js.map