sneakoscope 2.0.11 → 2.0.12

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

@@ -94,7 +94,7 @@ async function narutoRun(parsed) {
     const localWorker = await resolveNarutoLocalWorkerMode(parsed);
     const schedulerBackend = localWorker.auto_select_eligible ? 'ollama' : parsed.backend;
     const safe = systemSafeNarutoConcurrency({ backend: schedulerBackend });
-    const workGraph = buildNarutoWorkGraph({
+    const baseWorkGraph = buildNarutoWorkGraph({
         prompt: parsed.prompt,
         requestedClones: roster.agent_count,
         totalWorkItems: parsed.workItems,
@@ -104,9 +104,21 @@ async function narutoRun(parsed) {
         maxActiveWorkers: parsed.concurrency || safe.cap,
         worktreePolicy
     });
+    const baseRoleDistribution = buildNarutoRoleDistribution(baseWorkGraph.work_items, { readonly: parsed.readonly });
+    const allocationWorkers = buildNarutoAllocationWorkers(baseWorkGraph, baseRoleDistribution, roster);
+    const allocationAssignments = allocateNarutoTasksToWorkers(baseWorkGraph.work_items, allocationWorkers);
+    const workGraph = buildNarutoWorkGraph({
+        prompt: parsed.prompt,
+        requestedClones: roster.agent_count,
+        totalWorkItems: parsed.workItems,
+        readonly: parsed.readonly,
+        writeCapable,
+        leaseBasePath: patchEnvelopeBasePath,
+        maxActiveWorkers: parsed.concurrency || safe.cap,
+        worktreePolicy,
+        allocationAssignments
+    });
     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(),
@@ -135,7 +147,7 @@ async function narutoRun(parsed) {
         blockers: allocationWorkers.length ? [] : ['naruto_allocation_workers_missing']
     };
     const rebalanceDecisions = rebalanceNarutoReadyWork({
-        tasks: workGraph.work_items.map((item) => ({ ...item, owner: null, status: 'pending' })),
+        tasks: workGraph.work_items.map((item) => ({ ...item, status: 'pending' })),
         workers: allocationWorkers.map((worker) => ({ ...worker, alive: true, state: 'idle' })),
         completedTaskIds: [],
         reclaimedTaskIds: []
@@ -159,52 +171,38 @@ 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: realRuntimeSmokeGraph,
-        governor: { ...governor, safe_active_workers: Math.min(2, activeSlots), safe_zellij_visible_panes: Math.min(1, zellijVisiblePanes) },
-        spawnWorker: async (item, placement) => spawnActualNarutoWorker({
+    const runPreRunSmoke = parsed.smoke === true || process.env.SKS_NARUTO_PRE_RUN_SMOKE === '1';
+    const realActivePoolSmoke = runPreRunSmoke
+        ? await runNarutoControlPlaneSmoke({
             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
-    };
+            prompt: parsed.prompt,
+            rosterCount: roster.agent_count,
+            totalWorkItems: workGraph.total_work_items,
+            patchEnvelopeBasePath,
+            worktreePolicy,
+            governor,
+            activeSlots,
+            zellijVisiblePanes
+        })
+        : {
+            schema: 'sks.naruto-active-pool.v1',
+            ok: true,
+            status: 'skipped',
+            runtime_source_of_truth: 'agent-orchestrator-scheduler',
+            production_runtime_source_of_truth: 'agent-orchestrator-scheduler',
+            fallback_reason: 'pre_run_smoke_never_owns_production_runtime',
+            reason: 'pre_run_smoke_disabled_for_production',
+            active_cap: 0,
+            max_observed_active_workers: 0,
+            average_active_workers: 0,
+            active_pool_utilization: 0,
+            refill_latency_ms_p95: 0,
+            visible_workers: 0,
+            headless_workers: 0,
+            worker_lifecycle: [],
+            smoke_graph_total_work_items: 0
+        };
     const verificationDag = buildNarutoVerificationDag(workGraph, { cwd: root });
     const gptFinalPack = buildNarutoGptFinalPack({
         missionId: mission.id,
@@ -284,7 +282,8 @@ async function narutoRun(parsed) {
         concurrency: activeSlots,
         targetActiveSlots: activeSlots,
         visualLaneCount: zellijVisiblePanes,
-        desiredWorkItemCount: parsed.workItems,
+        desiredWorkItemCount: workGraph.total_work_items,
+        minimumWorkItems: workGraph.total_work_items,
         maxAgentCount: MAX_NARUTO_AGENT_COUNT,
         narutoMode: true,
         clones: roster.agent_count,
@@ -307,6 +306,9 @@ async function narutoRun(parsed) {
         noFast: false,
         writeMode: writeCapable ? parsed.writeMode || 'parallel' : 'off',
         gitWorktreePolicy: worktreePolicy,
+        narutoWorkGraph: workGraph,
+        narutoAllocationPolicy: allocationPolicy,
+        narutoRebalancePolicy: rebalancePolicy,
         json: parsed.json
     });
     const clones = result.roster?.agent_count ?? roster.agent_count;
@@ -323,7 +325,7 @@ async function narutoRun(parsed) {
         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',
+        pre_run_real_active_pool_source: runPreRunSmoke ? 'smoke_only' : 'skipped',
         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: {
@@ -409,6 +411,56 @@ function compactNarutoRunResult(result) {
         }
     };
 }
+async function runNarutoControlPlaneSmoke(input) {
+    const smokeGraph = buildNarutoWorkGraph({
+        prompt: input.prompt,
+        requestedClones: Math.min(2, input.rosterCount),
+        totalWorkItems: Math.min(2, input.totalWorkItems),
+        readonly: true,
+        writeCapable: false,
+        leaseBasePath: input.patchEnvelopeBasePath,
+        maxActiveWorkers: Math.min(2, input.activeSlots),
+        worktreePolicy: {
+            mode: 'patch-envelope-only',
+            required: false,
+            main_repo_root: input.worktreePolicy.main_repo_root,
+            worktree_root: null,
+            fallback_reason: 'pre_run_smoke_never_owns_production_runtime'
+        }
+    });
+    const smokeWorktreePolicy = {
+        mode: 'patch-envelope-only',
+        required: false,
+        main_repo_root: input.worktreePolicy.main_repo_root,
+        worktree_root: null,
+        fallback_reason: 'pre_run_smoke_never_owns_production_runtime'
+    };
+    const realActivePool = await runNarutoRealActivePool({
+        graph: smokeGraph,
+        governor: { ...input.governor, safe_active_workers: Math.min(2, input.activeSlots), safe_zellij_visible_panes: Math.min(1, input.zellijVisiblePanes) },
+        spawnWorker: async (item, placement) => spawnActualNarutoWorker({
+            root: input.root,
+            missionId: input.missionId,
+            item,
+            placement,
+            backend: 'fake',
+            worktreePolicy: smokeWorktreePolicy,
+            zellijSessionName: `sks-${input.missionId}`,
+            visiblePaneCap: input.zellijVisiblePanes
+        }),
+        collectWorker: async (handle) => collectActualNarutoWorker(handle),
+        enqueueVerification: async () => undefined,
+        updateDashboard: async () => undefined
+    });
+    return {
+        ...realActivePool,
+        status: 'smoke_completed',
+        runtime_source_of_truth: 'pre_run_smoke_only',
+        production_runtime_source_of_truth: 'agent-orchestrator-scheduler',
+        fallback_reason: 'pre_run_smoke_never_owns_production_runtime',
+        smoke_graph_total_work_items: smokeGraph.total_work_items
+    };
+}
 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 || '')]));
@@ -582,9 +634,10 @@ function parseNarutoArgs(args = []) {
     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');
     const attach = hasFlag(args, '--attach');
+    const smoke = hasFlag(args, '--smoke');
     const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url']);
     const prompt = positionalArgs(rest, valueFlags).join(' ').trim() || 'Naruto shadow clone swarm run';
-    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach };
+    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach, smoke };
 }
 async function writeNarutoArtifacts(ledgerRoot, artifacts) {
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-work-graph.json'), artifacts.workGraph);

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.11';
+export const PACKAGE_VERSION = '2.0.12';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/git/git-worktree-merge-queue.js

@@ -54,14 +54,34 @@ export async function applyGitWorktreeMergeQueue(input) {
             input: diff.diff,
             timeoutMs: 30000
         });
-        if (apply.ok)
+        if (apply.ok) {
             appliedCount += 1;
+            strategyResults.push({
+                ok: true,
+                worker_id: diff.worker_id,
+                strategy: 'diff-apply-3way',
+                commit_hash: null,
+                conflict_files: [],
+                changed_files: diff.changed_files,
+                blockers: []
+            });
+        }
         else {
-            conflicts.push(summarizeGitWorktreeConflict({
+            const conflict = summarizeGitWorktreeConflict({
                 workerId: diff.worker_id,
                 changedFiles: diff.changed_files,
                 stderr: apply.stderr || apply.stdout
-            }));
+            });
+            strategyResults.push({
+                ok: false,
+                worker_id: diff.worker_id,
+                strategy: 'diff-apply-3way',
+                commit_hash: null,
+                conflict_files: conflict.conflict_files || diff.changed_files,
+                changed_files: diff.changed_files,
+                blockers: conflict.blockers || ['git_worktree_diff_apply_failed']
+            });
+            conflicts.push(conflict);
         }
     }
     const blockers = conflicts.length ? ['git_worktree_merge_queue_conflicts'] : [];
@@ -80,44 +100,44 @@ export async function applyGitWorktreeMergeQueue(input) {
     };
 }
 async function applyCheckpointCommit(integrationWorktreePath, checkpoint) {
-    const merge = await runGitCommand(integrationWorktreePath, ['merge', '--no-ff', '--no-edit', checkpoint.commit_hash || ''], {
+    const cherryPick = await runGitCommand(integrationWorktreePath, ['cherry-pick', '--allow-empty', '-X', 'theirs', checkpoint.commit_hash || ''], {
         timeoutMs: 120000
     });
-    if (merge.ok) {
+    if (cherryPick.ok) {
         return {
             ok: true,
             worker_id: checkpoint.worker_id,
-            strategy: 'merge',
+            strategy: 'checkpoint-cherry-pick',
             commit_hash: checkpoint.commit_hash,
             conflict_files: [],
             blockers: []
         };
     }
-    await runGitCommand(integrationWorktreePath, ['merge', '--abort'], { timeoutMs: 30000 }).catch(() => null);
-    const cherryPick = await runGitCommand(integrationWorktreePath, ['cherry-pick', checkpoint.commit_hash || ''], {
+    await runGitCommand(integrationWorktreePath, ['cherry-pick', '--abort'], { timeoutMs: 30000 }).catch(() => null);
+    const merge = await runGitCommand(integrationWorktreePath, ['merge', '--no-ff', '--no-edit', '-X', 'theirs', checkpoint.commit_hash || ''], {
         timeoutMs: 120000
     });
-    if (cherryPick.ok) {
+    if (merge.ok) {
         return {
             ok: true,
             worker_id: checkpoint.worker_id,
-            strategy: 'cherry-pick',
+            strategy: 'checkpoint-merge',
             commit_hash: checkpoint.commit_hash,
             conflict_files: [],
             blockers: []
         };
     }
     const conflictFiles = await runGitCommand(integrationWorktreePath, ['diff', '--name-only', '--diff-filter=U'], { timeoutMs: 30000 }).catch(() => null);
-    await runGitCommand(integrationWorktreePath, ['cherry-pick', '--abort'], { timeoutMs: 30000 }).catch(() => null);
+    await runGitCommand(integrationWorktreePath, ['merge', '--abort'], { timeoutMs: 30000 }).catch(() => null);
     return {
         ok: false,
         worker_id: checkpoint.worker_id,
-        strategy: 'merge_then_cherry-pick',
+        strategy: 'checkpoint-cherry-pick-then-merge',
         commit_hash: checkpoint.commit_hash,
         conflict_files: String(conflictFiles?.stdout || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean),
         blockers: [
-            `git_worktree_checkpoint_merge_failed:${merge.stderr_tail || merge.stdout_tail}`,
-            `git_worktree_checkpoint_cherry_pick_failed:${cherryPick.stderr_tail || cherryPick.stdout_tail}`
+            `git_worktree_checkpoint_cherry_pick_failed:${cherryPick.stderr_tail || cherryPick.stdout_tail}`,
+            `git_worktree_checkpoint_merge_failed:${merge.stderr_tail || merge.stdout_tail}`
         ]
     };
 }

package/dist/core/naruto/naruto-rebalance-policy.js

@@ -3,11 +3,14 @@ export function rebalanceNarutoReadyWork(input) {
     const completed = new Set((input.completedTaskIds || []).map(String));
     const reclaimed = new Set((input.reclaimedTaskIds || []).map(String));
     const idle = input.workers.filter((worker) => worker.alive && ['idle', 'done', 'unknown'].includes(worker.state));
+    const activeWorkerIds = new Set(input.workers.filter((worker) => worker.alive).map((worker) => worker.id));
+    const activeWritePaths = new Set([...(input.activeWritePaths || []), ...(input.currentAssignments || []).flatMap((row) => row.write_paths || [])].map(normalizePath));
     if (!idle.length)
         return [];
     const ready = input.tasks
-        .filter((task) => (task.status || 'pending') === 'pending' && !task.owner)
+        .filter((task) => (task.status || 'pending') === 'pending')
         .filter((task) => task.dependencies.every((dep) => completed.has(dep)))
+        .filter((task) => task.write_paths.every((file) => !activeWritePaths.has(normalizePath(file))))
         .sort((left, right) => {
         const reclaimedOrder = Number(!reclaimed.has(left.id)) - Number(!reclaimed.has(right.id));
         return reclaimedOrder || left.id.localeCompare(right.id);
@@ -15,12 +18,18 @@ export function rebalanceNarutoReadyWork(input) {
     const decisions = [];
     const assignments = [...(input.currentAssignments || [])];
     for (const task of ready) {
-        const decision = chooseNarutoTaskOwner(task, idle, assignments);
+        const requestedOwner = task.owner ? String(task.owner) : '';
+        const ownerActive = requestedOwner && activeWorkerIds.has(requestedOwner);
+        const ownerIdle = ownerActive ? idle.some((worker) => worker.id === requestedOwner) : false;
+        if (requestedOwner && ownerActive && !ownerIdle)
+            continue;
+        const candidateWorkers = ownerIdle ? idle.filter((worker) => worker.id === requestedOwner) : idle;
+        const decision = chooseNarutoTaskOwner({ ...task, owner: null }, candidateWorkers, assignments);
         decisions.push({
             type: 'assign',
             task_id: task.id,
             worker_id: decision.owner,
-            reason: `${reclaimed.has(task.id) ? 'reclaimed ready work' : 'idle worker pickup'}; ${decision.reason}`
+            reason: `${reclaimed.has(task.id) ? 'reclaimed ready work' : requestedOwner && !ownerActive ? `owner inactive:${requestedOwner}` : 'idle worker pickup'}; ${decision.reason}`
         });
         assignments.push({
             task_id: task.id,
@@ -33,4 +42,7 @@ export function rebalanceNarutoReadyWork(input) {
     }
     return decisions;
 }
+function normalizePath(file) {
+    return String(file || '').replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, '');
+}
 //# sourceMappingURL=naruto-rebalance-policy.js.map

package/dist/core/naruto/naruto-work-graph.js

@@ -42,6 +42,12 @@ export function buildNarutoWorkGraph(input = {}) {
         fallback_reason: writeCapable ? 'git_capability_not_evaluated' : 'readonly_or_write_disabled'
     };
     const workItems = [];
+    const assignmentById = new Map();
+    for (const row of input.allocationAssignments || []) {
+        const id = String(row.task_id || row.id || '');
+        if (id)
+            assignmentById.set(id, row);
+    }
     for (let index = 0; index < totalWorkItems; index += 1) {
         const id = `NW-${String(index + 1).padStart(6, '0')}`;
         const kind = kindCycle[index % kindCycle.length] || 'verification';
@@ -53,6 +59,8 @@ export function buildNarutoWorkGraph(input = {}) {
             ...writePaths.map((file) => ({ path: file, kind: 'write' })),
             ...readPaths.map((file) => ({ path: file, kind: 'read' }))
         ];
+        const assignment = assignmentById.get(id);
+        const allocationHints = assignment?.allocation_hints || assignment?.hints || null;
         workItems.push({
             id,
             kind,
@@ -73,6 +81,11 @@ export function buildNarutoWorkGraph(input = {}) {
                 requires_verification: kind !== 'research' && kind !== 'final_review_input_pack',
                 requires_gpt_final: writePaths.length > 0 || kind === 'final_review_input_pack'
             },
+            owner: assignment?.owner ?? null,
+            allocation_reason: assignment?.allocation_reason ?? null,
+            allocation_score: assignment?.allocation_score ?? null,
+            allocation_hints: allocationHints,
+            lane: assignment?.owner ?? null,
             ...(writePaths.length > 0 ? {
                 worktree: {
                     mode: worktreePolicy.mode,

package/dist/core/version.js

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

package/dist/core/zellij/zellij-slot-column-anchor.js

@@ -5,18 +5,32 @@ export function renderZellijSlotColumnAnchor(input = {}) {
     const visible = Math.max(1, nonNegativeInt(input.visiblePaneCap, active || 1));
     const headless = nonNegativeInt(input.headlessWorkers, 0);
     const queue = nonNegativeInt(input.queueDepth, 0);
-    return `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}`;
+    const header = `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}`;
+    const workers = Array.isArray(input.workerRows) ? input.workerRows : [];
+    if (!workers.length)
+        return header;
+    const maxRows = Math.max(1, nonNegativeInt(input.maxWorkerRows, input.mode === 'full-debug' ? 24 : 12));
+    const visibleRows = workers.slice(0, maxRows);
+    const hidden = Math.max(0, workers.length - visibleRows.length);
+    return [
+        header,
+        ...visibleRows.map((row, index) => renderWorkerRow(row, index + 1)),
+        ...(hidden ? [`+${hidden} more worker${hidden === 1 ? '' : 's'}`] : [])
+    ].join('\n');
 }
 export async function renderZellijSlotColumnAnchorFromArtifacts(input) {
     const root = path.resolve(input.artifactRoot);
     const missionDir = inferMissionDir(root, input.missionId);
     const snapshot = await readJson(path.join(missionDir, 'zellij-dashboard-snapshot.json'));
     const rightColumn = await readJson(path.join(missionDir, 'zellij-right-column-state.json'));
-    const activeWorkers = Number(snapshot?.active_workers ?? rightColumn?.visible_worker_panes?.filter((row) => row?.status === 'running' || row?.status === 'launching').length ?? 0);
+    const swarm = await readJson(path.join(root, 'agent-native-cli-session-swarm.json'))
+        || await readJson(path.join(missionDir, 'agents', 'agent-native-cli-session-swarm.json'));
+    const workerRows = await buildWorkerRows(root, missionDir, rightColumn, swarm);
+    const activeWorkers = Number(snapshot?.active_workers ?? workerRows.filter((row) => row.status === 'running' || row.status === 'launching').length ?? 0);
     const visiblePaneCap = Number(snapshot?.visible_panes ?? Math.max(1, rightColumn?.visible_worker_panes?.length || activeWorkers || 1));
-    const headlessWorkers = Number(snapshot?.headless_workers ?? rightColumn?.headless_workers?.filter((row) => !row?.status || row?.status === 'running').length ?? 0);
+    const headlessWorkers = Number(snapshot?.headless_workers ?? workerRows.filter((row) => row.placement === 'headless' && (!row.status || row.status === 'running')).length ?? 0);
     const queueDepth = Number(snapshot?.queue_depth ?? 0);
-    const anchorInput = { activeWorkers, visiblePaneCap, headlessWorkers, queueDepth };
+    const anchorInput = { activeWorkers, visiblePaneCap, headlessWorkers, queueDepth, workerRows };
     if (input.mode !== undefined)
         anchorInput.mode = input.mode;
     return renderZellijSlotColumnAnchor(anchorInput);
@@ -47,12 +61,157 @@ async function readJson(file) {
         return null;
     }
 }
+async function buildWorkerRows(root, missionDir, rightColumn, swarm) {
+    const byKey = new Map();
+    const records = Array.isArray(swarm?.records) ? swarm.records : [];
+    const recordByKey = new Map();
+    for (const record of records) {
+        const key = workerKey(record?.slot_id, record?.generation_index);
+        if (key)
+            recordByKey.set(key, record);
+    }
+    for (const pane of Array.isArray(rightColumn?.visible_worker_panes) ? rightColumn.visible_worker_panes : []) {
+        const key = workerKey(pane?.slot_id, pane?.generation_index);
+        if (!key)
+            continue;
+        const record = recordByKey.get(key);
+        byKey.set(key, await hydrateWorkerRow(root, missionDir, {
+            slotId: String(pane.slot_id),
+            generationIndex: Number(pane.generation_index || 1),
+            placement: 'zellij-pane',
+            status: pane.status || record?.status || 'running',
+            paneId: pane.pane_id || record?.zellij_pane_id || null,
+            yOrder: Number(pane.y_order || 0)
+        }, record));
+    }
+    for (const row of Array.isArray(rightColumn?.headless_workers) ? rightColumn.headless_workers : []) {
+        const key = workerKey(row?.slot_id, row?.generation_index);
+        if (!key)
+            continue;
+        const record = recordByKey.get(key);
+        byKey.set(key, await hydrateWorkerRow(root, missionDir, {
+            slotId: String(row.slot_id),
+            generationIndex: Number(row.generation_index || 1),
+            placement: 'headless',
+            status: row.status || record?.status || 'running',
+            reason: row.reason || record?.headless_reason || null,
+            yOrder: 9000
+        }, record));
+    }
+    for (const record of records) {
+        const key = workerKey(record?.slot_id, record?.generation_index);
+        if (!key || byKey.has(key))
+            continue;
+        byKey.set(key, await hydrateWorkerRow(root, missionDir, {
+            slotId: String(record.slot_id || record.agent_id || 'slot-?'),
+            generationIndex: Number(record.generation_index || 1),
+            placement: record.worker_placement || (record.zellij_pane_id ? 'zellij-pane' : 'process'),
+            status: record.status || 'running',
+            paneId: record.zellij_pane_id || null,
+            yOrder: 5000
+        }, record));
+    }
+    return [...byKey.values()].sort((a, b) => {
+        const statusDelta = statusWeight(a.status) - statusWeight(b.status);
+        if (statusDelta)
+            return statusDelta;
+        const yDelta = Number(a.yOrder || 0) - Number(b.yOrder || 0);
+        if (yDelta)
+            return yDelta;
+        return String(a.slotId).localeCompare(String(b.slotId));
+    });
+}
+async function hydrateWorkerRow(root, missionDir, base, record) {
+    const artifactDir = resolveArtifactDir(root, missionDir, record?.worker_artifact_dir);
+    const result = artifactDir ? await readJson(path.join(artifactDir, 'worker-result.json')) : null;
+    const intake = artifactDir ? await readJson(path.join(artifactDir, 'worker-intake.json')) : null;
+    const heartbeatPath = artifactDir ? path.join(artifactDir, 'worker-heartbeat.jsonl') : null;
+    return {
+        ...base,
+        status: result?.status || base.status || record?.status || 'running',
+        backend: result?.backend || record?.backend || intake?.backend || null,
+        role: result?.persona_id || intake?.agent?.naruto_role || intake?.agent?.role || intake?.agent?.persona_id || null,
+        task: firstText([
+            result?.summary,
+            Array.isArray(result?.changed_files) ? result.changed_files[0] : null,
+            intake?.slice?.description,
+            intake?.slice?.title,
+            intake?.slice?.id,
+            base.reason
+        ]),
+        worktreeId: result?.worktree?.id || record?.worktree?.id || intake?.worktree?.id || null,
+        heartbeatAgeMs: heartbeatPath ? await heartbeatAgeMs(heartbeatPath) : null
+    };
+}
+function renderWorkerRow(row, index) {
+    const slot = `${trimInline(row.slotId || 'slot-?', 12)} g${Math.max(1, Math.floor(Number(row.generationIndex) || 1))}`;
+    const status = trimInline(row.status || 'running', 9);
+    const backend = trimInline(row.backend || row.placement || '-', 12);
+    const worktree = trimInline(row.worktreeId || row.role || '-', 10);
+    const task = trimInline(row.task || row.reason || '-', 38);
+    return `${String(index).padStart(2, '0')} ${slot} ${status} ${backend} ${worktree} · ${task} · hb ${formatHeartbeat(row.heartbeatAgeMs)}`;
+}
+function resolveArtifactDir(root, missionDir, value) {
+    if (!value)
+        return null;
+    const text = String(value);
+    if (path.isAbsolute(text))
+        return text;
+    return path.join(root, text);
+}
+async function heartbeatAgeMs(file) {
+    try {
+        return Date.now() - (await fs.promises.stat(file)).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+function formatHeartbeat(ageMs) {
+    if (ageMs == null)
+        return '?';
+    if (ageMs < 1000)
+        return 'now';
+    return `${Math.max(1, Math.round(ageMs / 1000))}s`;
+}
+function firstText(values) {
+    for (const value of values) {
+        const text = String(value || '').replace(/\s+/g, ' ').trim();
+        if (text)
+            return text;
+    }
+    return null;
+}
+function workerKey(slotId, generationIndex) {
+    const slot = String(slotId || '').trim();
+    if (!slot)
+        return null;
+    return `${slot}:g${Math.max(1, Math.floor(Number(generationIndex) || 1))}`;
+}
+function statusWeight(status) {
+    const text = String(status || '').toLowerCase();
+    if (text === 'running' || text === 'launching')
+        return 0;
+    if (text === 'failed')
+        return 1;
+    if (text === 'draining')
+        return 2;
+    if (text === 'closed')
+        return 3;
+    return 4;
+}
 function nonNegativeInt(value, fallback) {
     const parsed = Number(value);
     if (!Number.isFinite(parsed) || parsed < 0)
         return fallback;
     return Math.floor(parsed);
 }
+function trimInline(value, max) {
+    const text = String(value || '').replace(/\s+/g, ' ').trim();
+    if (text.length <= max)
+        return text;
+    return text.slice(0, Math.max(1, max - 3)) + '...';
+}
 function shellQuote(value) {
     return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }