sneakoscope 2.0.9 → 2.0.10

package/dist/core/naruto/naruto-real-worker-runtime.js

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { allocateWorkerWorktree } from '../git/git-worktree-manager.js';
+import { cleanupGitWorktree } from '../git/git-worktree-cleanup.js';
+export async function spawnActualNarutoWorker(input) {
+    const workerDir = path.join(input.root, '.sneakoscope', 'missions', input.missionId, 'agents', 'naruto-real-workers', input.item.id);
+    await ensureDir(workerDir);
+    let worktree = null;
+    if (input.worktreePolicy?.mode === 'git-worktree' && input.item.write_allowed === true) {
+        const allocation = await allocateWorkerWorktree({
+            repoRoot: input.worktreePolicy.main_repo_root || input.root,
+            missionId: input.missionId,
+            workerId: input.item.id,
+            slotId: input.item.id.replace(/[^A-Za-z0-9_-]/g, '-'),
+            generationIndex: 1
+        }).catch((err) => ({ ok: false, blockers: [`git_worktree_allocate_exception:${err?.message || String(err)}`] }));
+        await writeJsonAtomic(path.join(workerDir, 'git-worktree-allocation.json'), allocation);
+        if (allocation.ok)
+            worktree = allocation;
+    }
+    const resultPath = path.join(workerDir, 'worker-result.json');
+    const heartbeatPath = path.join(workerDir, 'worker-heartbeat.jsonl');
+    const intakePath = path.join(workerDir, 'worker-intake.json');
+    await writeJsonAtomic(intakePath, {
+        schema: 'sks.naruto-actual-worker-intake.v1',
+        generated_at: nowIso(),
+        mission_id: input.missionId,
+        item: input.item,
+        placement: input.placement,
+        backend: input.backend,
+        result_path: resultPath,
+        heartbeat_path: heartbeatPath,
+        worktree_path: worktree?.worktree_path || null,
+        zellij_session_name: input.zellijSessionName || null,
+        visible_pane_cap: input.visiblePaneCap
+    });
+    const child = spawn(process.execPath, [actualWorkerEntrypoint(), intakePath], {
+        cwd: worktree?.worktree_path || input.root,
+        stdio: ['ignore', 'ignore', 'ignore']
+    });
+    const exit = waitForExit(child, 30000);
+    return {
+        id: input.item.id,
+        item: input.item,
+        placement: input.placement,
+        started_at: Date.now(),
+        pid: child.pid || null,
+        child,
+        worker_artifact_dir: workerDir,
+        result_path: resultPath,
+        heartbeat_path: heartbeatPath,
+        worktree,
+        exit
+    };
+}
+export async function collectActualNarutoWorker(handle) {
+    const exit = await handle.exit;
+    const result = await readJson(handle.result_path, null).catch(() => null);
+    const blockers = [
+        ...(exit.code === 0 ? [] : [`naruto_actual_worker_exit_${exit.code ?? exit.signal ?? 'unknown'}`]),
+        ...(result?.ok === false ? result.blockers || ['naruto_actual_worker_result_not_ok'] : []),
+        ...(result ? [] : ['naruto_actual_worker_result_missing'])
+    ];
+    if (handle.worktree?.worktree_path) {
+        const cleanup = await cleanupGitWorktree({
+            repoRoot: handle.worktree.main_repo_root || handle.worktree.repo_root || handle.worktree.repoRoot || '',
+            worktreePath: handle.worktree.worktree_path,
+            branch: handle.worktree.branch,
+            deleteBranch: true
+        }).catch((err) => ({ ok: false, blockers: [`git_worktree_cleanup_exception:${err?.message || String(err)}`] }));
+        await writeJsonAtomic(path.join(handle.worker_artifact_dir, 'git-worktree-cleanup.json'), cleanup);
+        blockers.push(...(cleanup.blockers || []));
+    }
+    return {
+        id: handle.id,
+        ok: blockers.length === 0,
+        item: handle.item,
+        placement: handle.placement,
+        completed_at: Date.now(),
+        pid: handle.pid,
+        worker_artifact_dir: handle.worker_artifact_dir,
+        blockers
+    };
+}
+function actualWorkerEntrypoint() {
+    return fileURLToPath(new URL('./naruto-real-worker-child.js', import.meta.url));
+}
+function waitForExit(child, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let killTimer = null;
+        const finish = (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            resolve({ code, signal });
+        };
+        const timer = setTimeout(() => {
+            if (!child.killed)
+                child.kill();
+            killTimer = setTimeout(() => {
+                if (!settled)
+                    child.kill('SIGKILL');
+                finish(null, 'SIGKILL');
+            }, 5000);
+        }, Math.max(1000, timeoutMs));
+        child.on('close', (code, signal) => {
+            finish(code, signal);
+        });
+        child.on('error', () => {
+            finish(1, null);
+        });
+    });
+}
+//# sourceMappingURL=naruto-real-worker-runtime.js.map

package/dist/core/version.js

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

package/dist/core/zellij/zellij-right-column-manager.js

@@ -1,13 +1,20 @@
 import path from 'node:path';
 import { appendJsonl, ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { openZellijDashboardPane } from './zellij-dashboard-pane.js';
+import { zellijUiModeCreatesDashboard } from './zellij-ui-mode.js';
 export const ZELLIJ_RIGHT_COLUMN_STATE_SCHEMA = 'sks.zellij-right-column-state.v1';
 export async function ensureRightColumn(input) {
     const paths = resolveRightColumnPaths(input.root, input.missionId, input.projectRoot);
     await ensureDir(paths.missionDir);
+    const uiMode = input.uiMode || 'compact-slots';
+    const createDashboard = input.createDashboard ?? zellijUiModeCreatesDashboard(uiMode);
     const existing = await readRightColumnState(input.root, input.missionId, input.projectRoot);
-    if (existing?.status === 'active' && existing.dashboard_pane_id) {
-        return writeRightColumnState(paths.statePath, { ...existing, updated_at: nowIso() });
+    if (existing?.status === 'active') {
+        return writeRightColumnState(paths.statePath, {
+            ...existing,
+            updated_at: nowIso(),
+            ui_mode: existing.ui_mode || uiMode
+        });
     }
     const creating = await writeRightColumnState(paths.statePath, {
         schema: ZELLIJ_RIGHT_COLUMN_STATE_SCHEMA,
@@ -18,11 +25,29 @@ export async function ensureRightColumn(input) {
         status: 'creating',
         dashboard_pane_id: null,
         right_anchor_pane_id: null,
+        ui_mode: uiMode,
         visible_worker_panes: [],
         headless_workers: [],
         blockers: []
     });
     await appendRightColumnEvent(paths.eventsPath, 'right_column_creating', creating, {});
+    if (!createDashboard) {
+        const active = await writeRightColumnState(paths.statePath, {
+            ...creating,
+            updated_at: nowIso(),
+            status: 'active',
+            dashboard_pane_id: null,
+            right_anchor_pane_id: null,
+            ui_mode: uiMode,
+            blockers: []
+        });
+        await appendRightColumnEvent(paths.eventsPath, 'right_column_created', active, {
+            ok: true,
+            dashboard_created: false,
+            ui_mode: uiMode
+        });
+        return active;
+    }
     const dashboard = await openZellijDashboardPane({
         root: paths.projectRoot,
         missionId: input.missionId,
@@ -45,6 +70,7 @@ export async function ensureRightColumn(input) {
         status: blockers.length ? 'creating' : 'active',
         dashboard_pane_id: dashboard.pane_id ? String(dashboard.pane_id) : null,
         right_anchor_pane_id: dashboard.pane_id ? String(dashboard.pane_id) : null,
+        ui_mode: uiMode,
         blockers
     });
     await appendRightColumnEvent(paths.eventsPath, 'right_column_created', active, { ok: active.status === 'active' });
@@ -52,6 +78,9 @@ export async function ensureRightColumn(input) {
     return active;
 }
 export async function prepareWorkerInRightColumn(input) {
+    return withRightColumnLock(input.root, input.missionId, async () => prepareWorkerInRightColumnUnlocked(input));
+}
+async function prepareWorkerInRightColumnUnlocked(input) {
     const paths = resolveRightColumnPaths(input.root, input.missionId, input.projectRoot);
     const state = await ensureRightColumn({
         root: input.root,
@@ -59,12 +88,13 @@ export async function prepareWorkerInRightColumn(input) {
         missionId: input.missionId,
         sessionName: input.sessionName,
         cwd: input.cwd,
-        dashboardSnapshot: input.dashboardSnapshot
+        dashboardSnapshot: input.dashboardSnapshot,
+        uiMode: input.uiMode || 'compact-slots'
     });
     const activeVisible = state.visible_worker_panes.filter((pane) => pane.status === 'launching' || pane.status === 'running');
     const cap = Math.max(1, Math.floor(Number(input.visiblePaneCap || 1)));
     if (activeVisible.length >= cap) {
-        const next = await recordHeadlessWorkerInRightColumn({
+        const next = await recordHeadlessWorkerInRightColumnUnlocked({
             root: input.root,
             ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
             missionId: input.missionId,
@@ -134,6 +164,9 @@ export async function recordWorkerPaneInRightColumn(input) {
     return next;
 }
 export async function recordHeadlessWorkerInRightColumn(input) {
+    return withRightColumnLock(input.root, input.missionId, async () => recordHeadlessWorkerInRightColumnUnlocked(input));
+}
+async function recordHeadlessWorkerInRightColumnUnlocked(input) {
     const paths = resolveRightColumnPaths(input.root, input.missionId, input.projectRoot);
     const state = await readRightColumnState(input.root, input.missionId, input.projectRoot) || {
         schema: ZELLIJ_RIGHT_COLUMN_STATE_SCHEMA,
@@ -144,13 +177,14 @@ export async function recordHeadlessWorkerInRightColumn(input) {
         status: 'absent',
         dashboard_pane_id: null,
         right_anchor_pane_id: null,
+        ui_mode: 'compact-slots',
         visible_worker_panes: [],
         headless_workers: [],
         blockers: []
     };
     const headless = [
         ...state.headless_workers.filter((row) => !(row.slot_id === input.slotId && row.generation_index === input.generationIndex)),
-        { slot_id: input.slotId, generation_index: input.generationIndex, reason: input.reason }
+        { slot_id: input.slotId, generation_index: input.generationIndex, reason: input.reason, status: 'running', closed_at: null }
     ];
     const next = await writeRightColumnState(paths.statePath, { ...state, updated_at: nowIso(), headless_workers: headless });
     await appendRightColumnEvent(paths.eventsPath, 'worker_headless_overflow', next, {
@@ -169,13 +203,19 @@ export async function closeWorkerInRightColumn(input) {
         const same = pane.slot_id === input.slotId && pane.generation_index === input.generationIndex;
         return same ? { ...pane, pane_id: input.paneId || pane.pane_id, status: input.status } : pane;
     });
+    const headless = state.headless_workers.map((row) => {
+        const same = row.slot_id === input.slotId && row.generation_index === input.generationIndex;
+        return same ? { ...row, status: input.status === 'draining' ? 'closed' : input.status, closed_at: nowIso() } : row;
+    });
     const visibleStillActive = panes.filter((pane) => pane.status === 'launching' || pane.status === 'running');
+    const headlessStillActive = headless.filter((row) => !row.status || row.status === 'running');
     const next = await writeRightColumnState(paths.statePath, {
         ...state,
         updated_at: nowIso(),
-        status: visibleStillActive.length || state.headless_workers.length ? 'active' : 'draining',
+        status: visibleStillActive.length || headlessStillActive.length ? 'active' : 'draining',
         right_anchor_pane_id: visibleStillActive[visibleStillActive.length - 1]?.pane_id || state.dashboard_pane_id,
-        visible_worker_panes: panes
+        visible_worker_panes: panes,
+        headless_workers: headless
     });
     await appendRightColumnEvent(paths.eventsPath, 'worker_pane_drained', next, {
         slot_id: input.slotId,
@@ -242,4 +282,23 @@ function inferProjectRoot(root, missionId) {
     }
     return root;
 }
+const rightColumnLocks = new Map();
+async function withRightColumnLock(root, missionId, fn) {
+    const key = `${path.resolve(root)}:${missionId}`;
+    const previous = rightColumnLocks.get(key) || Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    rightColumnLocks.set(key, previous.then(() => current, () => current));
+    await previous.catch(() => undefined);
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+        if (rightColumnLocks.get(key) === current)
+            rightColumnLocks.delete(key);
+    }
+}
 //# sourceMappingURL=zellij-right-column-manager.js.map

package/dist/core/zellij/zellij-slot-pane-renderer.js

@@ -0,0 +1,82 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function renderZellijSlotPane(input) {
+    const mode = input.mode || 'compact-slots';
+    const maxLines = mode === 'compact-slots' ? 5 : mode === 'dashboard-plus-slots' ? 8 : 20;
+    const task = trimInline(input.currentFile || input.currentTask || '-', 56);
+    const heartbeat = input.heartbeatAgeMs == null
+        ? 'unknown'
+        : input.heartbeatAgeMs < 1000
+            ? 'now'
+            : `${Math.max(1, Math.round(input.heartbeatAgeMs / 1000))}s ago`;
+    const rows = [
+        `${input.slotId} gen-${Math.max(1, Math.floor(Number(input.generationIndex) || 1))}`,
+        `${trimInline(input.role || 'worker', 18)} - ${trimInline(input.backend || 'codex-sdk', 18)} - ${trimInline(input.worktreeId || '-', 18)}`,
+        `status: ${trimInline(input.status || 'running', 14)} ${task}`,
+        `patch: ${trimInline(input.patchStatus || 'queued', 18)}  verify: ${trimInline(input.verifyStatus || 'queued', 18)}`,
+        `heartbeat: ${heartbeat}`
+    ];
+    return rows.slice(0, maxLines).join('\n');
+}
+export async function renderZellijSlotPaneFromArtifacts(input) {
+    const artifactDir = path.resolve(input.artifactDir);
+    const result = await readJson(path.join(artifactDir, 'worker-result.json'));
+    const heartbeatPath = path.join(artifactDir, 'worker-heartbeat.jsonl');
+    const heartbeatMtime = await statMtimeMs(heartbeatPath);
+    const now = Date.now();
+    return renderZellijSlotPane({
+        slotId: input.slotId,
+        generationIndex: input.generationIndex,
+        role: input.role || result?.persona_id || result?.agent_id || null,
+        backend: input.backend || result?.backend || null,
+        status: result?.status || (heartbeatMtime ? 'running' : 'launching'),
+        currentTask: result?.summary || null,
+        currentFile: Array.isArray(result?.changed_files) ? result.changed_files[0] : null,
+        patchStatus: Array.isArray(result?.patch_envelopes) && result.patch_envelopes.length ? 'candidate' : 'queued',
+        verifyStatus: result?.verification?.status || 'queued',
+        heartbeatAgeMs: heartbeatMtime ? now - heartbeatMtime : null,
+        worktreeId: result?.worktree?.id || null,
+        mode: input.mode || 'compact-slots'
+    });
+}
+export function buildZellijSlotPaneCommand(input) {
+    const args = [
+        input.cliPath,
+        'zellij-slot-pane',
+        '--mission', input.missionId,
+        '--slot', input.slotId,
+        '--generation', String(Math.max(1, Math.floor(Number(input.generationIndex) || 1))),
+        '--artifact-dir', input.artifactDir,
+        '--mode', input.mode || 'compact-slots',
+        ...(input.backend ? ['--backend', input.backend] : []),
+        ...(input.role ? ['--role', input.role] : []),
+        ...(input.watch ? ['--watch'] : [])
+    ];
+    return [input.nodePath || process.execPath, ...args].map(shellQuote).join(' ');
+}
+async function readJson(file) {
+    try {
+        return JSON.parse(await fs.promises.readFile(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function statMtimeMs(file) {
+    try {
+        return (await fs.promises.stat(file)).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+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, `'\\''`)}'`;
+}
+//# sourceMappingURL=zellij-slot-pane-renderer.js.map

package/dist/core/zellij/zellij-ui-mode.js

@@ -0,0 +1,16 @@
+export function resolveZellijUiMode(args = [], env = process.env) {
+    const fromEnv = String(env.SKS_ZELLIJ_UI_MODE || '').trim();
+    if (fromEnv === 'full-debug')
+        return 'full-debug';
+    if (fromEnv === 'dashboard-plus-slots')
+        return 'dashboard-plus-slots';
+    if (args.includes('--zellij-dashboard'))
+        return 'dashboard-plus-slots';
+    if (args.includes('--zellij-full-debug'))
+        return 'full-debug';
+    return 'compact-slots';
+}
+export function zellijUiModeCreatesDashboard(mode) {
+    return mode !== 'compact-slots';
+}
+//# sourceMappingURL=zellij-ui-mode.js.map

package/dist/core/zellij/zellij-worker-pane-manager.js

@@ -29,7 +29,7 @@ export function buildWorkerPaneArtifact(input) {
         schema: ZELLIJ_WORKER_PANE_SCHEMA,
         generated_at: now,
         updated_at: now,
-        ok: blockers.length === 0 && isRealZellijWorkerPaneIdSource(paneIdSource) && Boolean(input.paneId),
+        ok: blockers.length === 0 && (paneIdSource === 'zellij_worker_headless_overflow' || (isRealZellijWorkerPaneIdSource(paneIdSource) && Boolean(input.paneId))),
         status: input.status || 'launching',
         mission_id: input.missionId,
         session_name: input.sessionName,
@@ -52,8 +52,8 @@ export function buildWorkerPaneArtifact(input) {
         stdout_log: input.stdoutLog,
         stderr_log: input.stderrLog,
         parent_child_transport: 'worker-result-json-and-heartbeat',
-        scaling_primitive: 'native_cli_process_in_zellij_worker_pane',
-        command: '<native-cli-worker-command>',
+        scaling_primitive: input.scalingPrimitive || 'native_cli_process_in_zellij_worker_pane',
+        command: String(input.workerCommand || '').includes('zellij-slot-pane') ? '<zellij-slot-pane-renderer-command>' : '<native-cli-worker-command>',
         create_session: input.createSession || null,
         launch: input.launch || null,
         pane_reconciliation: input.paneReconciliation || null,
@@ -96,6 +96,7 @@ export async function openWorkerPane(input) {
             cwd,
             worker: { slotId: input.slotId, generationIndex: input.generationIndex },
             visiblePaneCap: input.visiblePaneCap || 1,
+            uiMode: input.uiMode || 'compact-slots',
             dashboardSnapshot: {
                 ...(input.dashboardSnapshot || {}),
                 mode: String(input.dashboardSnapshot?.mode || 'naruto'),
@@ -104,12 +105,41 @@ export async function openWorkerPane(input) {
             }
         })
         : null;
+    if (rightColumn?.placement === 'headless') {
+        const record = buildWorkerPaneArtifact({
+            ...input,
+            paneId: null,
+            paneIdSource: 'zellij_worker_headless_overflow',
+            createSession,
+            launch: null,
+            paneReconciliation: null,
+            directionRequested: 'right',
+            directionApplied: 'not_applied',
+            rightColumn: {
+                mode: 'spawn-on-first-worker',
+                focus_pane_id: null,
+                y_order: null
+            },
+            status: 'running',
+            providerContext,
+            serviceTier: input.serviceTier || providerContext.service_tier,
+            scalingPrimitive: 'native_cli_process_headless_with_slot_dashboard',
+            blockers: []
+        });
+        await writeWorkerPaneArtifact(root, record);
+        await appendWorkerPaneEvent(root, 'worker_headless_overflow', input, {
+            slot_id: input.slotId,
+            generation_index: input.generationIndex,
+            reason: `visible_pane_cap:${input.visiblePaneCap || 1}`
+        });
+        return record;
+    }
     const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || 'running', input.worktree || null);
-    const directionRequested = rightColumn ? 'down' : 'right';
+    const directionRequested = rightColumn?.focusPaneId ? 'down' : 'right';
     const focus = rightColumn?.focusPaneId
         ? await focusZellijPaneById(input.sessionName, rightColumn.focusPaneId, cwd)
         : null;
-    const newPaneArgs = ['--session', input.sessionName, 'action', 'new-pane', '--direction', directionRequested, ...(rightColumn ? ['--near-current-pane'] : []), '--name', paneName, '--', 'sh', '-lc', input.workerCommand];
+    const newPaneArgs = ['--session', input.sessionName, 'action', 'new-pane', '--direction', directionRequested, ...(directionRequested === 'down' ? ['--near-current-pane'] : []), '--name', paneName, '--', 'sh', '-lc', input.workerCommand];
     let launch = createSession.ok
         ? await runZellij(newPaneArgs, {
             cwd,
@@ -119,9 +149,9 @@ export async function openWorkerPane(input) {
         : null;
     let directionApplied = launch?.ok ? directionRequested : 'not_applied';
     if (createSession.ok && launch && !launch.ok) {
-        const fallbackArgs = rightColumn
+        const fallbackArgs = rightColumn && directionRequested === 'down'
             ? ['--session', input.sessionName, 'action', 'new-pane', '--direction', 'down', '--name', paneName, '--', 'sh', '-lc', input.workerCommand]
-            : ['--session', input.sessionName, 'action', 'new-pane', '--name', paneName, '--', 'sh', '-lc', input.workerCommand];
+            : ['--session', input.sessionName, 'action', 'new-pane', '--direction', directionRequested, '--name', paneName, '--', 'sh', '-lc', input.workerCommand];
         const fallback = await runZellij(fallbackArgs, {
             cwd,
             timeoutMs: 5000,
@@ -204,7 +234,7 @@ export async function openWorkerPane(input) {
         provider_context: record.provider_context,
         direction_requested: record.direction_requested,
         direction_applied: record.direction_applied,
-        command: '<native-cli-worker-command>',
+        command: record.command,
         worker_artifact_dir: input.workerArtifactDir,
         worker_result_path: input.resultPath,
         heartbeat_path: input.heartbeatPath,

package/dist/scripts/agent-role-config-repair-check.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/agents/agent-role-config.js');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-role-repair-'));
+fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+const plan = await mod.repairAgentRoleConfigs({ root, apply: false, codexHome: path.join(root, 'codex-home') });
+const repair = await mod.repairAgentRoleConfigs({ root, apply: true, codexHome: path.join(root, 'codex-home'), reportPath: path.join(root, '.sneakoscope', 'reports', 'agent-role-config-repair.json') });
+const analysisScout = path.join(root, '.codex', 'agents', 'analysis-scout.toml');
+const staleRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-role-stale-'));
+fs.mkdirSync(path.join(staleRoot, '.codex', 'agents'), { recursive: true });
+fs.writeFileSync(path.join(staleRoot, '.codex', 'agents', 'analysis-scout.toml'), 'model = "gpt-5-codex"\nsandbox_mode = "read-only"\n');
+const stalePlan = await mod.repairAgentRoleConfigs({ root: staleRoot, apply: false, codexHome: path.join(staleRoot, 'codex-home') });
+const staleRepair = await mod.repairAgentRoleConfigs({ root: staleRoot, apply: true, codexHome: path.join(staleRoot, 'codex-home') });
+const repairedText = fs.readFileSync(path.join(staleRoot, '.codex', 'agents', 'analysis-scout.toml'), 'utf8');
+const report = {
+    schema: 'sks.agent-role-config-repair-check.v1',
+    plan_ok: plan.ok === true && plan.missing.includes('analysis-scout.toml'),
+    repair_ok: repair.ok === true,
+    analysis_scout_created: fs.existsSync(analysisScout),
+    created_matches_model: fs.readFileSync(analysisScout, 'utf8').includes('model = "gpt-5.5"'),
+    stale_detected: stalePlan.stale.includes('analysis-scout.toml'),
+    stale_repaired: staleRepair.repaired.includes('.codex/agents/analysis-scout.toml') && repairedText.includes('name = "analysis_scout"') && repairedText.includes('model = "gpt-5.5"'),
+    warnings_suppressed: repair.warnings_suppressed === true,
+    artifact_written: fs.existsSync(path.join(root, '.sneakoscope', 'reports', 'agent-role-config-repair.json'))
+};
+const ok = report.plan_ok && report.repair_ok && report.analysis_scout_created && report.created_matches_model && report.stale_detected && report.stale_repaired && report.warnings_suppressed && report.artifact_written;
+assertGate(ok, 'doctor --fix must repair missing SKS-owned agent role configs', report);
+emitGate('agent:role-config-repair', report);
+//# sourceMappingURL=agent-role-config-repair-check.js.map

package/dist/scripts/git-worktree-integration-primary-check.js

@@ -17,6 +17,8 @@ const integrationPath = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-integration-'
 fs.rmSync(integrationPath, { recursive: true, force: true });
 const integration = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-integrate', workerId: 'integration', slotId: 'integration' });
 const report = await mergeMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: integration.worktree_path, diffs: [diff] });
-assertGate(report.ok === true && report.applied_count === 1, 'git-worktree-diff must apply through merge queue', report);
-emitGate('git:worktree-integration-primary', { applied_count: report.applied_count });
+const mainReport = await mergeMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: repo, diffs: [diff] });
+const mainContent = fs.readFileSync(path.join(repo, 'a.txt'), 'utf8');
+assertGate(report.ok === true && report.applied_count === 1 && mainReport.ok === true && mainReport.applied_count === 1 && mainContent.includes('integrated'), 'git-worktree-diff must prevalidate in integration worktree and apply to main repo', { report, mainReport, mainContent });
+emitGate('git:worktree-integration-primary', { applied_count: report.applied_count, main_applied_count: mainReport.applied_count });
 //# sourceMappingURL=git-worktree-integration-primary-check.js.map

package/dist/scripts/git-worktree-integration-primary-runtime-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const orchestrator = fs.readFileSync(path.join(root, 'src/core/agents/agent-orchestrator.ts'), 'utf8');
+const report = {
+    schema: 'sks.git-worktree-integration-primary-runtime-check.v1',
+    splits_worktree_entries: orchestrator.includes("entry.envelope?.source === 'git-worktree-diff'"),
+    uses_integration_worktree: orchestrator.includes('createGitIntegrationWorktree'),
+    uses_merge_queue: orchestrator.includes('applyGitWorktreeMergeQueue'),
+    applies_to_main_repo: orchestrator.includes('main_repo_apply') && orchestrator.includes('integrationWorktreePath: repoRoot'),
+    rollback_evidence: orchestrator.includes('rollback_evidence') && orchestrator.includes('captureGitWorktreeRollbackPlan') && orchestrator.includes('completeGitWorktreeRollbackPlan'),
+    bypasses_normal_apply: orchestrator.includes('const normalEntries') && orchestrator.includes('applyAgentPatchQueueEntry(root, entry') && orchestrator.includes('parallelEntries = disjointEntries'),
+    writes_report: orchestrator.includes('git-worktree-merge-queue-report.json')
+};
+const ok = report.splits_worktree_entries && report.uses_integration_worktree && report.uses_merge_queue && report.applies_to_main_repo && report.rollback_evidence && report.bypasses_normal_apply && report.writes_report;
+assertGate(ok, 'git-worktree-diff entries must use integration merge queue primary path', report);
+emitGate('git:worktree-integration-primary-runtime', report);
+//# sourceMappingURL=git-worktree-integration-primary-runtime-check.js.map

package/dist/scripts/mutation-callsite-coverage-check.js

@@ -17,6 +17,7 @@ const uncovered = [];
 const GUARD_CALL = /\bguarded(WriteFile|Rm|Rename|Chmod|Xattr|Chflags|GlobalCodexConfigWrite|ProcessKill|PackageInstall|SkillSnapshotPromotion|Apply)\(/;
 const RISKY = [
     { kind: 'write_file', token: 'fs.writeFile', re: /\bfs\.writeFile\(/ },
+    { kind: 'write_file', token: 'fs.promises.writeFile', re: /\bfs\.promises\.writeFile\(/ },
     { kind: 'write_file', token: 'fsp.writeFile', re: /\bfsp\.writeFile\(/ },
     { kind: 'write_file', token: 'writeFileSync', re: /\b(?:fs\.)?writeFileSync\(/ },
     { kind: 'rm', token: 'fs.rm', re: /\bfs\.rm\(/ },
@@ -167,7 +168,7 @@ function processKillIsLivenessProbe(line) {
     return /\bprocess\.kill\([^,\n]+,\s*0\s*\)/.test(line);
 }
 function codexHomeMutationOnLine(line) {
-    return /\b(?:writeTextAtomic|writeJsonAtomic|writeFileSync|fs\.writeFile|fsp\.writeFile|fs\.rm|fsp\.rm|fs\.rename|fsp\.rename|fs\.chmod|fsp\.chmod|copyFile|open)\b/.test(line)
+    return /\b(?:writeTextAtomic|writeJsonAtomic|writeFileSync|fs\.writeFile|fs\.promises\.writeFile|fsp\.writeFile|fs\.rm|fsp\.rm|fs\.rename|fsp\.rename|fs\.chmod|fsp\.chmod|copyFile|open)\b/.test(line)
         && /(?:~\/\.codex|CODEX_HOME|codexHome|codexLbHome|auth\.json|config\.toml)/.test(line);
 }
 function snippet(line) {

package/dist/scripts/naruto-extreme-parallelism-check.js

@@ -13,7 +13,7 @@ const governor = decideNarutoConcurrency({
 });
 const report = {
     schema: 'sks.naruto-extreme-parallelism-check.v1',
-    ok: graph.total_work_items >= 200 && governor.safe_active_workers >= 16 && governor.safe_zellij_visible_panes <= governor.safe_active_workers && graph.mixed_work_kinds.length >= 6,
+    ok: graph.total_work_items >= 200 && governor.safe_active_workers >= 16 && governor.safe_zellij_visible_panes <= governor.safe_active_workers && governor.safe_zellij_visible_panes <= 8 && graph.mixed_work_kinds.length >= 6,
     graph: { total_work_items: graph.total_work_items, mixed_work_kinds: graph.mixed_work_kinds, write_allowed_count: graph.write_allowed_count },
     governor
 };

package/dist/scripts/naruto-extreme-parallelism-real-check.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { buildNarutoWorkGraph } from '../core/naruto/naruto-work-graph.js';
+import { decideNarutoConcurrency } from '../core/naruto/naruto-concurrency-governor.js';
+import { runNarutoRealActivePool } from '../core/naruto/naruto-active-pool.js';
+import { collectActualNarutoWorker, spawnActualNarutoWorker } from '../core/naruto/naruto-real-worker-runtime.js';
+const graph = buildNarutoWorkGraph({ requestedClones: 100, totalWorkItems: 200, writeCapable: true, maxActiveWorkers: 32 });
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-extreme-real-'));
+const missionId = `M-naruto-extreme-real-${process.pid}`;
+const governor = decideNarutoConcurrency({
+    requestedClones: 100,
+    totalWorkItems: graph.total_work_items,
+    pendingWorkQueueSize: graph.total_work_items,
+    backend: 'codex-sdk',
+    hardware: { cores: 16, loadAverage: [1, 1, 1], freeMemoryBytes: 64 * 1024 * 1024 * 1024, totalMemoryBytes: 128 * 1024 * 1024 * 1024, fileDescriptorLimit: 8192, processCount: 100, terminalRows: 48, remoteApiRateLimitBudget: 32, localLlmMaxParallelRequests: 8 }
+});
+const target = { ...governor, safe_active_workers: Math.min(32, governor.safe_active_workers), safe_zellij_visible_panes: Math.min(8, governor.safe_zellij_visible_panes) };
+const report = await runNarutoRealActivePool({
+    graph,
+    governor: target,
+    spawnWorker: async (item, placement) => spawnActualNarutoWorker({
+        root: tempRoot,
+        missionId,
+        item,
+        placement,
+        backend: 'codex-sdk',
+        visiblePaneCap: target.safe_zellij_visible_panes,
+        zellijSessionName: `sks-${missionId}`
+    }),
+    collectWorker: async (handle) => collectActualNarutoWorker(handle),
+    enqueueVerification: async () => undefined,
+    updateDashboard: async () => undefined
+});
+const actualArtifacts = report.worker_lifecycle.every((row) => row.pid && row.worker_artifact_dir && fs.existsSync(path.join(row.worker_artifact_dir, 'worker-result.json')));
+const ok = report.ok && report.max_observed_active_workers >= Math.ceil(target.safe_active_workers * 0.8) && report.active_pool_utilization >= 0.8 && report.headless_workers > 0 && report.visible_workers <= graph.total_work_items && actualArtifacts;
+assertGate(ok, 'Naruto extreme parallelism must use actual child process active-pool lifecycle near cap with headless overflow', { report, target, actualArtifacts, tempRoot });
+emitGate('naruto:extreme-parallelism-real', report);
+//# sourceMappingURL=naruto-extreme-parallelism-real-check.js.map

package/dist/scripts/naruto-real-active-pool-check.js

@@ -32,7 +32,8 @@ const report = await runNarutoRealActivePool({
         dashboardEvents += 1;
     }
 });
-const ok = report.ok && spawned === graph.total_work_items && collected === graph.total_work_items && report.max_observed_active_workers >= target.safe_active_workers && dashboardEvents > graph.total_work_items;
+const processEvidence = report.worker_lifecycle.every((row) => row.pid == null || row.worker_artifact_dir != null);
+const ok = report.ok && spawned === graph.total_work_items && collected === graph.total_work_items && report.max_observed_active_workers >= target.safe_active_workers && dashboardEvents > graph.total_work_items && report.active_cap === target.safe_active_workers && processEvidence;
 assertGate(ok, 'Naruto real active pool must run spawn/collect lifecycle and refill to cap', { report, spawned, collected, dashboardEvents, target });
-emitGate('naruto:real-active-pool', { spawned, collected, max_observed_active_workers: report.max_observed_active_workers, refill_latency_ms_p95: report.refill_latency_ms_p95 });
+emitGate('naruto:real-active-pool', { spawned, collected, active_cap: report.active_cap, max_observed_active_workers: report.max_observed_active_workers, refill_latency_ms_p95: report.refill_latency_ms_p95, active_pool_utilization: report.active_pool_utilization });
 //# sourceMappingURL=naruto-real-active-pool-check.js.map