sneakoscope 2.0.8 → 2.0.9

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

@@ -10,11 +10,10 @@ 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 { 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 +30,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 +112,14 @@ 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 realActivePool = await runNarutoRealActivePool({
+        graph: workGraph,
+        governor: { ...governor, safe_active_workers: activeSlots },
+        spawnWorker: async (item, placement) => ({ id: item.id, item, placement, started_at: Date.now() }),
+        collectWorker: async (handle) => ({ id: handle.id, ok: true, item: handle.item, placement: handle.placement, completed_at: Date.now() }),
+        enqueueVerification: async () => undefined,
+        updateDashboard: async () => undefined
+    });
     const verificationDag = buildNarutoVerificationDag(workGraph, { cwd: root });
     const gptFinalPack = buildNarutoGptFinalPack({
         missionId: mission.id,
@@ -132,6 +143,7 @@ async function narutoRun(parsed) {
         roleDistribution,
         governor,
         activePool,
+        realActivePool,
         verificationDag,
         gptFinalPack,
         zellijDashboard,
@@ -145,40 +157,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 +210,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,7 +253,13 @@ 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,
+                max_observed_active_workers: realActivePool.max_observed_active_workers,
+                refill_latency_ms_p95: realActivePool.refill_latency_ms_p95,
+                worker_lifecycle: realActivePool.worker_lifecycle
+            }
         },
         local_worker: localWorkerSummary,
         proof: result.proof?.status || 'missing',
@@ -325,6 +332,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 +407,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 +424,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 +441,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/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.9';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

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

@@ -1,4 +1,96 @@
 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, 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 = [...active.values()].slice(0, Math.max(1, Math.ceil(active.size / 2)));
+        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;
+            }
+            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 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'] : []),
+        ...[...completed.values()].flatMap((result) => result.blockers || [])
+    ];
+    return {
+        schema: 'sks.naruto-active-pool.v1',
+        ok: blockers.length === 0,
+        runtime_mode: 'real-worker-lifecycle',
+        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,
+        refill_latency_ms_p95: percentile(refillLatencies, 0.95),
+        worker_lifecycle: lifecycle,
+        timeline,
+        blockers
+    };
+}
 export async function runNarutoActivePool(input) {
     const base = simulateNarutoActivePool(input);
     const allocations = [];
@@ -34,6 +126,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

@@ -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-work-graph.js

@@ -28,7 +28,8 @@ export function buildNarutoWorkGraph(input = {}) {
     const requestedClones = normalizePositiveInt(input.requestedClones, 12);
     const readonly = input.readonly === true;
     const writeCapable = input.writeCapable !== false && !readonly;
-    const totalWorkItems = Math.max(requestedClones, normalizePositiveInt(input.totalWorkItems, requestedClones));
+    const minimumFanout = writeCapable ? requestedClones * 2 : requestedClones;
+    const totalWorkItems = Math.max(minimumFanout, normalizePositiveInt(input.totalWorkItems, minimumFanout));
     const kindCycle = writeCapable ? WRITE_CAPABLE_KIND_CYCLE : READONLY_KIND_CYCLE;
     const basePath = normalizeNarutoPath(input.leaseBasePath || '.sneakoscope/naruto/patch-envelopes');
     const targetPaths = normalizePaths(input.targetPaths || []);

package/dist/core/release/release-gate-cache-v2.js

@@ -19,14 +19,59 @@ export function releaseGateCacheKey(root, gate) {
     hashFileIfPresent(hash, path.join(root, 'package.json'));
     hashFileIfPresent(hash, path.join(root, 'dist', 'build-manifest.json'));
     for (const input of gate.cache.inputs) {
-        const file = path.join(root, input);
-        if (fs.existsSync(file) && fs.statSync(file).isFile())
+        const expanded = expandGlob(root, input);
+        hash.update(`input:${input}`);
+        if (!expanded.length) {
+            hash.update(`missing_or_empty:${input}`);
+            continue;
+        }
+        for (const file of expanded) {
+            hash.update(path.relative(root, file));
             hashFileIfPresent(hash, file);
-        else
-            hash.update(input);
+        }
     }
     return hash.digest('hex');
 }
+export function expandGlob(root, input) {
+    const absolute = path.join(root, input);
+    if (!/[*!?[\]{}]/.test(input)) {
+        if (!fs.existsSync(absolute))
+            return [];
+        const stat = fs.statSync(absolute);
+        if (stat.isDirectory())
+            return hashDirectoryRecursive(absolute);
+        return stat.isFile() ? [absolute] : [];
+    }
+    if (input.endsWith('/**')) {
+        const dir = path.join(root, input.slice(0, -3));
+        return fs.existsSync(dir) && fs.statSync(dir).isDirectory() ? hashDirectoryRecursive(dir) : [];
+    }
+    const firstWildcard = input.search(/[*!?[\]{}]/);
+    const prefix = input.slice(0, firstWildcard);
+    const base = path.join(root, prefix.includes('/') ? prefix.slice(0, prefix.lastIndexOf('/')) : '');
+    if (!fs.existsSync(base))
+        return [];
+    const re = globToRegExp(input);
+    return hashDirectoryRecursive(base).filter((file) => re.test(path.relative(root, file)));
+}
+export function hashDirectoryRecursive(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    const out = [];
+    const stack = [dir];
+    while (stack.length) {
+        const current = stack.pop();
+        for (const name of fs.readdirSync(current).sort()) {
+            const file = path.join(current, name);
+            const stat = fs.statSync(file);
+            if (stat.isDirectory())
+                stack.push(file);
+            else if (stat.isFile())
+                out.push(file);
+        }
+    }
+    return out.sort();
+}
 export function readReleaseGateCacheHit(root, gate) {
     try {
         const parsed = JSON.parse(fs.readFileSync(releaseGateCacheFile(root), 'utf8'));
@@ -60,4 +105,13 @@ function hashFileIfPresent(hash, file) {
     if (fs.existsSync(file) && fs.statSync(file).isFile())
         hash.update(fs.readFileSync(file));
 }
+function globToRegExp(input) {
+    const escaped = input
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '\u0000')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/\u0000/g, '.*');
+    return new RegExp(`^${escaped}$`);
+}
 //# sourceMappingURL=release-gate-cache-v2.js.map

package/dist/core/release/release-gate-dag.js

@@ -35,6 +35,39 @@ export async function runReleaseGateDag(input) {
     let cached = 0;
     let sumGateMs = 0;
     let peakRunning = 0;
+    const writeSummarySnapshot = (finished = false) => {
+        const wallMs = Date.now() - started;
+        const failures = [...failed.values()].map((row) => ({ id: row.id, exit_code: row.exit_code, stderr_tail: row.stderr_tail }));
+        const snapshot = {
+            schema: 'sks.release-gate-dag-run.v1',
+            ok: failures.length === 0,
+            run_id: runId,
+            selected_preset: preset,
+            total_gates: manifest.gates.length,
+            selected_gates: selected.length,
+            completed: completed.size,
+            failed: failed.size,
+            cached,
+            wall_ms: wallMs,
+            sum_gate_ms: sumGateMs,
+            cpu_time_saved_ms: Math.max(0, sumGateMs - wallMs),
+            parallelism_gain: wallMs > 0 ? Number((sumGateMs / wallMs).toFixed(2)) : 1,
+            critical_path_ms: estimateCriticalPath(selected, completed),
+            peak_running: peakRunning,
+            peak_resources: peakResources,
+            budget_snapshot: budget,
+            budget_summary: summarizeReleaseGateBudget(budget),
+            report_dir: reportDir,
+            failures
+        };
+        if (!finished) {
+            snapshot.in_progress = true;
+            snapshot.pending = pending.size;
+            snapshot.running = running.size;
+        }
+        writeReleaseGateJson(path.join(reportDir, 'summary.json'), snapshot);
+        return snapshot;
+    };
     if (input.explain) {
         writeReleaseGateJson(path.join(reportDir, 'explain.json'), { schema: RELEASE_GATE_NODE_SCHEMA, preset, budget, gates: selected.map((gate) => ({ id: gate.id, deps: gate.deps, resource: gate.resource, command: gate.command })) });
     }
@@ -51,6 +84,7 @@ export async function runReleaseGateDag(input) {
                 cached += 1;
                 progressed = true;
                 appendReleaseGateJsonl(timeline, { event: 'cache_hit', gate_id: gate.id, at: new Date().toISOString() });
+                writeSummarySnapshot(false);
                 continue;
             }
             appendReleaseGateJsonl(timeline, { event: 'start', gate_id: gate.id, resource: gate.resource, at: new Date().toISOString() });
@@ -102,32 +136,9 @@ export async function runReleaseGateDag(input) {
             }
         }
         appendReleaseGateJsonl(timeline, { event: result.ok ? 'pass' : 'fail', gate_id: result.id, duration_ms: result.duration_ms, at: new Date().toISOString() });
+        writeSummarySnapshot(false);
     }
-    const wallMs = Date.now() - started;
-    const failures = [...failed.values()].map((row) => ({ id: row.id, exit_code: row.exit_code, stderr_tail: row.stderr_tail }));
-    const result = {
-        schema: 'sks.release-gate-dag-run.v1',
-        ok: failures.length === 0,
-        run_id: runId,
-        selected_preset: preset,
-        total_gates: manifest.gates.length,
-        selected_gates: selected.length,
-        completed: completed.size,
-        failed: failed.size,
-        cached,
-        wall_ms: wallMs,
-        sum_gate_ms: sumGateMs,
-        cpu_time_saved_ms: Math.max(0, sumGateMs - wallMs),
-        parallelism_gain: wallMs > 0 ? Number((sumGateMs / wallMs).toFixed(2)) : 1,
-        critical_path_ms: estimateCriticalPath(selected, completed),
-        peak_running: peakRunning,
-        peak_resources: peakResources,
-        budget_snapshot: budget,
-        budget_summary: summarizeReleaseGateBudget(budget),
-        report_dir: reportDir,
-        failures
-    };
-    writeReleaseGateJson(path.join(reportDir, 'summary.json'), result);
+    const result = writeSummarySnapshot(true);
     return result;
 }
 function selectPreset(manifest, preset) {

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '2.0.8';
+export const PACKAGE_VERSION = '2.0.9';
 //# sourceMappingURL=version.js.map

package/dist/core/zellij/zellij-dashboard-renderer.js

@@ -6,6 +6,10 @@ export function buildZellijDashboardSnapshot(input) {
         generated_at: nowIso(),
         mission_id: input.mission_id,
         mode: input.mode || 'naruto',
+        route: input.route || input.mode || '$Naruto',
+        provider: input.provider || 'unknown',
+        service_tier: input.service_tier || 'fast',
+        backpressure: input.backpressure || 'normal',
         backend_counts: input.backend_counts || { 'codex-sdk': 1 },
         placement_counts: input.placement_counts || { 'zellij-pane': 1 },
         active_workers: Number(input.active_workers || 0),
@@ -16,6 +20,15 @@ export function buildZellijDashboardSnapshot(input) {
         local_llm: input.local_llm || { tps: 0, queue: 0 },
         gpt_final_status: input.gpt_final_status || 'not_started',
         gate_progress: input.gate_progress || 'not_release',
+        patch_verify: input.patch_verify || {
+            patches: 0,
+            gpt_approved: 0,
+            conflicts: 0,
+            verification_running: 0,
+            verification_passed: 0,
+            verification_failed: 0
+        },
+        workers: input.workers || [],
         latest_blockers: input.latest_blockers || []
     };
 }
@@ -25,18 +38,21 @@ export function renderZellijDashboardText(snapshot) {
     return [
         'SKS Dashboard',
         `Mission: ${snapshot.mission_id}`,
-        `Mode: ${snapshot.mode}`,
+        `Route / mode: ${snapshot.route} / ${snapshot.mode} / ${snapshot.service_tier}`,
+        `Provider: ${snapshot.provider}`,
         `Backend counts: ${backendCounts || 'none'}`,
         `Placement counts: ${placementCounts || 'none'}`,
-        `Active workers: ${snapshot.active_workers}`,
-        `Visible panes: ${snapshot.visible_panes}`,
-        `Headless workers: ${snapshot.headless_workers}`,
-        `Queue depth: ${snapshot.queue_depth}`,
+        `Active / visible / headless / queued: ${snapshot.active_workers}/${snapshot.visible_panes}/${snapshot.headless_workers}/${snapshot.queue_depth}`,
+        `Backpressure: ${snapshot.backpressure}`,
         `Worktrees active/completed/retained: ${snapshot.worktrees.active}/${snapshot.worktrees.completed}/${snapshot.worktrees.retained}`,
         `Local LLM TPS / queue: ${snapshot.local_llm.tps}/${snapshot.local_llm.queue}`,
         `GPT final status: ${snapshot.gpt_final_status}`,
         `Gate progress: ${snapshot.gate_progress}`,
-        `Latest blockers: ${snapshot.latest_blockers.length ? snapshot.latest_blockers.join(', ') : 'none'}`
+        `Patch / verify: patches ${snapshot.patch_verify.patches} · approved ${snapshot.patch_verify.gpt_approved} · conflicts ${snapshot.patch_verify.conflicts} · verify ${snapshot.patch_verify.verification_running}/${snapshot.patch_verify.verification_passed}/${snapshot.patch_verify.verification_failed}`,
+        'Workers:',
+        ...(snapshot.workers.length ? snapshot.workers.slice(0, 12).map((worker) => `${worker.slot_id} gen-${worker.generation_index} ${worker.role} ${worker.backend}/${worker.provider}/${worker.service_tier} WT:${worker.worktree_id || '-'} ${worker.status} ${worker.current_file || ''} ${worker.latest_heartbeat || ''}`) : ['none']),
+        `Latest blockers: ${snapshot.latest_blockers.length ? snapshot.latest_blockers.join(', ') : 'none'}`,
+        'Controls: q detach | /stop selected | /focus slot | /logs'
     ].join('\n');
 }
 //# sourceMappingURL=zellij-dashboard-renderer.js.map

package/dist/core/zellij/zellij-launcher.js

@@ -19,7 +19,7 @@ export async function launchZellijLayout(opts = {}) {
         ledgerRoot,
         cwd: opts.cwd || root,
         kind: opts.kind || 'agent',
-        slotCount: opts.slotCount || 1,
+        slotCount: opts.slotCount ?? 1,
         title: `SKS ${opts.kind || 'agent'} ${missionId}`,
         codexArgs: opts.codexArgs || [],
         launchEnv: opts.launchEnv || {}
@@ -124,7 +124,7 @@ export async function launchMadZellijUi(args = [], opts = {}) {
     const launchOpts = {
         ...opts,
         kind: 'mad',
-        slotCount: opts.slotCount || 1
+        slotCount: opts.slotCount ?? 1
     };
     const resolvedSession = session || opts.session;
     if (resolvedSession)
@@ -135,7 +135,7 @@ export async function launchTeamZellijView(opts = {}) {
     return launchZellijLayout({
         ...opts,
         kind: 'team',
-        slotCount: opts.slotCount || 5
+        slotCount: opts.slotCount ?? 5
     });
 }
 /**