sneakoscope 2.0.7 → 2.0.9

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

@@ -4,6 +4,7 @@ import { providerPaneLabel } from '../provider/provider-badge.js';
 import { resolveProviderContext } from '../provider/provider-context.js';
 import { runZellij } from './zellij-command.js';
 import { extractZellijPaneIdFromOutput } from './zellij-lane-runtime.js';
+import { closeWorkerInRightColumn, prepareWorkerInRightColumn, recordWorkerPaneInRightColumn } from './zellij-right-column-manager.js';
 export const ZELLIJ_WORKER_PANE_SCHEMA = 'sks.zellij-worker-pane.v1';
 export const ZELLIJ_WORKER_PANE_EVENT_SCHEMA = 'sks.zellij-worker-pane-event.v1';
 export function buildWorkerPaneName(slotId, generationIndex) {
@@ -23,7 +24,7 @@ export function buildWorkerPaneArtifact(input) {
     const paneIdSource = input.paneIdSource || 'zellij_worker_pane_launch_failed';
     const blockers = input.blockers || [];
     const providerContext = normalizePaneProviderContext(input.providerContext, input.serviceTier);
-    const paneTitle = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.status || input.statusLabel, input.worktree || null);
+    const paneTitle = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || input.status, input.worktree || null);
     return {
         schema: ZELLIJ_WORKER_PANE_SCHEMA,
         generated_at: now,
@@ -59,8 +60,9 @@ export function buildWorkerPaneArtifact(input) {
         opened_at: now,
         closed_at: null,
         close: null,
-        direction_requested: 'right',
+        direction_requested: input.directionRequested || 'right',
         direction_applied: input.directionApplied || 'not_applied',
+        right_column: input.rightColumn || null,
         sdk_thread_id: input.sdkThreadId || null,
         sdk_run_id: input.sdkRunId || null,
         stream_event_count: Number(input.streamEventCount || 0),
@@ -79,34 +81,61 @@ export async function openWorkerPane(input) {
     const workerDir = path.join(root, input.workerArtifactDir);
     await ensureDir(workerDir);
     await appendWorkerPaneEvent(root, 'session_launch_started', input, {});
-    const createSession = await runZellij(['attach', '--create-background', input.sessionName], {
+    const createSessionRaw = await runZellij(['attach', '--create-background', input.sessionName], {
         cwd,
         timeoutMs: 5000,
         optional: false
     });
+    const createSession = normalizeExistingZellijSession(input.sessionName, createSessionRaw);
+    const rightColumn = input.rightColumnMode === 'spawn-on-first-worker'
+        ? await prepareWorkerInRightColumn({
+            root,
+            ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+            missionId: input.missionId,
+            sessionName: input.sessionName,
+            cwd,
+            worker: { slotId: input.slotId, generationIndex: input.generationIndex },
+            visiblePaneCap: input.visiblePaneCap || 1,
+            dashboardSnapshot: {
+                ...(input.dashboardSnapshot || {}),
+                mode: String(input.dashboardSnapshot?.mode || 'naruto'),
+                active_workers: Number(input.dashboardSnapshot?.active_workers || input.visiblePaneCap || 1),
+                visible_panes: Number(input.dashboardSnapshot?.visible_panes || input.visiblePaneCap || 1)
+            }
+        })
+        : null;
     const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || 'running', input.worktree || null);
+    const directionRequested = rightColumn ? '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];
     let launch = createSession.ok
-        ? await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--direction', 'right', '--name', paneName, '--', 'sh', '-lc', input.workerCommand], {
+        ? await runZellij(newPaneArgs, {
             cwd,
             timeoutMs: 5000,
             optional: false
         })
         : null;
-    let directionApplied = launch?.ok ? 'right' : 'not_applied';
+    let directionApplied = launch?.ok ? directionRequested : 'not_applied';
     if (createSession.ok && launch && !launch.ok) {
-        const fallback = await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--name', paneName, '--', 'sh', '-lc', input.workerCommand], {
+        const fallbackArgs = rightColumn
+            ? ['--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];
+        const fallback = await runZellij(fallbackArgs, {
             cwd,
             timeoutMs: 5000,
             optional: false
         });
         if (fallback.ok) {
             launch = fallback;
-            directionApplied = 'unknown';
+            directionApplied = rightColumn ? 'down' : 'unknown';
         }
     }
     const stdoutPaneId = launch?.ok ? extractZellijPaneIdFromOutput(launch.stdout_tail) : null;
     const reconciledPane = stdoutPaneId ? null : launch?.ok ? await reconcileZellijWorkerPaneId(input.sessionName, paneName, path.join(root, input.resultPath), cwd) : null;
     const paneId = stdoutPaneId || reconciledPane?.pane_id || null;
+    const renamePane = paneId ? await renameZellijPaneById(input.sessionName, paneId, paneName, cwd) : null;
     const paneIdSource = stdoutPaneId
         ? 'zellij_worker_new_pane_stdout'
         : reconciledPane?.pane_id
@@ -116,6 +145,7 @@ export async function openWorkerPane(input) {
                 : 'zellij_worker_pane_launch_failed';
     const blockers = [
         ...(createSession.ok ? [] : createSession.blockers.map((blocker) => `zellij_worker_session_${blocker}`)),
+        ...(rightColumn && rightColumn.placement !== 'zellij-pane' ? [`zellij_worker_right_column_${rightColumn.placement}`] : []),
         ...(launch && !launch.ok ? launch.blockers.map((blocker) => `zellij_worker_pane_${blocker}`) : []),
         ...(launch?.ok && !isRealZellijWorkerPaneIdSource(paneIdSource) ? ['zellij_worker_pane_id_real_source_missing'] : [])
     ];
@@ -125,14 +155,30 @@ export async function openWorkerPane(input) {
         paneIdSource,
         createSession,
         launch,
-        paneReconciliation: reconciledPane,
+        paneReconciliation: {
+            ...(reconciledPane || {}),
+            focus_pane: focus,
+            focus_degraded: focus ? focus.ok !== true : false,
+            rename_pane: renamePane
+        },
+        directionRequested,
         directionApplied,
+        rightColumn: rightColumn ? { mode: 'spawn-on-first-worker', focus_pane_id: rightColumn.focusPaneId, y_order: rightColumn.yOrder } : null,
         status: blockers.length ? 'failed' : 'running',
         providerContext,
         serviceTier: input.serviceTier || providerContext.service_tier,
         blockers
     });
     await writeWorkerPaneArtifact(root, record);
+    if (rightColumn) {
+        await recordWorkerPaneInRightColumn({
+            root,
+            ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+            missionId: input.missionId,
+            record,
+            yOrder: rightColumn.yOrder
+        });
+    }
     await appendWorkerPaneEvent(root, 'zellij_worker_pane_created', input, {
         ok: record.ok,
         pane_id: record.pane_id,
@@ -172,12 +218,16 @@ export async function openWorkerPane(input) {
 }
 export async function closeWorkerPane(input) {
     const root = path.resolve(input.root);
-    const close = process.env.SKS_ZELLIJ_CLOSE_WORKER_PANE === '1' && input.paneRecord.pane_id
-        ? await runZellij(['--session', input.paneRecord.session_name, 'action', 'close-pane', '--pane-id', input.paneRecord.pane_id], {
-            cwd: input.cwd || packageRoot(),
-            timeoutMs: 5000,
-            optional: true
-        })
+    const success = (input.status || 'closed') === 'closed' && !(input.blockers || []).length;
+    const closeSuccess = process.env.SKS_ZELLIJ_CLOSE_WORKER_PANE !== '0';
+    const closeFailed = process.env.SKS_ZELLIJ_CLOSE_FAILED_PANE === '1' || process.env.SKS_ZELLIJ_KEEP_FAILED_PANE === '0';
+    const paneId = input.paneRecord.pane_id;
+    const shouldClose = Boolean(paneId) && (success ? closeSuccess : closeFailed);
+    const close = shouldClose
+        ? await closeZellijPaneById(input.paneRecord.session_name, paneId || '', input.cwd || packageRoot())
+        : null;
+    const rename = !shouldClose && paneId
+        ? await renameZellijPaneById(input.paneRecord.session_name, paneId, `${input.paneRecord.pane_title} · ${success ? 'drained' : 'failed'}`, input.cwd || packageRoot())
         : null;
     const next = {
         ...input.paneRecord,
@@ -191,9 +241,25 @@ export async function closeWorkerPane(input) {
         stream_event_count: Number(input.streamEventCount || input.paneRecord.stream_event_count || 0),
         structured_output_valid: input.structuredOutputValid === true || input.paneRecord.structured_output_valid === true,
         worker_result_path: input.workerResultPath || input.paneRecord.worker_result_path,
-        blockers: [...input.paneRecord.blockers, ...(input.blockers || []), ...(close && !close.ok ? close.blockers.map((blocker) => `zellij_worker_close_${blocker}`) : [])]
+        blockers: [
+            ...input.paneRecord.blockers,
+            ...(input.blockers || []),
+            ...(close && !close.ok ? close.blockers.map((blocker) => `zellij_worker_close_${blocker}`) : []),
+            ...(rename && !rename.ok ? rename.blockers.map((blocker) => `zellij_worker_rename_${blocker}`) : [])
+        ]
     };
     await writeWorkerPaneArtifact(root, next);
+    if (next.right_column?.mode === 'spawn-on-first-worker') {
+        await closeWorkerInRightColumn({
+            root,
+            ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+            missionId: next.mission_id,
+            slotId: next.slot_id,
+            generationIndex: next.generation_index,
+            paneId: next.pane_id,
+            status: next.status === 'failed' ? 'failed' : close?.ok ? 'closed' : 'draining'
+        });
+    }
     await appendWorkerPaneEvent(root, 'pane_closed', {
         root,
         missionId: next.mission_id,
@@ -262,6 +328,11 @@ async function reconcileZellijWorkerPaneId(sessionName, paneName, resultPath, cw
         timeoutMs: 5000,
         optional: true
     });
+    const screen = await runZellij(['--session', sessionName, 'action', 'dump-screen'], {
+        cwd,
+        timeoutMs: 5000,
+        optional: true
+    });
     const rows = parsePaneRows(listed.stdout_tail);
     const pane = rows.find((row) => {
         const title = String(row.title || row.name || row.pane_name || '');
@@ -280,6 +351,7 @@ async function reconcileZellijWorkerPaneId(sessionName, paneName, resultPath, cw
         pane_id: paneId == null ? null : String(paneId),
         listed_count: rows.length,
         command: listed,
+        dump_screen: screen,
         blockers: paneId == null ? ['zellij_worker_pane_id_not_reconciled'] : []
     };
 }
@@ -330,4 +402,97 @@ function parsePaneRows(text) {
         return [];
     }
 }
+async function renameZellijPaneById(sessionName, paneId, paneName, cwd) {
+    const numeric = Number.parseInt(paneId.replace(/^terminal_/, ''), 10);
+    const numericCandidates = Number.isFinite(numeric)
+        ? [numeric, numeric + 1, numeric - 1].filter((value) => value >= 0).map(String)
+        : [];
+    const candidates = [...new Set([paneId, paneId.replace(/^terminal_/, ''), ...numericCandidates].filter(Boolean))];
+    let last = null;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        if (attempt > 0)
+            await sleep(200 * attempt);
+        for (const candidate of candidates) {
+            last = await runZellij(['--session', sessionName, 'action', 'rename-pane', '--pane-id', candidate, paneName], {
+                cwd,
+                timeoutMs: 5000,
+                optional: true
+            });
+            if (last.ok)
+                return last;
+            const focus = await runZellij(['--session', sessionName, 'action', 'focus-pane-id', candidate], {
+                cwd,
+                timeoutMs: 5000,
+                optional: true
+            });
+            if (focus.ok) {
+                last = await runZellij(['--session', sessionName, 'action', 'rename-pane', paneName], {
+                    cwd,
+                    timeoutMs: 5000,
+                    optional: true
+                });
+                if (last.ok)
+                    return last;
+            }
+        }
+    }
+    return last;
+}
+async function focusZellijPaneById(sessionName, paneId, cwd) {
+    const candidates = zellijPaneIdCandidates(paneId);
+    let last = null;
+    for (const candidate of candidates) {
+        const focus = await runZellij(['--session', sessionName, 'action', 'focus-pane-id', candidate], {
+            cwd,
+            timeoutMs: 5000,
+            optional: true
+        });
+        last = focus;
+        if (focus.ok)
+            return focus;
+    }
+    return last;
+}
+async function closeZellijPaneById(sessionName, paneId, cwd) {
+    const candidates = zellijPaneIdCandidates(paneId);
+    let last = null;
+    for (const candidate of candidates) {
+        const close = await runZellij(['--session', sessionName, 'action', 'close-pane', '--pane-id', candidate], {
+            cwd,
+            timeoutMs: 5000,
+            optional: true
+        });
+        last = close;
+        if (close.ok)
+            return close;
+    }
+    return last;
+}
+function zellijPaneIdCandidates(paneId) {
+    const raw = String(paneId || '').trim();
+    const numeric = raw.replace(/^terminal_/, '');
+    const parsed = Number.parseInt(numeric, 10);
+    return [...new Set([
+            raw,
+            numeric,
+            Number.isFinite(parsed) ? String(parsed) : '',
+            Number.isFinite(parsed) ? `terminal_${parsed}` : ''
+        ].filter(Boolean))];
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeExistingZellijSession(sessionName, result) {
+    if (result.ok)
+        return result;
+    if (/Session already exists/i.test(result.stderr_tail || '')) {
+        return {
+            ...result,
+            ok: true,
+            blockers: [],
+            warnings: [...result.warnings, `zellij_session_already_exists:${sessionName}`]
+        };
+    }
+    return result;
+}
 //# sourceMappingURL=zellij-worker-pane-manager.js.map

package/dist/scripts/codex-sdk-release-review-pipeline-check.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 // @ts-nocheck
-import { assertGate, emitGate, packageScripts, readText } from './lib/codex-sdk-gate-lib.js';
+import { assertGate, emitGate, packageScripts, readText, releaseGateIds } from './lib/codex-sdk-gate-lib.js';
 const scripts = packageScripts();
-const releaseCheck = String(scripts['release:check'] || '');
 const releaseRealCheck = String(scripts['release:real-check'] || '');
-assertGate(releaseCheck.includes('codex-sdk:capability'), 'release:check must include Codex SDK capability gate');
-assertGate(releaseCheck.includes('codex-sdk:all-pipelines'), 'release:check must include Codex SDK all-pipelines gate');
+const releaseGates = releaseGateIds();
+assertGate(releaseGates.has('codex-sdk:capability'), 'release gate DAG must include Codex SDK capability gate');
+assertGate(releaseGates.has('codex-sdk:all-pipelines'), 'release gate DAG must include Codex SDK all-pipelines gate');
 assertGate(releaseRealCheck.includes('codex-sdk:real-smoke'), 'release:real-check must include Codex SDK real smoke');
 assertGate(readText('src/core/agents/agent-orchestrator.ts').includes('legacy_codex_exec_runtime_removed'), 'orchestrator must block legacy codex-exec requests');
-emitGate('codex-sdk:release-review-pipeline', { release_check_contains_sdk: true });
+emitGate('codex-sdk:release-review-pipeline', { release_gate_dag_contains_sdk: true });
 //# sourceMappingURL=codex-sdk-release-review-pipeline-check.js.map

package/dist/scripts/doctor-fix-proves-codex-read-check.js

@@ -25,19 +25,40 @@ const run = spawnSync(process.execPath, [
         SKS_DISABLE_UPDATE_CHECK: '1'
     },
     encoding: 'utf8',
-    timeout: 60000
+    timeout: 180000
 });
 const parsed = parseLastJson(run.stdout || '{}');
 const ok = run.status !== 0
     && parsed.ready?.ready === false
     && parsed.ready?.blockers?.includes('codex_cli_config_eperm')
     && parsed.ready?.next_actions?.length > 0;
-console.log(JSON.stringify({ schema: 'sks.doctor-fix-proves-codex-read-check.v1', ok, status: run.status, parsed }, null, 2));
+console.log(JSON.stringify({
+    schema: 'sks.doctor-fix-proves-codex-read-check.v1',
+    ok,
+    status: run.status,
+    signal: run.signal,
+    error: run.error ? String(run.error.message || run.error) : null,
+    parsed,
+    stdout_tail: String(run.stdout || '').slice(-1000),
+    stderr_tail: String(run.stderr || '').slice(-1000)
+}, null, 2));
 if (!ok)
     process.exitCode = 1;
 function parseLastJson(text) {
-    const index = String(text).lastIndexOf('\n{');
-    const jsonText = index >= 0 ? String(text).slice(index + 1) : String(text).slice(String(text).indexOf('{'));
-    return JSON.parse(jsonText || '{}');
+    const source = String(text || '').trim();
+    if (!source)
+        return {};
+    const starts = [];
+    for (let index = source.indexOf('{'); index >= 0; index = source.indexOf('{', index + 1))
+        starts.push(index);
+    for (let i = starts.length - 1; i >= 0; i -= 1) {
+        try {
+            return JSON.parse(source.slice(starts[i]));
+        }
+        catch {
+            // Continue searching for the outer JSON object; pretty JSON may contain nested objects.
+        }
+    }
+    return {};
 }
 //# sourceMappingURL=doctor-fix-proves-codex-read-check.js.map

package/dist/scripts/git-worktree-diff-envelope-check.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const envelopeMod = await importDist('core/git/git-worktree-patch-envelope.js');
+const schemaMod = await importDist('core/agents/agent-patch-schema.js');
+const envelope = envelopeMod.buildGitWorktreePatchEnvelope({
+    diff: { schema: 'sks.git-worktree-diff.v1', mission_id: 'M-env', worker_id: 'worker-1', main_repo_root: '.', worktree_path: '.', branch: null, base_head: null, worktree_head: null, changed_files: ['a.txt', 'b.txt'], diff_bytes: 12, diff: 'diff --git a/a.txt b/a.txt\n', clean: false },
+    agentId: 'agent-1',
+    sessionId: 'session-1',
+    slotId: 'slot-001',
+    generationIndex: 1
+});
+const validation = schemaMod.validateAgentPatchEnvelope(schemaMod.normalizeAgentPatchEnvelope(envelope));
+assertGate(envelope.operations.length === 1 && envelope.operations[0].op === 'git_apply_patch', 'git worktree envelope must use one git_apply_patch operation', envelope);
+assertGate(validation.ok === true, 'git_apply_patch envelope must validate', validation);
+emitGate('git:worktree-diff-envelope', { operations: envelope.operations.length, op: envelope.operations[0].op });
+//# sourceMappingURL=git-worktree-diff-envelope-check.js.map

package/dist/scripts/git-worktree-dirty-lock-check.js

@@ -0,0 +1,17 @@
+#!/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';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const cleanupMod = await importDist('core/git/git-worktree-cleanup.js');
+const repo = makeGitFixture('dirty-lock');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-lock-'));
+const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-lock', workerId: 'worker-1', slotId: 'slot-001' });
+fs.writeFileSync(path.join(allocation.worktree_path, 'a.txt'), 'dirty\n');
+const cleanup = await cleanupMod.cleanupGitWorktree({ repoRoot: repo, worktreePath: allocation.worktree_path, branch: allocation.branch });
+assertGate(cleanup.action === 'retained_dirty' && cleanup.git_locked === true, 'dirty retained worktree must be git locked', cleanup);
+emitGate('git:worktree-dirty-lock', { git_locked: cleanup.git_locked, unlock_command: cleanup.unlock_command });
+//# sourceMappingURL=git-worktree-dirty-lock-check.js.map

package/dist/scripts/git-worktree-dirty-main-detection-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const detectionMod = await importDist('core/git/git-repo-detection.js');
+const repo = makeGitFixture('dirty-main-detection');
+fs.writeFileSync(path.join(repo, 'dirty.txt'), 'dirty\n');
+const detection = await detectionMod.detectGitRepo(repo);
+assertGate(detection.main_worktree_dirty === true, 'dirty main worktree must be detected', detection);
+assertGate(String(detection.status_porcelain).includes('dirty.txt'), 'status_porcelain must include dirty file', detection);
+emitGate('git:worktree-dirty-main-detection', { dirty: detection.main_worktree_dirty });
+//# sourceMappingURL=git-worktree-dirty-main-detection-check.js.map

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

@@ -0,0 +1,22 @@
+#!/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';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const diffMod = await importDist('core/git/git-worktree-diff.js');
+const mergeMod = await importDist('core/git/git-worktree-merge-queue.js');
+const repo = makeGitFixture('integration-primary');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-integration-'));
+const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-integrate', workerId: 'worker-1', slotId: 'slot-001' });
+fs.writeFileSync(path.join(allocation.worktree_path, 'a.txt'), 'alpha\nintegrated\n');
+const diff = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: allocation.worktree_path, missionId: 'M-integrate', workerId: 'worker-1' });
+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 });
+//# sourceMappingURL=git-worktree-integration-primary-check.js.map

package/dist/scripts/git-worktree-manifest-append-check.js

@@ -0,0 +1,18 @@
+#!/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';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const repo = makeGitFixture('worktree-manifest-append');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-manifest-'));
+const allocations = [];
+for (let index = 0; index < 4; index += 1) {
+    allocations.push(await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-manifest', workerId: `worker-${index}`, slotId: `slot-${index}` }));
+}
+const manifest = JSON.parse(fs.readFileSync(allocations[0].manifest_path, 'utf8'));
+assertGate(manifest.allocations.length >= allocations.length, 'manifest append must preserve allocations', manifest);
+emitGate('git:worktree-manifest-append', { allocations: manifest.allocations.length });
+//# sourceMappingURL=git-worktree-manifest-append-check.js.map

package/dist/scripts/git-worktree-untracked-diff-check.js

@@ -0,0 +1,18 @@
+#!/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';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const diffMod = await importDist('core/git/git-worktree-diff.js');
+const repo = makeGitFixture('untracked-diff');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-untracked-'));
+const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-untracked', workerId: 'worker-1', slotId: 'slot-001' });
+fs.writeFileSync(path.join(allocation.worktree_path, 'new-file.txt'), 'new content\n');
+const diff = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: allocation.worktree_path, missionId: 'M-untracked', workerId: 'worker-1' });
+assertGate(diff.changed_files.includes('new-file.txt'), 'changed files must include untracked file', diff);
+assertGate(diff.diff.includes('new file mode') && diff.diff.includes('+new content'), 'git diff must include untracked file content', { diff: diff.diff });
+emitGate('git:worktree-untracked-diff', { changed_files: diff.changed_files });
+//# sourceMappingURL=git-worktree-untracked-diff-check.js.map

package/dist/scripts/lib/codex-sdk-gate-lib.js

@@ -59,6 +59,10 @@ export async function runFakeCodexSdkTaskFixture(label = 'fixture', extra = {})
 export function packageScripts() {
     return readJson('package.json').scripts || {};
 }
+export function releaseGateIds() {
+    const manifest = readJson('release-gates.v2.json');
+    return new Set((manifest.gates || []).map((gate) => gate.id));
+}
 export function assertSourceIncludes(file, tokens) {
     const text = readText(file);
     for (const token of tokens)

package/dist/scripts/mad-sks-zellij-default-pane-worker-check.js

@@ -17,10 +17,10 @@ const checks = {
     zellij_session_before_swarm: launchIndex >= 0 && swarmIndex >= 0 && launchIndex < swarmIndex,
     main_only_session: mad.includes('slotCount: 0'),
     zellij_default_backend: /return 'zellij'/.test(mad) && mad.includes("list.includes('--json')") && mad.includes("list.includes('--no-attach')"),
-    worker_command_real_zellij: mad.includes("command.push('--real')") && mad.includes("command.push('--zellij-session-name'") && mad.includes("command.push('--zellij-pane-worker')"),
+    worker_command_real_zellij: mad.includes("command.push('--real')") && mad.includes("command.push('--zellij-session-name'") && mad.includes("command.push('--zellij-pane-worker')") && mad.includes("command.push('--worker-placement'"),
     parser_accepts_worker_flags: parser.includes('--zellij-session-name') && parser.includes('--zellij-pane-worker') && parser.includes('--no-zellij-pane-worker'),
     native_worker_pane_path: swarm.includes("this.input.backend === 'zellij'") && swarm.includes('ctx.opts.zellijPaneWorker !== false') && swarm.includes('openWorkerPane({'),
-    right_pane_requested: manager.includes("'--direction', 'right'")
+    right_pane_requested: manager.includes("'--direction', directionRequested") && manager.includes("'--near-current-pane'")
 };
 const ok = Object.values(checks).every(Boolean);
 emit({

package/dist/scripts/naruto-concurrency-governor-check.js

@@ -10,6 +10,7 @@ const normal = governorMod.decideNarutoConcurrency({
     zellijVisiblePaneCap: 12,
     hardware: {
         cores: 32,
+        loadAverage: [0, 0, 0],
         freeMemoryBytes: 48 * 1024 * 1024 * 1024,
         totalMemoryBytes: 64 * 1024 * 1024 * 1024,
         fileDescriptorLimit: 4096,
@@ -37,7 +38,7 @@ const pressure = governorMod.decideNarutoConcurrency({
         diskIoPressure: 0.9
     }
 });
-assertGate(normal.safe_active_workers <= 32, 'requested_clones=200 fixture must cap active workers safely', { normal });
+assertGate(normal.safe_active_workers >= 32 && normal.safe_active_workers <= 100, 'requested_clones=200 fixture must cap active workers safely while allowing aggressive process-pool fanout', { normal });
 assertGate(normal.safe_zellij_visible_panes === 12 && normal.headless_workers === normal.safe_active_workers - 12, 'zellij visible panes must stay within UI cap', { normal });
 assertGate(normal.local_llm_parallel <= 4, 'local LLM active requests must respect max_parallel_requests=4', { normal });
 assertGate(pressure.safe_active_workers < normal.safe_active_workers, 'memory/load pressure fixture must decrease active workers', { normal: normal.safe_active_workers, pressure: pressure.safe_active_workers });

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

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// @ts-nocheck
+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';
+const graph = buildNarutoWorkGraph({ requestedClones: 100, writeCapable: true, maxActiveWorkers: 32 });
+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 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,
+    graph: { total_work_items: graph.total_work_items, mixed_work_kinds: graph.mixed_work_kinds, write_allowed_count: graph.write_allowed_count },
+    governor
+};
+assertGate(report.ok, 'Naruto extreme parallelism must fan out >=2x clones and keep a high safe active pool', report);
+emitGate('naruto:extreme-parallelism', report);
+//# sourceMappingURL=naruto-extreme-parallelism-check.js.map

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

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+// @ts-nocheck
+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';
+const graph = buildNarutoWorkGraph({ requestedClones: 12, totalWorkItems: 24, writeCapable: true, maxActiveWorkers: 6 });
+const governor = decideNarutoConcurrency({
+    requestedClones: 12,
+    totalWorkItems: graph.total_work_items,
+    pendingWorkQueueSize: graph.total_work_items,
+    backend: 'codex-sdk',
+    hardware: { cpuCoreCount: 8, freeMemoryBytes: 32 * 1024 * 1024 * 1024, totalMemoryBytes: 64 * 1024 * 1024 * 1024, fileDescriptorLimit: 4096, processCount: 100, terminalRows: 40, remoteApiRateLimitBudget: 8 }
+});
+const target = { ...governor, safe_active_workers: Math.min(6, governor.safe_active_workers), safe_zellij_visible_panes: 3 };
+let spawned = 0;
+let collected = 0;
+let dashboardEvents = 0;
+const report = await runNarutoRealActivePool({
+    graph,
+    governor: target,
+    spawnWorker: async (item, placement) => {
+        spawned += 1;
+        return { id: item.id, item, placement, started_at: Date.now() };
+    },
+    collectWorker: async (handle) => {
+        collected += 1;
+        return { id: handle.id, ok: true, item: handle.item, placement: handle.placement, completed_at: Date.now() };
+    },
+    enqueueVerification: async () => undefined,
+    updateDashboard: async () => {
+        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;
+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 });
+//# sourceMappingURL=naruto-real-active-pool-check.js.map

package/dist/scripts/naruto-work-graph-check.js

@@ -11,7 +11,7 @@ const graph = workGraph.buildNarutoWorkGraph({
 });
 const validation = workGraph.validateNarutoWorkGraph(graph);
 assertGate(graph.ok === true && validation.ok === true, 'Naruto work graph must validate', { graph_blockers: graph.blockers, validation });
-assertGate(graph.total_work_items >= graph.requested_clones, 'work graph must create at least requested clone count', { total: graph.total_work_items, requested: graph.requested_clones });
+assertGate(graph.total_work_items >= graph.requested_clones * 2, 'write-capable work graph must create at least 2x requested clone count', { total: graph.total_work_items, requested: graph.requested_clones });
 assertGate(graph.mixed_work_kinds.length > 4, 'work graph must contain mixed work kinds, not only verification', { kinds: graph.mixed_work_kinds });
 assertGate(graph.write_allowed_count > 0, 'write-capable Naruto graph must include write_allowed work items', { write_allowed_count: graph.write_allowed_count });
 assertGate(graph.active_waves.every((wave) => wave.conflict_count === 0), 'active waves must not overlap write leases', { waves: graph.active_waves });

package/dist/scripts/naruto-worktree-coding-blackbox.js

@@ -0,0 +1,29 @@
+#!/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';
+import { makeGitFixture, run } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const diffMod = await importDist('core/git/git-worktree-diff.js');
+const mergeMod = await importDist('core/git/git-worktree-merge-queue.js');
+const repo = makeGitFixture('naruto-worktree-blackbox');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-blackbox-'));
+const allocations = [];
+for (const file of ['a.txt', 'b.txt']) {
+    const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-naruto-blackbox', workerId: file.replace('.txt', ''), slotId: file.replace('.txt', '') });
+    fs.writeFileSync(path.join(allocation.worktree_path, file), `${file}\nworker-change\n`);
+    allocations.push(allocation);
+}
+assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main worktree must remain unchanged before integration');
+const diffs = [];
+for (const allocation of allocations) {
+    diffs.push(await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: allocation.worktree_path, missionId: 'M-naruto-blackbox', workerId: allocation.worker_id }));
+}
+const integration = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-naruto-blackbox', workerId: 'integration', slotId: 'integration' });
+const report = await mergeMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: integration.worktree_path, diffs });
+assertGate(report.ok === true && report.applied_count === 2, 'integration worktree merge report must apply worker diffs', report);
+assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main worktree must remain unchanged after integration queue');
+emitGate('naruto:worktree-coding:blackbox', { allocations: allocations.length, applied_count: report.applied_count });
+//# sourceMappingURL=naruto-worktree-coding-blackbox.js.map