sneakoscope 2.0.18 → 3.0.1

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

@@ -5,7 +5,7 @@ import { resolveProviderContext } from '../provider/provider-context.js';
 import { runZellij } from './zellij-command.js';
 import { extractZellijPaneIdFromOutput } from './zellij-lane-runtime.js';
 import { buildZellijSlotColumnAnchorCommand } from './zellij-slot-column-anchor.js';
-import { closeWorkerInRightColumn, prepareWorkerInRightColumn, recordSlotColumnAnchorInRightColumn, recordWorkerPaneInRightColumn } from './zellij-right-column-manager.js';
+import { closeWorkerInRightColumn, prepareWorkerInRightColumn, readRightColumnState, recordSlotColumnAnchorInRightColumn, 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) {
@@ -75,6 +75,8 @@ export function buildWorkerPaneArtifact(input) {
         column_creation_direction_applied: input.columnCreationDirectionApplied ?? null,
         worker_direction_requested: input.workerDirectionRequested || 'down',
         worker_direction_applied: input.workerDirectionApplied || (directionApplied === 'down' ? 'down' : directionApplied === 'unknown' ? 'unknown' : 'not_applied'),
+        worker_stacked_requested: input.stackedRequested === true,
+        worker_stacked_applied: input.stackedApplied === true,
         slot_column_anchor_pane_id: input.slotColumnAnchorPaneId || null,
         right_column: input.rightColumn || null,
         sdk_thread_id: input.sdkThreadId || null,
@@ -155,163 +157,200 @@ export async function openWorkerPane(input) {
         return record;
     }
     const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || 'running', input.worktree || null);
-    let slotColumnAnchorPaneId = rightColumn?.state.slot_column_anchor_pane_id || null;
-    let anchorLaunch = null;
-    let columnCreationDirectionRequested = null;
-    let columnCreationDirectionApplied = null;
-    if (rightColumn && !rightColumn.focusPaneId && !slotColumnAnchorPaneId) {
-        columnCreationDirectionRequested = 'right';
-        const anchorCommand = buildZellijSlotColumnAnchorCommand({
-            cliPath: path.join(packageRoot(), 'dist', 'bin', 'sks.js'),
-            missionId: input.missionId,
-            mode: input.uiMode || 'compact-slots',
-            artifactRoot: root,
-            watch: true
-        });
-        anchorLaunch = createSession.ok
-            ? await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--direction', 'right', '--name', 'SLOTS', '--', 'sh', '-lc', anchorCommand], {
+    // CRITICAL: serialize anchor + worker pane creation per session. Workers
+    // launch concurrently, and without this lock every worker raced past the
+    // "does the SLOTS anchor exist yet?" check and created its OWN anchor with
+    // --direction right — splitting the screen into N side-by-side columns
+    // (observed in agent-zellij-pane-launch-ledger: terminal_1..terminal_5 all
+    // recorded as separate slot_column_anchor_pane_id values in one mission).
+    return withZellijPaneCreationLock(input.sessionName, async () => {
+        // Re-read the right-column state now that we hold the lock: a previously
+        // serialized worker may have created the anchor and/or its own pane.
+        const freshState = rightColumn
+            ? await readRightColumnState(root, input.missionId, input.projectRoot).catch(() => null)
+            : null;
+        let slotColumnAnchorPaneId = freshState?.slot_column_anchor_pane_id || rightColumn?.state.slot_column_anchor_pane_id || null;
+        const lastVisibleWorkerPaneId = [...(freshState?.visible_worker_panes || [])]
+            .filter((pane) => pane.pane_id && (pane.status === 'launching' || pane.status === 'running'))
+            .map((pane) => String(pane.pane_id))
+            .pop() || null;
+        const freshFocusCandidate = lastVisibleWorkerPaneId
+            || slotColumnAnchorPaneId
+            || freshState?.right_anchor_pane_id
+            || freshState?.dashboard_pane_id
+            || rightColumn?.focusPaneId
+            || null;
+        let anchorLaunch = null;
+        let columnCreationDirectionRequested = null;
+        let columnCreationDirectionApplied = null;
+        if (rightColumn && !freshFocusCandidate) {
+            columnCreationDirectionRequested = 'right';
+            const anchorCommand = buildZellijSlotColumnAnchorCommand({
+                cliPath: path.join(packageRoot(), 'dist', 'bin', 'sks.js'),
+                missionId: input.missionId,
+                mode: input.uiMode || 'compact-slots',
+                artifactRoot: root,
+                watch: true
+            });
+            anchorLaunch = createSession.ok
+                ? await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--direction', 'right', '--name', 'SLOTS', '--', 'sh', '-lc', anchorCommand], {
+                    cwd,
+                    timeoutMs: 5000,
+                    optional: false
+                })
+                : null;
+            slotColumnAnchorPaneId = anchorLaunch?.ok ? extractZellijPaneIdFromOutput(anchorLaunch.stdout_tail) : null;
+            columnCreationDirectionApplied = anchorLaunch?.ok ? (slotColumnAnchorPaneId ? 'right' : 'unknown') : 'not_applied';
+            if (slotColumnAnchorPaneId) {
+                await recordSlotColumnAnchorInRightColumn({
+                    root,
+                    ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+                    missionId: input.missionId,
+                    sessionName: input.sessionName,
+                    paneId: slotColumnAnchorPaneId
+                });
+            }
+        }
+        const focusPaneId = lastVisibleWorkerPaneId || slotColumnAnchorPaneId || freshFocusCandidate || null;
+        const directionRequested = 'down';
+        const focus = focusPaneId
+            ? await focusZellijPaneById(input.sessionName, focusPaneId, cwd)
+            : null;
+        // Vertical stack policy: the first worker splits DOWN from the SLOTS anchor;
+        // every following worker joins a zellij stacked-pane group with the previous
+        // worker (`new-pane --stacked`, zellij >= 0.43) so the right column stays a
+        // clean vertical stack instead of fragmenting the screen. Opt out with
+        // SKS_ZELLIJ_WORKER_STACKED=0.
+        const stackRequested = process.env.SKS_ZELLIJ_WORKER_STACKED !== '0'
+            && Boolean(lastVisibleWorkerPaneId)
+            && focus?.ok === true;
+        const newPaneArgs = stackRequested
+            ? ['--session', input.sessionName, 'action', 'new-pane', '--stacked', '--name', paneName, '--', 'sh', '-lc', input.workerCommand]
+            : ['--session', input.sessionName, 'action', 'new-pane', '--direction', directionRequested, '--near-current-pane', '--name', paneName, '--', 'sh', '-lc', input.workerCommand];
+        let launch = createSession.ok
+            ? await runZellij(newPaneArgs, {
                 cwd,
                 timeoutMs: 5000,
                 optional: false
             })
             : null;
-        slotColumnAnchorPaneId = anchorLaunch?.ok ? extractZellijPaneIdFromOutput(anchorLaunch.stdout_tail) : null;
-        columnCreationDirectionApplied = anchorLaunch?.ok ? (slotColumnAnchorPaneId ? 'right' : 'unknown') : 'not_applied';
-        if (slotColumnAnchorPaneId) {
-            await recordSlotColumnAnchorInRightColumn({
+        let stackApplied = Boolean(stackRequested && launch?.ok);
+        let directionApplied = launch?.ok ? directionRequested : 'not_applied';
+        if (createSession.ok && launch && !launch.ok) {
+            const fallbackArgs = ['--session', input.sessionName, 'action', 'new-pane', '--direction', directionRequested, '--name', paneName, '--', 'sh', '-lc', input.workerCommand];
+            const fallback = await runZellij(fallbackArgs, {
+                cwd,
+                timeoutMs: 5000,
+                optional: false
+            });
+            if (fallback.ok) {
+                launch = fallback;
+                stackApplied = false;
+                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
+                ? 'zellij_worker_list_panes'
+                : launch?.ok
+                    ? 'zellij_worker_pane_stdout_missing'
+                    : '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}`] : []),
+            ...(rightColumn && columnCreationDirectionRequested === 'right' && columnCreationDirectionApplied !== 'right' ? ['zellij_worker_slot_column_anchor_not_created'] : []),
+            ...(anchorLaunch && !anchorLaunch.ok ? anchorLaunch.blockers.map((blocker) => `zellij_worker_slot_column_anchor_${blocker}`) : []),
+            ...(launch && !launch.ok ? launch.blockers.map((blocker) => `zellij_worker_pane_${blocker}`) : []),
+            ...(launch?.ok && !isRealZellijWorkerPaneIdSource(paneIdSource) ? ['zellij_worker_pane_id_real_source_missing'] : [])
+        ];
+        const record = buildWorkerPaneArtifact({
+            ...input,
+            paneId,
+            paneIdSource,
+            createSession,
+            launch,
+            paneReconciliation: {
+                ...(reconciledPane || {}),
+                focus_pane: focus,
+                focus_degraded: focus ? focus.ok !== true : false,
+                slot_column_anchor_pane_id: slotColumnAnchorPaneId,
+                slot_column_anchor_launch: anchorLaunch,
+                rename_pane: renamePane
+            },
+            directionRequested,
+            directionApplied,
+            columnCreationDirectionRequested,
+            columnCreationDirectionApplied,
+            workerDirectionRequested: 'down',
+            workerDirectionApplied: directionApplied === 'down' ? 'down' : directionApplied === 'unknown' ? 'unknown' : 'not_applied',
+            stackedRequested: stackRequested,
+            stackedApplied: stackApplied,
+            slotColumnAnchorPaneId,
+            rightColumn: rightColumn ? { mode: 'spawn-on-first-worker', focus_pane_id: focusPaneId, y_order: rightColumn.yOrder, slot_column_anchor_pane_id: slotColumnAnchorPaneId } : 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,
-                sessionName: input.sessionName,
-                paneId: slotColumnAnchorPaneId
+                record,
+                yOrder: rightColumn.yOrder
             });
         }
-    }
-    const focusPaneId = rightColumn?.focusPaneId || slotColumnAnchorPaneId || null;
-    const directionRequested = 'down';
-    const focus = focusPaneId
-        ? await focusZellijPaneById(input.sessionName, focusPaneId, cwd)
-        : null;
-    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,
-            timeoutMs: 5000,
-            optional: false
-        })
-        : null;
-    let directionApplied = launch?.ok ? directionRequested : 'not_applied';
-    if (createSession.ok && launch && !launch.ok) {
-        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', '--direction', directionRequested, '--name', paneName, '--', 'sh', '-lc', input.workerCommand];
-        const fallback = await runZellij(fallbackArgs, {
-            cwd,
-            timeoutMs: 5000,
-            optional: false
+        await appendWorkerPaneEvent(root, 'zellij_worker_pane_created', input, {
+            ok: record.ok,
+            pane_id: record.pane_id,
+            pane_id_source: record.pane_id_source,
+            blockers
         });
-        if (fallback.ok) {
-            launch = fallback;
-            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
-            ? 'zellij_worker_list_panes'
-            : launch?.ok
-                ? 'zellij_worker_pane_stdout_missing'
-                : '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}`] : []),
-        ...(rightColumn && columnCreationDirectionRequested === 'right' && columnCreationDirectionApplied !== 'right' ? ['zellij_worker_slot_column_anchor_not_created'] : []),
-        ...(anchorLaunch && !anchorLaunch.ok ? anchorLaunch.blockers.map((blocker) => `zellij_worker_slot_column_anchor_${blocker}`) : []),
-        ...(launch && !launch.ok ? launch.blockers.map((blocker) => `zellij_worker_pane_${blocker}`) : []),
-        ...(launch?.ok && !isRealZellijWorkerPaneIdSource(paneIdSource) ? ['zellij_worker_pane_id_real_source_missing'] : [])
-    ];
-    const record = buildWorkerPaneArtifact({
-        ...input,
-        paneId,
-        paneIdSource,
-        createSession,
-        launch,
-        paneReconciliation: {
-            ...(reconciledPane || {}),
-            focus_pane: focus,
-            focus_degraded: focus ? focus.ok !== true : false,
-            slot_column_anchor_pane_id: slotColumnAnchorPaneId,
-            slot_column_anchor_launch: anchorLaunch,
-            rename_pane: renamePane
-        },
-        directionRequested,
-        directionApplied,
-        columnCreationDirectionRequested,
-        columnCreationDirectionApplied,
-        workerDirectionRequested: 'down',
-        workerDirectionApplied: directionApplied === 'down' ? 'down' : directionApplied === 'unknown' ? 'unknown' : 'not_applied',
-        slotColumnAnchorPaneId,
-        rightColumn: rightColumn ? { mode: 'spawn-on-first-worker', focus_pane_id: focusPaneId, y_order: rightColumn.yOrder, slot_column_anchor_pane_id: slotColumnAnchorPaneId } : 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 appendJsonl(path.join(root, 'agent-zellij-pane-launch-ledger.jsonl'), {
+            schema: 'sks.agent-zellij-pane-launch.v1',
+            generated_at: nowIso(),
+            launch_mode: record.ok ? 'real_zellij_worker_pane_session' : 'real_zellij_worker_pane_failed',
+            agent_id: input.slotId,
+            slot_id: input.slotId,
+            generation_index: input.generationIndex,
+            session_id: input.sessionId,
+            session_name: input.sessionName,
+            pane_name: paneName,
+            pane_title: paneName,
+            pane_kind: record.pane_kind,
+            pane_id: record.pane_id,
+            pane_id_source: record.pane_id_source,
+            provider: record.provider,
+            service_tier: record.service_tier,
+            provider_context: record.provider_context,
+            direction_requested: record.direction_requested,
+            direction_applied: record.direction_applied,
+            column_creation_direction_requested: record.column_creation_direction_requested || null,
+            column_creation_direction_applied: record.column_creation_direction_applied || null,
+            worker_direction_requested: record.worker_direction_requested,
+            worker_direction_applied: record.worker_direction_applied,
+            worker_stacked_requested: record.worker_stacked_requested === true,
+            worker_stacked_applied: record.worker_stacked_applied === true,
+            slot_column_anchor_pane_id: record.slot_column_anchor_pane_id || null,
+            command: record.command,
+            worker_artifact_dir: input.workerArtifactDir,
+            worker_result_path: input.resultPath,
+            heartbeat_path: input.heartbeatPath,
+            patch_envelope_path: input.patchEnvelopePath,
+            parent_child_transport: 'worker-result-json-and-heartbeat',
+            persistent_slot_lane: false,
+            scaling_primitive: record.scaling_primitive,
+            blockers
         });
-    }
-    await appendWorkerPaneEvent(root, 'zellij_worker_pane_created', input, {
-        ok: record.ok,
-        pane_id: record.pane_id,
-        pane_id_source: record.pane_id_source,
-        blockers
-    });
-    await appendJsonl(path.join(root, 'agent-zellij-pane-launch-ledger.jsonl'), {
-        schema: 'sks.agent-zellij-pane-launch.v1',
-        generated_at: nowIso(),
-        launch_mode: record.ok ? 'real_zellij_worker_pane_session' : 'real_zellij_worker_pane_failed',
-        agent_id: input.slotId,
-        slot_id: input.slotId,
-        generation_index: input.generationIndex,
-        session_id: input.sessionId,
-        session_name: input.sessionName,
-        pane_name: paneName,
-        pane_title: paneName,
-        pane_kind: record.pane_kind,
-        pane_id: record.pane_id,
-        pane_id_source: record.pane_id_source,
-        provider: record.provider,
-        service_tier: record.service_tier,
-        provider_context: record.provider_context,
-        direction_requested: record.direction_requested,
-        direction_applied: record.direction_applied,
-        column_creation_direction_requested: record.column_creation_direction_requested || null,
-        column_creation_direction_applied: record.column_creation_direction_applied || null,
-        worker_direction_requested: record.worker_direction_requested,
-        worker_direction_applied: record.worker_direction_applied,
-        slot_column_anchor_pane_id: record.slot_column_anchor_pane_id || null,
-        command: record.command,
-        worker_artifact_dir: input.workerArtifactDir,
-        worker_result_path: input.resultPath,
-        heartbeat_path: input.heartbeatPath,
-        patch_envelope_path: input.patchEnvelopePath,
-        parent_child_transport: 'worker-result-json-and-heartbeat',
-        persistent_slot_lane: false,
-        scaling_primitive: record.scaling_primitive,
-        blockers
+        return record;
     });
-    return record;
 }
 export async function closeWorkerPane(input) {
     const root = path.resolve(input.root);
@@ -547,6 +586,14 @@ async function focusZellijPaneById(sessionName, paneId, cwd) {
         last = focus;
         if (focus.ok)
             return focus;
+        // zellij exits non-zero with "Pane Terminal(N) is already focused" when the
+        // target pane already holds focus (common: new-pane auto-focuses the pane
+        // it created, so the previous worker pane is usually still focused). That
+        // is a success for our purposes — without this, stacked placement would
+        // silently fall back to a plain down-split on every consecutive worker.
+        if (/already focused/i.test(`${focus.stdout_tail || ''} ${focus.stderr_tail || ''}`)) {
+            return { ...focus, ok: true, blockers: [], warnings: [...focus.warnings, 'zellij_pane_already_focused'] };
+        }
     }
     return last;
 }
@@ -579,6 +626,25 @@ function zellijPaneIdCandidates(paneId) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+const zellijPaneCreationLocks = new Map();
+async function withZellijPaneCreationLock(sessionName, fn) {
+    const key = String(sessionName || 'default');
+    const previous = zellijPaneCreationLocks.get(key) || Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    zellijPaneCreationLocks.set(key, previous.then(() => current, () => current));
+    await previous.catch(() => undefined);
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+        if (zellijPaneCreationLocks.get(key) === current)
+            zellijPaneCreationLocks.delete(key);
+    }
+}
 function normalizeExistingZellijSession(sessionName, result) {
     if (result.ok)
         return result;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "2.0.18",
+  "version": "3.0.1",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -24,6 +24,10 @@
   "files": [
     "dist",
     "!dist/build-manifest.json",
+    "!dist/**/*.d.ts",
+    "!dist/**/*.d.ts.map",
+    "!dist/**/*.js.map",
+    "!dist/**/*.tsbuildinfo",
     "!dist/vendor/openai-codex/rust-v0.131.0",
     "!dist/scripts/*-blackbox.js",
     "!dist/scripts/*-check.js",
@@ -558,6 +562,7 @@
     "release:check:dag:no-cache": "node ./dist/scripts/release-gate-dag-runner.js --preset release --no-cache",
     "release:check:dag:fail-fast": "node ./dist/scripts/release-gate-dag-runner.js --preset release --fail-fast",
     "codex:0138-capability": "node ./dist/scripts/codex-0138-capability-check.js",
+    "codex:0139-capability": "node ./dist/scripts/codex-0139-capability-check.js",
     "codex:0138-capability-artifact": "node ./dist/scripts/codex-0138-capability-artifact-check.js",
     "codex-sdk:version-compat": "node ./dist/scripts/codex-sdk-version-compat-check.js",
     "codex-app:handoff": "node ./dist/scripts/codex-app-handoff-check.js",
@@ -680,7 +685,23 @@
     "mad-db:mcp-result-lifecycle": "node ./dist/scripts/mad-db-mcp-result-lifecycle-check.js",
     "mad-db:operation-lifecycle-blackbox": "node ./dist/scripts/mad-db-operation-lifecycle-blackbox.js",
     "runtime:proof-summary": "node ./dist/scripts/runtime-proof-summary-check.js",
-    "runtime:proof-summary-cli": "node ./dist/scripts/runtime-proof-summary-cli-check.js"
+    "runtime:proof-summary-cli": "node ./dist/scripts/runtime-proof-summary-cli-check.js",
+    "codex-app:launcher": "node ./dist/scripts/codex-app-launcher-check.js",
+    "codex-app:handoff-launch": "node ./dist/scripts/codex-app-handoff-launch-check.js",
+    "qa-loop:app-handoff-launch": "node ./dist/scripts/qa-loop-app-handoff-launch-check.js",
+    "qa-loop:app-handoff-confirmation": "node ./dist/scripts/qa-loop-app-handoff-confirmation-check.js",
+    "qa-loop:app-handoff-status-lifecycle": "node ./dist/scripts/qa-loop-app-handoff-status-lifecycle-check.js",
+    "qa-loop:app-handoff-gate-lifecycle": "node ./dist/scripts/qa-loop-app-handoff-gate-lifecycle-check.js",
+    "codex-plugin:parallel-detail-fetch": "node ./dist/scripts/codex-plugin-parallel-detail-fetch-check.js",
+    "codex-plugin:cache": "node ./dist/scripts/codex-plugin-cache-check.js",
+    "codex-plugin:diff": "node ./dist/scripts/codex-plugin-diff-check.js",
+    "image:artifact-registry": "node ./dist/scripts/image-artifact-registry-check.js",
+    "image:global-path-contract": "node ./dist/scripts/image-global-path-contract-check.js",
+    "qa-loop:image-path-prompt-injection": "node ./dist/scripts/qa-loop-image-path-prompt-injection-check.js",
+    "codex:model-metadata": "node ./dist/scripts/codex-model-metadata-check.js",
+    "codex:effort-auto-discovery": "node ./dist/scripts/codex-effort-auto-discovery-check.js",
+    "codex:account-usage-autodiscovery": "node ./dist/scripts/codex-account-usage-autodiscovery-check.js",
+    "codex:0138-feature-probes": "node ./dist/scripts/codex-0138-feature-probes-check.js"
   },
   "keywords": [
     "sneakoscope",

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

@@ -1,11 +0,0 @@
-export function stealNarutoWork(queue, input = {}) {
-    const item = queue.shift() || null;
-    return {
-        schema: 'sks.naruto-work-stealing.v1',
-        stolen: Boolean(item),
-        work_item_id: item?.id || null,
-        from_queue: input.fromQueue || 'pending',
-        to_slot: input.toSlot || 'idle-slot'
-    };
-}
-//# sourceMappingURL=naruto-work-stealing.js.map

package/dist/core/zellij/zellij-right-column-layout-proof.js

@@ -1,42 +0,0 @@
-export function evaluateZellijRightColumnGeometry(input) {
-    const tolerance = Math.max(0, Number(input.tolerance ?? 2));
-    const main = input.panes.find((pane) => pane.role === 'main') || null;
-    const dashboard = input.panes.find((pane) => pane.role === 'dashboard') || null;
-    const workers = input.panes.filter((pane) => pane.role === 'worker');
-    const workerGeometries = workers.map((pane) => pane.geometry).filter(Boolean);
-    const baseX = workerGeometries[0]?.x;
-    const sameRightX = baseX == null ? null : workerGeometries.every((geometry) => geometry.x != null && Math.abs(geometry.x - baseX) <= tolerance);
-    const rightOfMain = !main?.geometry ? null : workerGeometries.every((geometry) => {
-        if (geometry.x == null || main.geometry?.x == null || main.geometry?.width == null)
-            return false;
-        return geometry.x >= main.geometry.x + main.geometry.width - tolerance;
-    });
-    const increasingY = workerGeometries.every((geometry, index) => {
-        if (index === 0)
-            return true;
-        const previous = workerGeometries[index - 1];
-        return geometry.y != null && previous?.y != null && geometry.y > previous.y;
-    });
-    const visibleCapOk = workers.length <= Math.max(0, Math.floor(Number(input.visiblePaneCap || 0)));
-    const blockers = [
-        ...(!main ? ['right_column_main_pane_missing'] : []),
-        ...(!dashboard ? ['right_column_dashboard_missing'] : []),
-        ...(sameRightX === false ? ['right_column_worker_x_range_mismatch'] : []),
-        ...(rightOfMain === false ? ['right_column_workers_not_right_of_main'] : []),
-        ...(increasingY === false ? ['right_column_workers_not_stacked_down'] : []),
-        ...(visibleCapOk ? [] : ['right_column_visible_cap_exceeded'])
-    ];
-    return {
-        schema: 'sks.zellij-right-column-layout-proof.v1',
-        ok: blockers.length === 0,
-        main_pane_id: main?.pane_id || null,
-        dashboard_pane_id: dashboard?.pane_id || null,
-        worker_pane_ids: workers.map((pane) => pane.pane_id),
-        same_right_x: sameRightX,
-        right_of_main: rightOfMain,
-        increasing_y: increasingY,
-        visible_cap_ok: visibleCapOk,
-        blockers
-    };
-}
-//# sourceMappingURL=zellij-right-column-layout-proof.js.map