sneakoscope 2.0.9 → 2.0.11

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

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { createMission, findLatestMission, loadMission } from '../mission.js';
-import { readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
+import { nowIso, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { classifyOllamaWorkerSlice } from '../agents/agent-runner-ollama.js';
 import { buildNarutoCloneRoster, systemSafeNarutoConcurrency } from '../agents/agent-roster.js';
@@ -11,6 +11,9 @@ 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 { allocateNarutoTasksToWorkers } from '../naruto/naruto-allocation-policy.js';
+import { rebalanceNarutoReadyWork } from '../naruto/naruto-rebalance-policy.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';
@@ -102,6 +105,50 @@ async function narutoRun(parsed) {
         worktreePolicy
     });
     const roleDistribution = buildNarutoRoleDistribution(workGraph.work_items, { readonly: parsed.readonly });
+    const allocationWorkers = buildNarutoAllocationWorkers(workGraph, roleDistribution, roster);
+    const allocationAssignments = allocateNarutoTasksToWorkers(workGraph.work_items, allocationWorkers);
+    const allocationPolicy = {
+        schema: 'sks.naruto-allocation-policy.v1',
+        generated_at: nowIso(),
+        ok: allocationWorkers.length > 0 && allocationAssignments.length === workGraph.work_items.length,
+        scoring_model: {
+            same_primary_role: 18,
+            declared_role: 12,
+            same_path_lane: 12,
+            overlap_each: 4,
+            assigned_task_penalty_each: -4,
+            write_conflict_penalty: -20,
+            dependency_incomplete: '-Infinity'
+        },
+        workers: allocationWorkers,
+        assignments: allocationAssignments.map((row) => ({
+            task_id: row.id,
+            owner: row.owner,
+            score: Number.isFinite(row.allocation_score) ? row.allocation_score : '-Infinity',
+            reason: row.allocation_reason,
+            role: row.required_role,
+            kind: row.kind,
+            paths: row.hints.paths,
+            domains: row.hints.domains,
+            write_paths: row.hints.writePaths
+        })),
+        blockers: allocationWorkers.length ? [] : ['naruto_allocation_workers_missing']
+    };
+    const rebalanceDecisions = rebalanceNarutoReadyWork({
+        tasks: workGraph.work_items.map((item) => ({ ...item, owner: null, status: 'pending' })),
+        workers: allocationWorkers.map((worker) => ({ ...worker, alive: true, state: 'idle' })),
+        completedTaskIds: [],
+        reclaimedTaskIds: []
+    });
+    const rebalancePolicy = {
+        schema: 'sks.naruto-rebalance-policy.v1',
+        generated_at: nowIso(),
+        ok: true,
+        trigger: 'idle_worker_ready_queue',
+        decisions: rebalanceDecisions,
+        blocked_by_dependency_count: workGraph.work_items.filter((item) => item.dependencies.length > 0).length,
+        blockers: []
+    };
     const governor = decideNarutoConcurrency({
         requestedClones: roster.agent_count,
         totalWorkItems: workGraph.total_work_items,
@@ -112,14 +159,52 @@ 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 realRuntimeSmokeGraph = buildNarutoWorkGraph({
+        prompt: parsed.prompt,
+        requestedClones: Math.min(2, roster.agent_count),
+        totalWorkItems: Math.min(2, workGraph.total_work_items),
+        readonly: true,
+        writeCapable: false,
+        leaseBasePath: patchEnvelopeBasePath,
+        maxActiveWorkers: Math.min(2, activeSlots),
+        worktreePolicy: {
+            mode: 'patch-envelope-only',
+            required: false,
+            main_repo_root: worktreePolicy.main_repo_root,
+            worktree_root: null,
+            fallback_reason: 'pre_run_smoke_never_owns_production_runtime'
+        }
+    });
+    const realRuntimeWorktreePolicy = {
+        mode: 'patch-envelope-only',
+        required: false,
+        main_repo_root: worktreePolicy.main_repo_root,
+        worktree_root: null,
+        fallback_reason: 'pre_run_smoke_never_owns_production_runtime'
+    };
     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() }),
+        graph: realRuntimeSmokeGraph,
+        governor: { ...governor, safe_active_workers: Math.min(2, activeSlots), safe_zellij_visible_panes: Math.min(1, zellijVisiblePanes) },
+        spawnWorker: async (item, placement) => spawnActualNarutoWorker({
+            root,
+            missionId: mission.id,
+            item,
+            placement,
+            backend: 'fake',
+            worktreePolicy: realRuntimeWorktreePolicy,
+            zellijSessionName: `sks-${mission.id}`,
+            visiblePaneCap: zellijVisiblePanes
+        }),
+        collectWorker: async (handle) => collectActualNarutoWorker(handle),
         enqueueVerification: async () => undefined,
         updateDashboard: async () => undefined
     });
+    const realActivePoolSmoke = {
+        ...realActivePool,
+        runtime_source_of_truth: 'pre_run_smoke_only',
+        production_runtime_source_of_truth: 'agent-orchestrator-scheduler',
+        smoke_graph_total_work_items: realRuntimeSmokeGraph.total_work_items
+    };
     const verificationDag = buildNarutoVerificationDag(workGraph, { cwd: root });
     const gptFinalPack = buildNarutoGptFinalPack({
         missionId: mission.id,
@@ -143,7 +228,9 @@ async function narutoRun(parsed) {
         roleDistribution,
         governor,
         activePool,
-        realActivePool,
+        realActivePool: realActivePoolSmoke,
+        allocationPolicy,
+        rebalancePolicy,
         verificationDag,
         gptFinalPack,
         zellijDashboard,
@@ -235,6 +322,8 @@ async function narutoRun(parsed) {
         max_clones: MAX_NARUTO_AGENT_COUNT,
         concurrency: result.target_active_slots ?? activeSlots,
         target_active_slots: result.target_active_slots ?? activeSlots,
+        runtime_source_of_truth: 'agent-orchestrator-scheduler',
+        pre_run_real_active_pool_source: 'smoke_only',
         concurrency_capped: clones > (result.target_active_slots ?? activeSlots),
         system: { cores: safe.cores, free_gb: safe.free_gb, safe_concurrency: safe.cap, heavy_backend: safe.heavy },
         work_graph: {
@@ -248,6 +337,8 @@ async function narutoRun(parsed) {
         },
         git_worktree: gitWorktreeCapability,
         role_distribution: roleDistribution,
+        allocation_policy: allocationPolicy,
+        rebalance_policy: rebalancePolicy,
         concurrency_governor: governor,
         active_pool: {
             ok: activePool.ok,
@@ -255,15 +346,23 @@ async function narutoRun(parsed) {
             refill_events: activePool.refill_events,
             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
+                ok: realActivePoolSmoke.ok,
+                runtime_source_of_truth: realActivePoolSmoke.runtime_source_of_truth,
+                production_runtime_source_of_truth: realActivePoolSmoke.production_runtime_source_of_truth,
+                active_cap: realActivePoolSmoke.active_cap,
+                max_observed_active_workers: realActivePoolSmoke.max_observed_active_workers,
+                average_active_workers: realActivePoolSmoke.average_active_workers,
+                active_pool_utilization: realActivePoolSmoke.active_pool_utilization,
+                refill_latency_ms_p95: realActivePoolSmoke.refill_latency_ms_p95,
+                visible_workers: realActivePoolSmoke.visible_workers,
+                headless_workers: realActivePoolSmoke.headless_workers,
+                worker_lifecycle_count: realActivePoolSmoke.worker_lifecycle.length,
+                worker_lifecycle_sample: realActivePoolSmoke.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 +379,57 @@ 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 buildNarutoAllocationWorkers(workGraph, roleDistribution, roster) {
+    const workItems = Array.isArray(workGraph?.work_items) ? workGraph.work_items : [];
+    const roleByWorkItem = new Map((roleDistribution?.work_item_roles || []).map((row) => [String(row.work_item_id), String(row.role || '')]));
+    const rosterRows = Array.isArray(roster?.roster) ? roster.roster : [];
+    const count = Math.max(1, Math.min(Number(roster?.agent_count || rosterRows.length || workItems.length || 1), Math.max(1, workItems.length || 1)));
+    return Array.from({ length: count }, (_unused, index) => {
+        const agent = rosterRows[index] || {};
+        const item = workItems[index % Math.max(1, workItems.length)] || {};
+        const role = String(agent.naruto_role || agent.role || roleByWorkItem.get(String(item.id || '')) || item.required_role || 'worker');
+        return {
+            id: String(agent.id || `clone-${String(index + 1).padStart(3, '0')}`),
+            role,
+            lane: narutoAllocationLane(item)
+        };
+    });
+}
+function narutoAllocationLane(item) {
+    const firstPath = String((item?.write_paths || item?.target_paths || item?.readonly_paths || [])[0] || '');
+    const parts = firstPath.replace(/\\/g, '/').split('/').filter(Boolean);
+    return parts.slice(0, Math.min(2, parts.length)).join('/') || null;
+}
 function summarizeNarutoLocalWorkerResult(localWorker, result) {
     const backendCounts = {};
     const rows = Array.isArray(result?.results) ? result.results : [];
@@ -443,6 +593,10 @@ async function writeNarutoArtifacts(ledgerRoot, artifacts) {
     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);
+    if (artifacts.allocationPolicy)
+        await writeJsonAtomic(path.join(ledgerRoot, 'naruto-allocation-policy.json'), artifacts.allocationPolicy);
+    if (artifacts.rebalancePolicy)
+        await writeJsonAtomic(path.join(ledgerRoot, 'naruto-rebalance-policy.json'), artifacts.rebalancePolicy);
     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.9';
+export const PACKAGE_VERSION = '2.0.11';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {