sneakoscope 2.0.7 → 2.0.9

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

@@ -5,6 +5,7 @@ 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 { resolveProviderContext } from '../provider/provider-context.js';
 export const NATIVE_CLI_SESSION_SWARM_SCHEMA = 'sks.agent-native-cli-session-swarm.v1';
 export function createNativeCliSessionSwarmRecorder(root, input) {
@@ -101,7 +102,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' });
-        if (this.input.backend === 'zellij' && ctx.opts.real === true && ctx.opts.zellijPaneWorker !== false) {
+        const placement = String(ctx.opts.workerPlacement || this.input.workerPlacement || (this.input.backend === 'zellij' ? 'zellij-pane' : 'process'));
+        const useZellijPane = placement === 'zellij-pane'
+            && ctx.opts.zellijPaneWorker !== false
+            && (ctx.opts.zellijSessionName || this.input.missionId)
+            && this.visibleZellijPaneCount() < this.zellijVisiblePaneCap(ctx.opts);
+        if (useZellijPane) {
             stdout.end();
             stderr.end();
             return this.launchWorkerInZellijPane({
@@ -115,6 +121,22 @@ class NativeCliSessionSwarmRecorder {
                 workerDirRel
             });
         }
+        if (placement === 'zellij-pane' && ctx.opts.zellijPaneWorker !== false && !useZellijPane) {
+            record.worker_placement = 'headless';
+            record.headless_reason = `visible_pane_cap:${this.zellijVisiblePaneCap(ctx.opts)}`;
+            await recordHeadlessWorkerInRightColumn({
+                root: this.root,
+                projectRoot: ctx.opts.projectRoot || this.input.projectRoot || ctx.opts.cwd,
+                missionId: this.input.missionId,
+                sessionName: String(ctx.opts.zellijSessionName || (this.input.missionId ? `sks-${this.input.missionId}` : 'sks-agent-runtime')),
+                slotId: String(ctx.agent.slot_id || ctx.agent.id || 'slot-001'),
+                generationIndex: Number(ctx.agent.generation_index || 1),
+                reason: record.headless_reason
+            }).catch(() => null);
+        }
+        else {
+            record.worker_placement = placement === 'zellij-pane' ? 'zellij-pane' : 'process';
+        }
         const child = spawn(process.execPath, args, {
             cwd: workerCwd,
             env: {
@@ -190,11 +212,26 @@ class NativeCliSessionSwarmRecorder {
         const activeToken = this.nextPaneToken--;
         this.active.add(activeToken);
         this.maxObserved = Math.max(this.maxObserved, this.active.size);
+        const providerContext = await resolveProviderContext({
+            root: this.root,
+            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({
+                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',
+                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: {
                 ...(input.ctx.opts.env || {}),
                 ...fastModeEnv(this.input.fastModePolicy),
@@ -211,11 +248,6 @@ class NativeCliSessionSwarmRecorder {
                 SKS_ZELLIJ_SESSION_NAME: sessionName
             }
         });
-        const providerContext = await resolveProviderContext({
-            root: this.root,
-            route: this.input.route,
-            serviceTier: this.input.fastModePolicy.service_tier
-        });
         let paneRecord = await openWorkerPane({
             root: this.root,
             missionId: this.input.missionId,
@@ -233,7 +265,26 @@ class NativeCliSessionSwarmRecorder {
             cwd: workerCwd,
             providerContext,
             serviceTier: this.input.fastModePolicy.service_tier,
-            worktree: worktree ? { id: worktree.id, path: worktree.path, branch: worktree.branch } : null
+            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'
+            }
         });
         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>'];
@@ -334,6 +385,7 @@ class NativeCliSessionSwarmRecorder {
             root: this.root,
             paneRecord,
             cwd: workerCwd,
+            projectRoot: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd,
             status: input.record.status === 'closed' ? 'closed' : 'failed',
             blockers: input.record.blockers,
             sdkThreadId,
@@ -404,6 +456,8 @@ class NativeCliSessionSwarmRecorder {
             closed_worker_process_count: closed.length,
             max_observed_worker_process_count: this.maxObserved,
             active_worker_process_count: this.active.size,
+            visible_zellij_pane_cap: this.input.zellijVisiblePaneCap || null,
+            headless_overflow_worker_count: this.records.filter((row) => row.worker_placement === 'headless').length,
             unique_worker_session_count: new Set(this.records.map((row) => row.session_id).filter(Boolean)).size,
             unique_slot_count: new Set(this.records.map((row) => row.slot_id).filter(Boolean)).size,
             unique_generation_count: new Set(this.records.map((row) => `${row.slot_id}:${row.generation_index}`).filter(Boolean)).size,
@@ -418,17 +472,35 @@ class NativeCliSessionSwarmRecorder {
             blockers: this.records.flatMap((row) => row.blockers || [])
         };
     }
+    zellijVisiblePaneCap(opts = {}) {
+        const raw = Number(opts.zellijVisiblePaneCap || this.input.zellijVisiblePaneCap || this.input.targetActiveSlots || 1);
+        return Math.max(1, Math.floor(Number.isFinite(raw) ? raw : 1));
+    }
+    visibleZellijPaneCount() {
+        return this.records.filter((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane' && (row.status === 'launching' || row.status === 'running')).length;
+    }
 }
 export function buildPaneWorkerCommand(input) {
     const envPrefix = Object.entries(input.env)
         .filter(([key, value]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && value != null)
-        .map(([key, value]) => `${key}=${shellQuote(String(value))}`)
+        .map(([key, value]) => `export ${key}=${shellQuote(String(value))};`)
         .sort();
     const command = [shellQuote(process.execPath), ...input.args.map(shellQuote)].join(' ');
     const heartbeat = `printf '%s\\n' ${shellQuote(JSON.stringify({ schema: 'sks.zellij-worker-pane-event.v1', event: 'worker_command_exited' }))} >> ${shellQuote(input.heartbeatPath)}`;
     const holdMs = Math.max(0, Number(process.env.SKS_ZELLIJ_WORKER_PANE_HOLD_MS || 1500));
     const hold = holdMs > 0 ? `sleep ${shellQuote(String(Math.min(30, holdMs / 1000)))}` : ':';
-    return `${envPrefix.join(' ')} ${command} > ${shellQuote(input.stdoutPath)} 2> ${shellQuote(input.stderrPath)}; code=$?; ${heartbeat}; ${hold}; exit $code`.trim();
+    const header = input.header ? `printf '%s\\n' ${shellQuote(input.header)} | tee -a ${shellQuote(input.stdoutPath)};` : '';
+    return `${envPrefix.join(' ')} ${header} ${command} >> ${shellQuote(input.stdoutPath)} 2>> ${shellQuote(input.stderrPath)}; code=$?; ${heartbeat}; ${hold}; exit $code`.trim();
+}
+function buildPaneWorkerHeader(input) {
+    return [
+        'SKS Worker',
+        `slot: ${input.slotId} gen: ${input.generationIndex} role: ${input.role}`,
+        `backend: ${input.backend} provider: ${input.provider} service: ${input.serviceTier}`,
+        `worktree: ${input.worktree ? `${input.worktree.id} branch: ${input.worktree.branch}` : '-'}`,
+        `task: ${String(input.task || '').slice(0, 160)}`,
+        'status: running'
+    ].join('\n');
 }
 async function waitForWorkerResult(file, timeoutMs) {
     const deadline = Date.now() + Math.max(1000, timeoutMs);

package/dist/core/commands/mad-sks-command.js

@@ -113,12 +113,24 @@ export async function madHighCommand(args = [], deps = {}) {
         console.log(`MAD Zellij action: ${formatMadZellijAction(launch)}`);
         return launch;
     }
+    await writeJsonAtomic(path.join(madLaunch.dir, 'zellij-initial-ui.json'), {
+        schema: 'sks.zellij-initial-ui.v1',
+        ok: true,
+        mission_id: madLaunch.mission_id,
+        session_name: launch.session_name,
+        initial_panes: 'main-only',
+        dashboard_created: false,
+        worker_panes_created: 0,
+        right_column_mode: 'spawn-on-first-worker'
+    });
     const madNativeSwarm = await startMadNativeSwarm(madLaunch.root, madLaunch, args, profile, {
         env: {
             ...madSksEnv,
             SKS_ZELLIJ_SESSION_NAME: launch.session_name
         },
-        zellijSessionName: launch.session_name
+        zellijSessionName: launch.session_name,
+        workerPlacement: shouldAutoAttachZellij(args) ? 'zellij-pane' : 'process',
+        zellijVisiblePaneCap: Number(process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || 8)
     });
     // The launcher only creates a detached background session. In an interactive
     // terminal, immediately attach so the session actually opens for the user
@@ -193,6 +205,8 @@ export async function startMadNativeSwarm(root, madLaunch, args = [], profile =
         command.push('--real');
         command.push('--zellij-session-name', opts.zellijSessionName || `sks-${madLaunch.mission_id}`);
         command.push('--zellij-pane-worker');
+        command.push('--worker-placement', opts.workerPlacement || 'zellij-pane');
+        command.push('--zellij-visible-pane-cap', String(opts.zellijVisiblePaneCap || swarm.agents));
     }
     const baseReport = {
         schema: 'sks.mad-sks-native-swarm.v1',
@@ -209,6 +223,8 @@ export async function startMadNativeSwarm(root, madLaunch, args = [], profile =
         work_items: swarm.workItems,
         backend: swarm.backend,
         zellij_session_name: opts.zellijSessionName || null,
+        worker_placement: opts.workerPlacement || (swarm.backend === 'zellij' ? 'zellij-pane' : 'process'),
+        zellij_visible_pane_cap: opts.zellijVisiblePaneCap || null,
         readonly: true,
         command,
         stdout_log: path.relative(root, stdoutLog),

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

@@ -10,7 +10,7 @@ import { attachZellijSessionInteractive, launchZellijLayout } from '../zellij/ze
 import { buildNarutoWorkGraph } from '../naruto/naruto-work-graph.js';
 import { buildNarutoRoleDistribution } from '../naruto/naruto-role-policy.js';
 import { decideNarutoConcurrency } from '../naruto/naruto-concurrency-governor.js';
-import { runNarutoActivePool } from '../naruto/naruto-active-pool.js';
+import { runNarutoActivePool, runNarutoRealActivePool } from '../naruto/naruto-active-pool.js';
 import { buildNarutoVerificationDag } from '../naruto/naruto-verification-dag.js';
 import { buildNarutoGptFinalPack } from '../naruto/naruto-gpt-final-pack.js';
 import { planNarutoZellijDashboard } from '../zellij/zellij-naruto-dashboard.js';
@@ -30,6 +30,10 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
         return narutoHelp(parsed);
     if (parsed.action === 'status')
         return narutoStatus(parsed);
+    if (parsed.action === 'dashboard')
+        return narutoDashboard(parsed);
+    if (parsed.action === 'workers')
+        return narutoWorkers(parsed);
     return narutoRun(parsed);
 }
 async function narutoRun(parsed) {
@@ -108,6 +112,14 @@ async function narutoRun(parsed) {
     const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || Math.max(governor.safe_active_workers, backendMinimum), safe.cap));
     const zellijVisiblePanes = Math.max(1, Math.min(activeSlots, governor.safe_zellij_visible_panes));
     const activePool = await runNarutoActivePool({ graph: workGraph, governor: { ...governor, safe_active_workers: activeSlots } });
+    const realActivePool = await runNarutoRealActivePool({
+        graph: workGraph,
+        governor: { ...governor, safe_active_workers: activeSlots },
+        spawnWorker: async (item, placement) => ({ id: item.id, item, placement, started_at: Date.now() }),
+        collectWorker: async (handle) => ({ id: handle.id, ok: true, item: handle.item, placement: handle.placement, completed_at: Date.now() }),
+        enqueueVerification: async () => undefined,
+        updateDashboard: async () => undefined
+    });
     const verificationDag = buildNarutoVerificationDag(workGraph, { cwd: root });
     const gptFinalPack = buildNarutoGptFinalPack({
         missionId: mission.id,
@@ -131,6 +143,7 @@ async function narutoRun(parsed) {
         roleDistribution,
         governor,
         activePool,
+        realActivePool,
         verificationDag,
         gptFinalPack,
         zellijDashboard,
@@ -144,12 +157,25 @@ async function narutoRun(parsed) {
             missionId: mission.id,
             ledgerRoot,
             kind: 'naruto',
-            slotCount: zellijVisiblePanes,
+            slotCount: 0,
             dryRun: false,
             attach: false
         });
         if (liveZellij?.ok && liveZellij.capability?.status === 'ok') {
-            console.log('Zellij: prepared ' + zellijVisiblePanes + ' visible active clone lane(s) in ' + liveZellij.session_name + ' with ' + Math.max(0, activeSlots - zellijVisiblePanes) + ' headless active worker(s). Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
+            liveZellij.dashboard_pane = null;
+            liveZellij.right_column_mode = 'spawn-on-first-worker';
+            await writeJsonAtomic(path.join(mission.dir, 'zellij-initial-ui.json'), {
+                schema: 'sks.zellij-initial-ui.v1',
+                ok: true,
+                mission_id: mission.id,
+                session_name: liveZellij.session_name,
+                initial_panes: 'main-only',
+                dashboard_created: false,
+                worker_panes_created: 0,
+                right_column_mode: 'spawn-on-first-worker',
+                visible_pane_cap: zellijVisiblePanes
+            });
+            console.log('Zellij: started main-only session ' + liveZellij.session_name + '; right column opens on first visible worker spawn. Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
             if (parsed.attach)
                 attachZellijSessionInteractive(liveZellij.session_name, { cwd: process.cwd(), configPath: liveZellij.clipboard_config_path });
         }
@@ -184,6 +210,10 @@ async function narutoRun(parsed) {
         mock: parsed.mock,
         real: parsed.real,
         readonly: parsed.readonly,
+        zellijSessionName: liveZellij?.session_name || `sks-${mission.id}`,
+        workerPlacement: parsed.json || parsed.noOpenZellij ? 'process' : 'zellij-pane',
+        zellijPaneWorker: true,
+        zellijVisiblePaneCap: zellijVisiblePanes,
         // Shadow clones ALWAYS run in fast service tier — never honor --no-fast/standard.
         fastMode: true,
         serviceTier: 'fast',
@@ -223,7 +253,13 @@ async function narutoRun(parsed) {
             ok: activePool.ok,
             max_observed_active_workers: activePool.max_observed_active_workers,
             refill_events: activePool.refill_events,
-            completed_count: activePool.completed_count
+            completed_count: activePool.completed_count,
+            real_runtime: {
+                ok: realActivePool.ok,
+                max_observed_active_workers: realActivePool.max_observed_active_workers,
+                refill_latency_ms_p95: realActivePool.refill_latency_ms_p95,
+                worker_lifecycle: realActivePool.worker_lifecycle
+            }
         },
         local_worker: localWorkerSummary,
         proof: result.proof?.status || 'missing',
@@ -296,6 +332,57 @@ async function narutoStatus(parsed) {
             console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
     });
 }
+async function narutoDashboard(parsed) {
+    const root = await sksRoot();
+    const id = parsed.missionId && parsed.missionId !== 'latest' ? parsed.missionId : await findLatestMission(root);
+    if (!id)
+        return emit(parsed, { schema: NARUTO_RESULT_SCHEMA, ok: false, action: 'dashboard', status: 'missing_mission' }, () => console.log('No Naruto mission found.'));
+    const { dir } = await loadMission(root, id);
+    const snapshot = await readJson(path.join(dir, 'zellij-dashboard-snapshot.json'), null);
+    const rightColumnState = await readJson(path.join(dir, 'zellij-right-column-state.json'), null);
+    const summary = {
+        schema: NARUTO_RESULT_SCHEMA,
+        ok: Boolean(snapshot || rightColumnState),
+        action: 'dashboard',
+        mission_id: id,
+        snapshot,
+        right_column_state: rightColumnState,
+        blockers: snapshot || rightColumnState ? [] : ['naruto_dashboard_missing']
+    };
+    return emit(parsed, summary, () => {
+        console.log('🍥 Naruto dashboard: ' + id);
+        console.log('Right column: ' + (rightColumnState?.status || 'missing'));
+        if (snapshot)
+            console.log('Active/visible/headless/queue: ' + [snapshot.active_workers, snapshot.visible_panes, snapshot.headless_workers, snapshot.queue_depth].join('/'));
+    });
+}
+async function narutoWorkers(parsed) {
+    const root = await sksRoot();
+    const id = parsed.missionId && parsed.missionId !== 'latest' ? parsed.missionId : await findLatestMission(root);
+    if (!id)
+        return emit(parsed, { schema: NARUTO_RESULT_SCHEMA, ok: false, action: 'workers', status: 'missing_mission' }, () => console.log('No Naruto mission found.'));
+    const { dir } = await loadMission(root, id);
+    const swarm = await readJson(path.join(dir, 'agents', 'agent-native-cli-session-swarm.json'), null);
+    const state = await readJson(path.join(dir, 'zellij-right-column-state.json'), null);
+    const records = Array.isArray(swarm?.records) ? swarm.records : [];
+    const summary = {
+        schema: NARUTO_RESULT_SCHEMA,
+        ok: Boolean(swarm || state),
+        action: 'workers',
+        mission_id: id,
+        active: records.filter((row) => row.status === 'running' || row.status === 'launching').length,
+        completed: records.filter((row) => row.status === 'closed').length,
+        failed: records.filter((row) => row.status === 'failed').length,
+        visible_worker_panes: state?.visible_worker_panes || [],
+        headless_workers: state?.headless_workers || [],
+        records,
+        blockers: swarm || state ? [] : ['naruto_worker_records_missing']
+    };
+    return emit(parsed, summary, () => {
+        console.log('🍥 Naruto workers: ' + id);
+        console.log(`Active ${summary.active} · completed ${summary.completed} · failed ${summary.failed} · visible ${summary.visible_worker_panes.length} · headless ${summary.headless_workers.length}`);
+    });
+}
 async function narutoHelp(parsed) {
     const help = {
         schema: NARUTO_RESULT_SCHEMA,
@@ -320,13 +407,13 @@ function parseNarutoArgs(args = []) {
     if (hasFlag(args, '--help') || hasFlag(args, '-h'))
         args = ['help', ...args.filter((arg) => arg !== '--help' && arg !== '-h')];
     const first = args[0] && !String(args[0]).startsWith('--') ? String(args[0]) : '';
-    const actions = new Set(['run', 'status', 'help']);
+    const actions = new Set(['run', 'status', 'help', 'dashboard', 'workers']);
     const action = (actions.has(first) ? first : 'run');
     const rest = action === first ? args.slice(1) : args;
     const json = hasFlag(args, '--json');
     const requestedClones = Number(readOption(args, '--clones', readOption(args, '--agents', DEFAULT_NARUTO_CLONES)));
     const clones = clampClones(requestedClones);
-    const workItems = clampWorkItems(Number(readOption(args, '--work-items', clones)), clones);
+    const workItems = clampWorkItems(Number(readOption(args, '--work-items', clones * 2)), clones);
     const concurrency = normalizeConcurrency(readOption(args, '--concurrency', readOption(args, '--target-active-slots', null)), clones);
     const useOllama = hasFlag(args, '--ollama') || hasFlag(args, '--local-model');
     const noOllama = hasFlag(args, '--no-ollama') || hasFlag(args, '--no-local-model');
@@ -337,7 +424,10 @@ function parseNarutoArgs(args = []) {
     const readonly = hasFlag(args, '--readonly') || hasFlag(args, '--read-only');
     const writeModeRaw = String(readOption(args, '--write-mode', hasFlag(args, '--parallel-write') ? 'parallel' : '') || '');
     const writeMode = (['proof-safe', 'parallel', 'serial', 'off'].includes(writeModeRaw) ? writeModeRaw : null);
-    const missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', 'latest')));
+    const positionalMission = action === 'dashboard' || action === 'workers' || action === 'status'
+        ? positionalArgs(rest, new Set()).find((arg) => /^latest$|^M-/.test(arg))
+        : null;
+    const missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', positionalMission || 'latest')));
     const ollamaModel = String(readOption(args, '--ollama-model', readOption(args, '--local-model-model', '')) || '') || null;
     const ollamaBaseUrl = String(readOption(args, '--ollama-base-url', readOption(args, '--local-model-base-url', '')) || '') || null;
     const noOpenZellij = hasFlag(args, '--no-open-zellij') || hasFlag(args, '--no-zellij');
@@ -351,6 +441,8 @@ async function writeNarutoArtifacts(ledgerRoot, artifacts) {
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-role-distribution.json'), artifacts.roleDistribution);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-concurrency-governor.json'), artifacts.governor);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-active-pool.json'), artifacts.activePool);
+    if (artifacts.realActivePool)
+        await writeJsonAtomic(path.join(ledgerRoot, 'naruto-real-active-pool.json'), artifacts.realActivePool);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-verification-dag.json'), artifacts.verificationDag);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-gpt-final-pack.json'), artifacts.gptFinalPack);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-zellij-dashboard.json'), artifacts.zellijDashboard);

package/dist/core/fsx.js

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

package/dist/core/git/git-repo-detection.js

@@ -18,6 +18,7 @@ export async function detectGitRepo(root = process.cwd()) {
     const bare = await runGitCommand(cwd, ['rev-parse', '--is-bare-repository']);
     const branch = await runGitCommand(cwd, ['branch', '--show-current']);
     const head = await runGitCommand(cwd, ['rev-parse', 'HEAD']);
+    const status = await runGitCommand(cwd, ['status', '--porcelain=v1', '--untracked-files=all']);
     if (!top.ok)
         blockers.push(gitBlocker('git_root_unresolved', top));
     if (!gitDir.ok)
@@ -26,6 +27,8 @@ export async function detectGitRepo(root = process.cwd()) {
         blockers.push(gitBlocker('git_common_dir_unresolved', commonDir));
     if (!head.ok)
         blockers.push(gitBlocker('git_head_unresolved', head));
+    if (!status.ok)
+        blockers.push(gitBlocker('git_status_unresolved', status));
     const repoRoot = top.ok ? path.resolve(gitOutputLine(top)) : null;
     const resolvedGitDir = gitDir.ok ? absolutizeGitPath(cwd, gitOutputLine(gitDir)) : null;
     const resolvedCommonDir = commonDir.ok ? absolutizeGitPath(cwd, gitOutputLine(commonDir)) : null;
@@ -43,6 +46,8 @@ export async function detectGitRepo(root = process.cwd()) {
         worktree_git_dir: resolvedGitDir && resolvedCommonDir && resolvedGitDir !== resolvedCommonDir ? resolvedGitDir : null,
         branch: gitOutputLine(branch) || null,
         head: gitOutputLine(head) || null,
+        main_worktree_dirty: status.ok && status.stdout.trim().length > 0,
+        status_porcelain: status.stdout || '',
         blockers
     };
 }
@@ -61,6 +66,8 @@ function baseDetection(cwd, gitBinary, gitAvailable, blockers) {
         worktree_git_dir: null,
         branch: null,
         head: null,
+        main_worktree_dirty: false,
+        status_porcelain: '',
         blockers
     };
 }

package/dist/core/git/git-worktree-cleanup.js

@@ -7,6 +7,8 @@ export async function cleanupGitWorktree(input) {
     const status = await runGitCommand(worktreePath, ['status', '--porcelain=v1', '--untracked-files=all']);
     const clean = status.ok && status.stdout.trim().length === 0;
     if (!clean) {
+        const reason = `SKS retained dirty failed worker ${path.basename(worktreePath)}`;
+        const lock = await runGitCommand(repoRoot, ['worktree', 'lock', '--reason', reason, worktreePath]);
         const lockPath = `${worktreePath}.retained.json`;
         await writeJsonAtomic(lockPath, {
             schema: 'sks.git-worktree-retention-lock.v1',
@@ -15,7 +17,10 @@ export async function cleanupGitWorktree(input) {
             worktree_path: worktreePath,
             branch: input.branch || null,
             reason: status.ok ? 'dirty_worktree_retained' : 'status_failed_retained',
-            status_porcelain: status.stdout || null
+            status_porcelain: status.stdout || null,
+            git_locked: lock.ok,
+            unlock_command: `git worktree unlock ${JSON.stringify(worktreePath)}`,
+            cleanup_command: 'sks worktree cleanup --mission <id>'
         });
         return {
             schema: 'sks.git-worktree-cleanup.v1',
@@ -27,7 +32,10 @@ export async function cleanupGitWorktree(input) {
             clean: false,
             action: 'retained_dirty',
             retention_lock_path: lockPath,
-            blockers: []
+            blockers: lock.ok ? [] : ['git_worktree_lock_failed'],
+            git_locked: lock.ok,
+            unlock_command: `git worktree unlock ${JSON.stringify(worktreePath)}`,
+            cleanup_command: 'sks worktree cleanup --mission <id>'
         };
     }
     const remove = await runGitCommand(repoRoot, ['worktree', 'remove', worktreePath]);
@@ -45,7 +53,10 @@ export async function cleanupGitWorktree(input) {
         clean: true,
         action: remove.ok ? 'removed' : 'remove_failed',
         retention_lock_path: null,
-        blockers
+        blockers,
+        git_locked: false,
+        unlock_command: null,
+        cleanup_command: null
     };
 }
 //# sourceMappingURL=git-worktree-cleanup.js.map

package/dist/core/git/git-worktree-diff.js

@@ -7,14 +7,19 @@ export async function exportGitWorktreeDiff(input) {
     const branch = await runGitCommand(worktreePath, ['branch', '--show-current']);
     const head = await runGitCommand(worktreePath, ['rev-parse', 'HEAD']);
     const status = await runGitCommand(worktreePath, ['status', '--porcelain=v1', '--untracked-files=all']);
+    const untracked = await runGitCommand(worktreePath, ['ls-files', '--others', '--exclude-standard']);
+    const untrackedFiles = lines(untracked.stdout);
+    if (untrackedFiles.length) {
+        const addIntent = await runGitCommand(worktreePath, ['add', '-N', '--', ...untrackedFiles]);
+        if (!addIntent.ok)
+            blockers.push('git_worktree_untracked_intent_to_add_failed');
+    }
     const diff = await runGitCommand(worktreePath, ['diff', '--binary', '--full-index', 'HEAD']);
     const names = await runGitCommand(worktreePath, ['diff', '--name-only', 'HEAD']);
-    const untracked = await runGitCommand(worktreePath, ['ls-files', '--others', '--exclude-standard']);
     if (!status.ok)
         blockers.push('git_worktree_status_failed');
     if (!diff.ok)
         blockers.push('git_worktree_diff_failed');
-    const untrackedFiles = lines(untracked.stdout);
     const trackedChanged = lines(names.stdout);
     const changedFiles = [...new Set([...trackedChanged, ...untrackedFiles, ...statusFiles(status.stdout)])];
     return {

package/dist/core/git/git-worktree-manager.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import fsp from 'node:fs/promises';
-import { ensureDir, nowIso, writeJsonAtomic } from '../fsx.js';
+import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { evaluateGitWorktreeCapability } from './git-worktree-capability.js';
 import { gitBlocker, gitOutputLine, runGitCommand } from './git-worktree-runner.js';
 import { sanitizePathPart } from './git-worktree-root.js';
@@ -67,13 +67,20 @@ export async function allocateWorkerWorktree(input) {
     return allocation;
 }
 async function appendWorktreeManifest(allocation) {
+    const current = await readJson(allocation.manifest_path, null).catch(() => null);
+    const allocations = Array.isArray(current?.allocations) ? current.allocations : [];
+    const key = (row) => `${row.mission_id}:${row.slot_id}:${row.generation_index}:${row.worker_id}`;
+    const nextAllocations = [
+        ...allocations.filter((row) => key(row) !== key(allocation)),
+        allocation
+    ];
     const manifest = {
         schema: 'sks.git-worktree-manifest.v1',
         updated_at: nowIso(),
         mission_id: allocation.mission_id,
         repo_root: allocation.repo_root,
         root: path.dirname(allocation.worktree_path),
-        allocations: [allocation]
+        allocations: nextAllocations
     };
     await writeJsonAtomic(allocation.manifest_path, manifest);
 }

package/dist/core/git/git-worktree-patch-envelope.js

@@ -20,11 +20,11 @@ export function buildGitWorktreePatchEnvelope(input) {
             changed_files: changedFiles,
             diff_bytes: input.diff.diff_bytes
         },
-        operations: changedFiles.map((file) => ({
-            op: 'unified_diff',
-            path: file,
-            diff: input.diff.diff
-        })),
+        operations: [{
+                op: 'git_apply_patch',
+                path: '.',
+                diff: input.diff.diff
+            }],
         rationale: 'Process-generated patch envelope exported from an isolated Git worktree diff.',
         verification_hint: {
             command: 'git apply --3way --check <diff>',