sneakoscope 2.0.9 → 2.0.10

package/dist/core/agents/native-cli-session-swarm.js

@@ -5,8 +5,10 @@ import { appendJsonl, ensureDir, exists, nowIso, packageRoot, readJson, writeJso
 import { fastModeEnv } from './fast-mode-policy.js';
 import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
 import { closeWorkerPane, openWorkerPane } from '../zellij/zellij-worker-pane-manager.js';
-import { recordHeadlessWorkerInRightColumn } from '../zellij/zellij-right-column-manager.js';
+import { closeWorkerInRightColumn, recordHeadlessWorkerInRightColumn } from '../zellij/zellij-right-column-manager.js';
 import { resolveProviderContext } from '../provider/provider-context.js';
+import { buildZellijSlotPaneCommand } from '../zellij/zellij-slot-pane-renderer.js';
+import { resolveZellijUiMode } from '../zellij/zellij-ui-mode.js';
 export const NATIVE_CLI_SESSION_SWARM_SCHEMA = 'sks.agent-native-cli-session-swarm.v1';
 export function createNativeCliSessionSwarmRecorder(root, input) {
     return new NativeCliSessionSwarmRecorder(root, input);
@@ -19,6 +21,7 @@ class NativeCliSessionSwarmRecorder {
     maxObserved = 0;
     writeLock = Promise.resolve();
     nextPaneToken = -1;
+    visibleZellijReservations = new Set();
     constructor(root, input) {
         this.root = root;
         this.input = input;
@@ -103,10 +106,12 @@ class NativeCliSessionSwarmRecorder {
         const stdout = fs.createWriteStream(path.join(this.root, stdoutRel), { flags: 'a' });
         const stderr = fs.createWriteStream(path.join(this.root, stderrRel), { flags: 'a' });
         const placement = String(ctx.opts.workerPlacement || this.input.workerPlacement || (this.input.backend === 'zellij' ? 'zellij-pane' : 'process'));
-        const useZellijPane = placement === 'zellij-pane'
+        const zellijReservation = placement === 'zellij-pane'
             && ctx.opts.zellijPaneWorker !== false
             && (ctx.opts.zellijSessionName || this.input.missionId)
-            && this.visibleZellijPaneCount() < this.zellijVisiblePaneCap(ctx.opts);
+            ? this.reserveVisibleZellijPane(ctx.opts, String(ctx.agent.session_id || ctx.agent.id || `${Date.now()}:${Math.random()}`))
+            : null;
+        const useZellijPane = Boolean(zellijReservation);
         if (useZellijPane) {
             stdout.end();
             stderr.end();
@@ -118,7 +123,8 @@ class NativeCliSessionSwarmRecorder {
                 stdoutRel,
                 stderrRel,
                 heartbeatRel,
-                workerDirRel
+                workerDirRel,
+                zellijReservation
             });
         }
         if (placement === 'zellij-pane' && ctx.opts.zellijPaneWorker !== false && !useZellijPane) {
@@ -174,6 +180,17 @@ class NativeCliSessionSwarmRecorder {
         record.exit_code = exit.code;
         record.signal = exit.signal;
         record.status = exit.code === 0 ? 'closed' : 'failed';
+        if (record.worker_placement === 'headless') {
+            await closeWorkerInRightColumn({
+                root: this.root,
+                projectRoot: ctx.opts.projectRoot || this.input.projectRoot || ctx.opts.cwd,
+                missionId: this.input.missionId,
+                slotId: String(ctx.agent.slot_id || ctx.agent.id || 'slot-001'),
+                generationIndex: Number(ctx.agent.generation_index || 1),
+                paneId: null,
+                status: record.status === 'closed' ? 'closed' : 'failed'
+            }).catch(() => null);
+        }
         const parsed = await readJson(path.join(this.root, resultRel), null).catch(() => null);
         if (!parsed) {
             record.blockers = ['native_cli_worker_result_missing'];
@@ -217,77 +234,102 @@ class NativeCliSessionSwarmRecorder {
             route: this.input.route,
             serviceTier: this.input.fastModePolicy.service_tier
         });
-        const workerCommand = buildPaneWorkerCommand({
-            args: input.args,
-            stdoutPath: path.join(this.root, input.stdoutRel),
-            stderrPath: path.join(this.root, input.stderrRel),
-            heartbeatPath: path.join(this.root, input.heartbeatRel),
-            header: buildPaneWorkerHeader({
+        const uiMode = resolveZellijUiMode(Array.isArray(input.ctx.opts.args) ? input.ctx.opts.args : [], process.env);
+        const workerEnv = {
+            ...(input.ctx.opts.env || {}),
+            ...fastModeEnv(this.input.fastModePolicy),
+            SKS_AGENT_WORKER: '1',
+            SKS_PIPELINE_MODE: 'agent-worker',
+            SKS_DISABLE_ROUTE_RECURSION: '1',
+            SKS_PARENT_MISSION_ID: this.input.missionId,
+            SKS_AGENT_SESSION_ID: String(input.ctx.agent.session_id || ''),
+            SKS_AGENT_SLOT_ID: slotId,
+            SKS_AGENT_GENERATION_INDEX: String(input.ctx.agent.generation_index || 1),
+            ...(input.ctx.opts.ollamaModel ? { SKS_OLLAMA_MODEL: String(input.ctx.opts.ollamaModel) } : {}),
+            ...(input.ctx.opts.ollamaBaseUrl ? { SKS_OLLAMA_BASE_URL: String(input.ctx.opts.ollamaBaseUrl) } : {}),
+            SKS_ZELLIJ_SESSION_NAME: sessionName
+        };
+        const role = String(input.ctx.agent.naruto_role || input.ctx.agent.role || input.ctx.agent.persona_id || 'worker');
+        const workerCommand = uiMode === 'full-debug'
+            ? buildPaneWorkerCommand({
+                args: input.args,
+                stdoutPath: path.join(this.root, input.stdoutRel),
+                stderrPath: path.join(this.root, input.stderrRel),
+                heartbeatPath: path.join(this.root, input.heartbeatRel),
+                header: buildPaneWorkerHeader({
+                    slotId,
+                    generationIndex: Number(input.ctx.agent.generation_index || 1),
+                    role,
+                    backend: this.input.backend,
+                    provider: providerContext.provider,
+                    serviceTier: this.input.fastModePolicy.service_tier,
+                    worktree,
+                    task: input.ctx.slice?.description || input.ctx.slice?.title || input.ctx.slice?.id || ''
+                }),
+                env: {
+                    ...workerEnv,
+                    SKS_ZELLIJ_WORKER_PANE: '1'
+                }
+            })
+            : buildZellijSlotPaneCommand({
+                cliPath: String(input.args[0] || ''),
+                missionId: this.input.missionId,
                 slotId,
                 generationIndex: Number(input.ctx.agent.generation_index || 1),
-                role: input.ctx.agent.naruto_role || input.ctx.agent.role || input.ctx.agent.persona_id || 'worker',
+                artifactDir: path.join(this.root, input.workerDirRel),
                 backend: this.input.backend,
-                provider: providerContext.provider,
+                role,
+                mode: uiMode,
+                watch: true
+            });
+        let paneRecord;
+        try {
+            paneRecord = await openWorkerPane({
+                root: this.root,
+                missionId: this.input.missionId,
+                sessionName,
+                slotId,
+                generationIndex: Number(input.ctx.agent.generation_index || 1),
+                sessionId: String(input.ctx.agent.session_id || ''),
+                workerArtifactDir: input.workerDirRel,
+                workerCommand,
+                resultPath: input.resultRel,
+                heartbeatPath: input.heartbeatRel,
+                patchEnvelopePath: input.record.patch_envelope_path,
+                stdoutLog: input.stdoutRel,
+                stderrLog: input.stderrRel,
+                cwd: workerCwd,
+                providerContext,
                 serviceTier: this.input.fastModePolicy.service_tier,
-                worktree,
-                task: input.ctx.slice?.description || input.ctx.slice?.title || input.ctx.slice?.id || ''
-            }),
-            env: {
-                ...(input.ctx.opts.env || {}),
-                ...fastModeEnv(this.input.fastModePolicy),
-                SKS_AGENT_WORKER: '1',
-                SKS_PIPELINE_MODE: 'agent-worker',
-                SKS_DISABLE_ROUTE_RECURSION: '1',
-                SKS_PARENT_MISSION_ID: this.input.missionId,
-                SKS_AGENT_SESSION_ID: String(input.ctx.agent.session_id || ''),
-                SKS_AGENT_SLOT_ID: slotId,
-                SKS_AGENT_GENERATION_INDEX: String(input.ctx.agent.generation_index || 1),
-                ...(input.ctx.opts.ollamaModel ? { SKS_OLLAMA_MODEL: String(input.ctx.opts.ollamaModel) } : {}),
-                ...(input.ctx.opts.ollamaBaseUrl ? { SKS_OLLAMA_BASE_URL: String(input.ctx.opts.ollamaBaseUrl) } : {}),
-                SKS_ZELLIJ_WORKER_PANE: '1',
-                SKS_ZELLIJ_SESSION_NAME: sessionName
-            }
-        });
-        let paneRecord = await openWorkerPane({
-            root: this.root,
-            missionId: this.input.missionId,
-            sessionName,
-            slotId,
-            generationIndex: Number(input.ctx.agent.generation_index || 1),
-            sessionId: String(input.ctx.agent.session_id || ''),
-            workerArtifactDir: input.workerDirRel,
-            workerCommand,
-            resultPath: input.resultRel,
-            heartbeatPath: input.heartbeatRel,
-            patchEnvelopePath: input.record.patch_envelope_path,
-            stdoutLog: input.stdoutRel,
-            stderrLog: input.stderrRel,
-            cwd: workerCwd,
-            providerContext,
-            serviceTier: this.input.fastModePolicy.service_tier,
-            worktree: worktree ? { id: worktree.id, path: worktree.path, branch: worktree.branch } : null,
-            backend: this.input.backend,
-            projectRoot: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd,
-            rightColumnMode: 'spawn-on-first-worker',
-            visiblePaneCap: this.zellijVisiblePaneCap(input.ctx.opts),
-            dashboardSnapshot: {
-                mode: this.input.route || '$Agent',
-                backend_counts: { [this.input.backend]: this.input.targetActiveSlots },
-                placement_counts: {
-                    'zellij-pane': this.zellijVisiblePaneCap(input.ctx.opts),
-                    headless: Math.max(0, this.input.targetActiveSlots - this.zellijVisiblePaneCap(input.ctx.opts))
-                },
-                active_workers: this.input.targetActiveSlots,
-                visible_panes: this.zellijVisiblePaneCap(input.ctx.opts),
-                headless_workers: Math.max(0, this.input.targetActiveSlots - this.zellijVisiblePaneCap(input.ctx.opts)),
-                queue_depth: Math.max(0, this.input.requestedAgents - this.input.targetActiveSlots),
-                local_llm: { tps: 0, queue: 0 },
-                gpt_final_status: 'pending',
-                gate_progress: 'worker-spawn'
-            }
-        });
+                worktree: worktree ? { id: worktree.id, path: worktree.path, branch: worktree.branch } : null,
+                backend: this.input.backend,
+                uiMode,
+                projectRoot: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd,
+                rightColumnMode: 'spawn-on-first-worker',
+                visiblePaneCap: this.zellijVisiblePaneCap(input.ctx.opts),
+                dashboardSnapshot: {
+                    mode: this.input.route || '$Agent',
+                    backend_counts: { [this.input.backend]: this.input.targetActiveSlots },
+                    placement_counts: {
+                        'zellij-pane': this.zellijVisiblePaneCap(input.ctx.opts),
+                        headless: Math.max(0, this.input.targetActiveSlots - this.zellijVisiblePaneCap(input.ctx.opts))
+                    },
+                    active_workers: this.input.targetActiveSlots,
+                    visible_panes: this.zellijVisiblePaneCap(input.ctx.opts),
+                    headless_workers: Math.max(0, this.input.targetActiveSlots - this.zellijVisiblePaneCap(input.ctx.opts)),
+                    queue_depth: Math.max(0, this.input.requestedAgents - this.input.targetActiveSlots),
+                    local_llm: { tps: 0, queue: 0 },
+                    gpt_final_status: 'pending',
+                    gate_progress: 'worker-spawn'
+                }
+            });
+        }
+        finally {
+            if (input.zellijReservation)
+                this.releaseVisibleZellijReservation(input.zellijReservation);
+        }
         const launchBlockers = paneRecord.blockers || [];
-        input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', '<native-cli-worker-command>'];
+        input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', uiMode === 'full-debug' ? '<native-cli-worker-command>' : '<zellij-slot-pane-renderer-command>'];
         input.record.zellij_session_name = sessionName;
         input.record.zellij_pane_id = paneRecord.pane_id || null;
         input.record.zellij_pane_id_source = paneRecord.pane_id_source;
@@ -300,6 +342,8 @@ class NativeCliSessionSwarmRecorder {
         input.record.service_tier = paneRecord.service_tier;
         input.record.provider_context = paneRecord.provider_context;
         input.record.worktree = worktree;
+        input.record.zellij_ui_mode = uiMode;
+        input.record.slot_visualization = uiMode === 'full-debug' ? 'worker-command-pane' : 'zellij-slot-pane-renderer';
         input.record.status = launchBlockers.length ? 'failed' : 'running';
         input.record.blockers = launchBlockers;
         await this.record(input.record);
@@ -325,6 +369,20 @@ class NativeCliSessionSwarmRecorder {
                 goal_mode_ref: input.ctx.agent.goal_mode_ref || null
             });
         }
+        const processRun = uiMode === 'full-debug'
+            ? null
+            : await this.spawnCompactSlotWorkerProcess({
+                args: input.args,
+                cwd: workerCwd,
+                env: workerEnv,
+                stdoutRel: input.stdoutRel,
+                stderrRel: input.stderrRel
+            });
+        if (processRun?.pid) {
+            input.record.pid = processRun.pid;
+            input.record.process_id = processRun.pid;
+            await this.record(input.record);
+        }
         await waitForWorkerHeartbeat(path.join(this.root, input.heartbeatRel), Number(process.env.SKS_ZELLIJ_WORKER_HEARTBEAT_TIMEOUT_MS || 30000));
         await appendJsonl(path.join(this.root, input.workerDirRel, 'zellij-worker-pane-events.jsonl'), {
             schema: 'sks.zellij-worker-pane-event.v1',
@@ -337,6 +395,7 @@ class NativeCliSessionSwarmRecorder {
             worker_artifact_dir: input.workerDirRel
         });
         const parsed = await waitForWorkerResult(path.join(this.root, input.resultRel), Number(process.env.SKS_ZELLIJ_WORKER_RESULT_TIMEOUT_MS || 120000));
+        const compactExit = processRun ? await processRun.wait(parsed ? 10000 : 1000) : null;
         this.active.delete(activeToken);
         input.record.closed_at = nowIso();
         const workerProcessReport = await readJson(path.join(this.root, input.workerDirRel, 'worker-process-report.json'), null).catch(() => null);
@@ -368,8 +427,10 @@ class NativeCliSessionSwarmRecorder {
                 result_path: input.resultRel
             });
         }
-        input.record.pid = Number(workerProcessReport?.pid) || null;
+        input.record.pid = Number(workerProcessReport?.pid || processRun?.pid) || null;
         input.record.process_id = input.record.pid;
+        input.record.compact_worker_exit_code = compactExit?.code ?? null;
+        input.record.compact_worker_signal = compactExit?.signal ?? null;
         input.record.sdk_thread_id = sdkThreadId;
         input.record.sdk_run_id = sdkRunId;
         input.record.stream_event_count = Number(workerProcessReport?.stream_event_count || workerProcessReport?.backend_router_report?.stream_event_count || 0);
@@ -479,6 +540,46 @@ class NativeCliSessionSwarmRecorder {
     visibleZellijPaneCount() {
         return this.records.filter((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane' && (row.status === 'launching' || row.status === 'running')).length;
     }
+    reserveVisibleZellijPane(opts = {}, token) {
+        const cap = this.zellijVisiblePaneCap(opts);
+        if (this.visibleZellijPaneCount() + this.visibleZellijReservations.size >= cap)
+            return null;
+        this.visibleZellijReservations.add(token);
+        return token;
+    }
+    releaseVisibleZellijReservation(token) {
+        this.visibleZellijReservations.delete(token);
+    }
+    async spawnCompactSlotWorkerProcess(input) {
+        const stdout = fs.createWriteStream(path.join(this.root, input.stdoutRel), { flags: 'a' });
+        const stderr = fs.createWriteStream(path.join(this.root, input.stderrRel), { flags: 'a' });
+        const child = spawn(process.execPath, input.args, {
+            cwd: input.cwd,
+            env: {
+                ...process.env,
+                ...Object.fromEntries(Object.entries(input.env).filter(([, value]) => value != null).map(([key, value]) => [key, String(value)]))
+            },
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        child.stdout?.pipe(stdout);
+        child.stderr?.pipe(stderr);
+        const exitPromise = new Promise((resolve) => {
+            child.on('close', (code, signal) => {
+                stdout.end();
+                stderr.end();
+                resolve({ code, signal });
+            });
+            child.on('error', () => {
+                stdout.end();
+                stderr.end();
+                resolve({ code: 1, signal: null });
+            });
+        });
+        return {
+            pid: child.pid || null,
+            wait: async (timeoutMs) => waitForChildExit(child, exitPromise, timeoutMs)
+        };
+    }
 }
 export function buildPaneWorkerCommand(input) {
     const envPrefix = Object.entries(input.env)
@@ -555,4 +656,18 @@ function normalizeWorkerWorktree(value) {
         main_repo_root: value?.main_repo_root == null ? null : String(value.main_repo_root)
     };
 }
+async function waitForChildExit(child, exitPromise, timeoutMs) {
+    let timer = null;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            if (!child.killed)
+                child.kill();
+            resolve({ code: null, signal: 'SIGTERM' });
+        }, Math.max(1000, timeoutMs));
+    });
+    const result = await Promise.race([exitPromise, timeout]);
+    if (timer)
+        clearTimeout(timer);
+    return result;
+}
 //# sourceMappingURL=native-cli-session-swarm.js.map

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

@@ -11,6 +11,7 @@ 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, 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';
@@ -112,11 +113,29 @@ 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) => ({ 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() }),
+        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
     });
@@ -256,14 +275,20 @@ async function narutoRun(parsed) {
             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,
-                worker_lifecycle: realActivePool.worker_lifecycle
+                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;
@@ -280,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 : [];

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.9';
+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

@@ -29,7 +29,7 @@ export async function runNarutoRealActivePool(input) {
                 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 });
+            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 });
         }
@@ -40,7 +40,7 @@ export async function runNarutoRealActivePool(input) {
         }
         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)));
+        const done = await nextCollectableWorkers(active);
         if (!done.length)
             break;
         for (const handle of done) {
@@ -53,6 +53,8 @@ export async function runNarutoRealActivePool(input) {
             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) {
@@ -66,16 +68,32 @@ export async function runNarutoRealActivePool(input) {
     }
     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,
@@ -85,12 +103,27 @@ export async function runNarutoRealActivePool(input) {
         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 = [];

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);

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