sneakoscope 3.0.1 → 3.0.3

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

@@ -1,13 +1,16 @@
 import path from 'node:path';
 import { appendJsonl, ensureDir, nowIso, packageRoot, readJson, writeJsonAtomic } from '../fsx.js';
+import { appendParallelRuntimeEvent } from '../agents/parallel-runtime-proof.js';
 import { providerPaneLabel } from '../provider/provider-badge.js';
 import { resolveProviderContext } from '../provider/provider-context.js';
+import { checkZellijStackedPaneCapability } from './zellij-capability.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, 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 const ZELLIJ_PANE_CREATION_LOCK_METRICS_SCHEMA = 'sks.zellij-pane-creation-lock-metrics.v1';
 export function buildWorkerPaneName(slotId, generationIndex) {
     return `${slotId}/gen-${Math.max(1, Math.floor(Number(generationIndex) || 1))}`;
 }
@@ -77,12 +80,15 @@ export function buildWorkerPaneArtifact(input) {
         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,
+        worker_stacked_fallback_mode: input.stackedFallbackMode || null,
+        worker_stacked_capability: input.stackedCapability || null,
         slot_column_anchor_pane_id: input.slotColumnAnchorPaneId || null,
         right_column: input.rightColumn || null,
         sdk_thread_id: input.sdkThreadId || null,
         sdk_run_id: input.sdkRunId || null,
         stream_event_count: Number(input.streamEventCount || 0),
         structured_output_valid: input.structuredOutputValid === true,
+        warnings: input.warnings || [],
         blockers
     };
 }
@@ -163,7 +169,7 @@ export async function openWorkerPane(input) {
     // --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 () => {
+    return withZellijPaneCreationLock(input, 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
@@ -221,9 +227,23 @@ export async function openWorkerPane(input) {
         // 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'
+        const stackIntent = process.env.SKS_ZELLIJ_WORKER_STACKED !== '0'
             && Boolean(lastVisibleWorkerPaneId)
             && focus?.ok === true;
+        const stackedCapability = stackIntent
+            ? await checkZellijStackedPaneCapability({ writeReport: false }).catch((err) => ({
+                schema: 'sks.zellij-stacked-pane-capability.v1',
+                ok: false,
+                zellij_bin: 'zellij',
+                version_text: null,
+                parsed_version: null,
+                supports_stacked_panes: false,
+                requires_update: false,
+                fallback_mode: 'headless-only',
+                blockers: [`zellij_stacked_capability_check_failed:${err?.code || err?.message || String(err)}`]
+            }))
+            : null;
+        const stackRequested = stackIntent && stackedCapability?.supports_stacked_panes === 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];
@@ -236,6 +256,7 @@ export async function openWorkerPane(input) {
             : null;
         let stackApplied = Boolean(stackRequested && launch?.ok);
         let directionApplied = launch?.ok ? directionRequested : 'not_applied';
+        let stackedRejectedFallback = false;
         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, {
@@ -246,6 +267,7 @@ export async function openWorkerPane(input) {
             if (fallback.ok) {
                 launch = fallback;
                 stackApplied = false;
+                stackedRejectedFallback = stackRequested;
                 directionApplied = rightColumn ? 'down' : 'unknown';
             }
         }
@@ -268,6 +290,10 @@ export async function openWorkerPane(input) {
             ...(launch && !launch.ok ? launch.blockers.map((blocker) => `zellij_worker_pane_${blocker}`) : []),
             ...(launch?.ok && !isRealZellijWorkerPaneIdSource(paneIdSource) ? ['zellij_worker_pane_id_real_source_missing'] : [])
         ];
+        const warnings = [
+            ...(stackIntent && stackedCapability && !stackedCapability.supports_stacked_panes ? [`zellij_stacked_pane_fallback:${stackedCapability.fallback_mode}`] : []),
+            ...(stackedRejectedFallback ? ['zellij_stacked_pane_rejected_fallback_down'] : [])
+        ];
         const record = buildWorkerPaneArtifact({
             ...input,
             paneId,
@@ -288,13 +314,16 @@ export async function openWorkerPane(input) {
             columnCreationDirectionApplied,
             workerDirectionRequested: 'down',
             workerDirectionApplied: directionApplied === 'down' ? 'down' : directionApplied === 'unknown' ? 'unknown' : 'not_applied',
-            stackedRequested: stackRequested,
+            stackedRequested: stackIntent,
             stackedApplied: stackApplied,
+            stackedFallbackMode: stackIntent ? (stackApplied ? 'native-stacked' : stackedCapability?.fallback_mode || 'down-split-stack-emulation') : null,
+            stackedCapability,
             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,
+            warnings,
             blockers
         });
         await writeWorkerPaneArtifact(root, record);
@@ -311,8 +340,27 @@ export async function openWorkerPane(input) {
             ok: record.ok,
             pane_id: record.pane_id,
             pane_id_source: record.pane_id_source,
+            worker_stacked_requested: record.worker_stacked_requested === true,
+            worker_stacked_applied: record.worker_stacked_applied === true,
+            worker_stacked_fallback_mode: record.worker_stacked_fallback_mode || null,
             blockers
         });
+        await appendParallelRuntimeEvent(root, input.missionId, {
+            event_type: 'zellij_pane_created',
+            slot_id: input.slotId,
+            generation_index: input.generationIndex,
+            session_id: input.sessionId,
+            pid: null,
+            backend: String(input.backend || 'zellij'),
+            placement: 'zellij-pane',
+            meta: {
+                ok: record.ok,
+                pane_id: record.pane_id,
+                worker_stacked_requested: record.worker_stacked_requested === true,
+                worker_stacked_applied: record.worker_stacked_applied === true,
+                worker_stacked_fallback_mode: record.worker_stacked_fallback_mode || null
+            }
+        }).catch(() => undefined);
         await appendJsonl(path.join(root, 'agent-zellij-pane-launch-ledger.jsonl'), {
             schema: 'sks.agent-zellij-pane-launch.v1',
             generated_at: nowIso(),
@@ -338,6 +386,7 @@ export async function openWorkerPane(input) {
             worker_direction_applied: record.worker_direction_applied,
             worker_stacked_requested: record.worker_stacked_requested === true,
             worker_stacked_applied: record.worker_stacked_applied === true,
+            worker_stacked_fallback_mode: record.worker_stacked_fallback_mode || null,
             slot_column_anchor_pane_id: record.slot_column_anchor_pane_id || null,
             command: record.command,
             worker_artifact_dir: input.workerArtifactDir,
@@ -627,8 +676,20 @@ function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 const zellijPaneCreationLocks = new Map();
-async function withZellijPaneCreationLock(sessionName, fn) {
-    const key = String(sessionName || 'default');
+async function withZellijPaneCreationLock(input, fn) {
+    const key = String(input.sessionName || 'default');
+    const requestedAt = nowIso();
+    const requestedMs = Date.now();
+    await appendWorkerPaneEvent(path.resolve(input.root), 'zellij_pane_creation_lock_requested', input, {}).catch(() => undefined);
+    await appendParallelRuntimeEvent(path.resolve(input.root), input.missionId, {
+        event_type: 'zellij_pane_creation_lock_requested',
+        slot_id: input.slotId,
+        generation_index: input.generationIndex,
+        session_id: input.sessionId,
+        pid: null,
+        backend: String(input.backend || 'zellij'),
+        placement: 'zellij-pane'
+    }).catch(() => undefined);
     const previous = zellijPaneCreationLocks.get(key) || Promise.resolve();
     let release;
     const current = new Promise((resolve) => {
@@ -636,15 +697,65 @@ async function withZellijPaneCreationLock(sessionName, fn) {
     });
     zellijPaneCreationLocks.set(key, previous.then(() => current, () => current));
     await previous.catch(() => undefined);
+    const acquiredAt = nowIso();
+    const acquiredMs = Date.now();
+    await appendWorkerPaneEvent(path.resolve(input.root), 'zellij_pane_creation_lock_acquired', input, { wait_ms: acquiredMs - requestedMs }).catch(() => undefined);
+    await appendParallelRuntimeEvent(path.resolve(input.root), input.missionId, {
+        event_type: 'zellij_pane_creation_lock_acquired',
+        slot_id: input.slotId,
+        generation_index: input.generationIndex,
+        session_id: input.sessionId,
+        pid: null,
+        backend: String(input.backend || 'zellij'),
+        placement: 'zellij-pane',
+        meta: { wait_ms: acquiredMs - requestedMs }
+    }).catch(() => undefined);
     try {
         return await fn();
     }
     finally {
+        const releasedAt = nowIso();
+        const releasedMs = Date.now();
+        const metrics = {
+            schema: ZELLIJ_PANE_CREATION_LOCK_METRICS_SCHEMA,
+            mission_id: input.missionId,
+            session_name: input.sessionName,
+            slot_id: input.slotId,
+            generation_index: input.generationIndex,
+            requested_at: requestedAt,
+            acquired_at: acquiredAt,
+            released_at: releasedAt,
+            wait_ms: acquiredMs - requestedMs,
+            held_ms: releasedMs - acquiredMs
+        };
+        await appendJsonl(paneCreationLockMetricsPath(path.resolve(input.root), input.missionId), metrics).catch(() => undefined);
+        await appendWorkerPaneEvent(path.resolve(input.root), 'zellij_pane_creation_lock_released', input, { wait_ms: metrics.wait_ms, held_ms: metrics.held_ms }).catch(() => undefined);
+        await appendParallelRuntimeEvent(path.resolve(input.root), input.missionId, {
+            event_type: 'zellij_pane_creation_lock_released',
+            slot_id: input.slotId,
+            generation_index: input.generationIndex,
+            session_id: input.sessionId,
+            pid: null,
+            backend: String(input.backend || 'zellij'),
+            placement: 'zellij-pane',
+            meta: { wait_ms: metrics.wait_ms, held_ms: metrics.held_ms }
+        }).catch(() => undefined);
         release();
         if (zellijPaneCreationLocks.get(key) === current)
             zellijPaneCreationLocks.delete(key);
     }
 }
+function paneCreationLockMetricsPath(root, missionId) {
+    return path.join(missionArtifactRoot(root, missionId), 'zellij', 'pane-creation-lock-events.jsonl');
+}
+function missionArtifactRoot(root, missionId) {
+    const resolved = path.resolve(root);
+    if (path.basename(resolved) === 'agents')
+        return path.dirname(resolved);
+    if (path.basename(resolved) === missionId)
+        return resolved;
+    return path.join(resolved, '.sneakoscope', 'missions', missionId);
+}
 function normalizeExistingZellijSession(sessionName, result) {
     if (result.ok)
         return result;

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

@@ -0,0 +1,65 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { readJson, readText, writeJsonAtomic } from '../fsx.js';
+export async function buildZellijWorkerPaneSummary(root, missionId) {
+    const missionDir = path.join(path.resolve(root), '.sneakoscope', 'missions', missionId);
+    const ledgerRows = await readJsonl(path.join(path.resolve(root), 'agent-zellij-pane-launch-ledger.jsonl'));
+    const missionRows = ledgerRows.filter((row) => !row.mission_id || row.mission_id === missionId);
+    const state = await readJson(path.join(missionDir, 'zellij-right-column-state.json'), null);
+    const metrics = await readJsonl(path.join(missionDir, 'zellij', 'pane-creation-lock-events.jsonl'));
+    const requested = missionRows.filter((row) => row.worker_stacked_requested === true);
+    const applied = missionRows.filter((row) => row.worker_stacked_applied === true);
+    const fallbackRows = missionRows.filter((row) => row.worker_stacked_requested === true && row.worker_stacked_applied !== true);
+    const fallbackModes = {};
+    for (const row of fallbackRows) {
+        const mode = String(row.worker_stacked_fallback_mode || 'unknown');
+        fallbackModes[mode] = (fallbackModes[mode] || 0) + 1;
+    }
+    const anchors = new Set([
+        ...missionRows.map((row) => row.slot_column_anchor_pane_id).filter(Boolean).map(String),
+        ...(state?.slot_column_anchor_pane_id ? [String(state.slot_column_anchor_pane_id)] : [])
+    ]);
+    const stackedCapable = missionRows.some((row) => row.worker_stacked_capability?.supports_stacked_panes === true);
+    const waitP95 = percentile(metrics.map((row) => Number(row.wait_ms || 0)), 0.95);
+    const heldP95 = percentile(metrics.map((row) => Number(row.held_ms || 0)), 0.95);
+    const blockers = [
+        ...(anchors.size > 1 ? ['zellij_duplicate_slot_anchor_count_gt_1'] : []),
+        ...(requested.length > 0 && applied.length === 0 && stackedCapable ? ['zellij_stacked_requested_but_none_applied'] : []),
+        ...(waitP95 > 5000 && requested.length <= 1 ? ['zellij_pane_lock_wait_high_with_low_concurrency'] : [])
+    ];
+    const summary = {
+        schema: 'sks.zellij-worker-pane-summary.v1',
+        ok: blockers.length === 0,
+        mission_id: missionId,
+        stacked_requested_count: requested.length,
+        stacked_applied_count: applied.length,
+        stacked_fallback_count: fallbackRows.length,
+        fallback_modes: fallbackModes,
+        pane_lock_wait_p95_ms: waitP95,
+        pane_lock_held_p95_ms: heldP95,
+        duplicate_slot_anchor_count: anchors.size,
+        blockers
+    };
+    await writeJsonAtomic(path.join(missionDir, 'zellij-worker-pane-summary.json'), summary);
+    await writeJsonAtomic(path.join(path.resolve(root), '.sneakoscope', 'reports', 'zellij-worker-pane-summary.json'), summary);
+    return summary;
+}
+async function readJsonl(file) {
+    const text = await readText(file, '').catch(() => '');
+    return String(text || '').split(/\n+/).filter(Boolean).flatMap((line) => {
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+function percentile(values, p) {
+    const sorted = values.filter((value) => Number.isFinite(value)).sort((a, b) => a - b);
+    if (!sorted.length)
+        return 0;
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * p) - 1));
+    return Math.round(sorted[index] || 0);
+}
+//# sourceMappingURL=zellij-worker-pane-summary.js.map

package/dist/scripts/github-release-body-helper.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, root } from './sks-1-18-gate-lib.js';
+const args = process.argv.slice(2);
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const truth = readJson('.sneakoscope/release-proof-truth.json') || readJson('dist/release-proof-truth.json');
+const codex0139 = readJson('.sneakoscope/codex-0139-capability.json');
+const zellij = readJson('.sneakoscope/reports/zellij-worker-pane-summary.json');
+const changelog = fs.readFileSync(path.join(root, 'CHANGELOG.md'), 'utf8');
+const latest = latestChangelogSection(changelog);
+const sdkVersion = readCodexSdkPackageVersion();
+const warnings = [
+    ...(truth?.package_version && truth.package_version !== latest.version ? [`package version ${truth.package_version} does not match changelog latest ${latest.version}`] : []),
+    ...(pkg.version !== latest.version ? [`package.json version ${pkg.version} does not match changelog latest ${latest.version}`] : []),
+    ...(!truth ? ['release proof truth missing'] : []),
+    ...(truth?.git_status_clean === false ? ['git working tree dirty when proof truth was generated'] : [])
+];
+const body = [
+    `Version: ${pkg.version}`,
+    `Commit: ${truth?.git_commit_sha || 'unknown'}`,
+    `Dirty: ${truth?.git_status_clean === false ? 'yes' : truth?.git_status_clean === true ? 'no' : 'unknown'}`,
+    `Release proof truth: ${truth ? '.sneakoscope/release-proof-truth.json' : 'missing'}`,
+    `Codex SDK package: ${sdkVersion || 'unknown'}`,
+    `External Codex CLI 0.139 capability: ${codex0139 ? `${codex0139.ok ? 'ok' : 'blocked'}${codex0139.parsed_version ? ` (${codex0139.parsed_version})` : ''}` : 'not recorded'}`,
+    `Zellij stacked panes: ${zellij ? `${zellij.stacked_applied_count || 0}/${zellij.stacked_requested_count || 0} applied, fallback ${zellij.stacked_fallback_count || 0}, SLOTS anchors ${zellij.duplicate_slot_anchor_count || 0}` : 'not recorded'}`,
+    `Packlist: ${truth?.npm_packlist_count ?? 'unknown'} files / ${truth?.npm_packlist_bytes ?? 'unknown'} bytes`,
+    ...(warnings.length ? [`Warnings: ${warnings.join('; ')}`] : ['Warnings: none']),
+    'Release gates: passed',
+    '',
+    latest.body.trim()
+].join('\n');
+if (args.includes('--check')) {
+    assertGate(Boolean(truth && truth.schema === 'sks.release-proof-truth.v1'), 'release proof truth missing; run npm run release:proof-truth first');
+    assertGate(latest.version === pkg.version, 'latest changelog section must match package version', { latest: latest.version, package: pkg.version });
+    assertGate(body.includes(`Version: ${pkg.version}`) && body.includes('Commit:') && body.includes('Dirty:') && body.includes('Release proof truth:') && body.includes('Codex SDK package:') && body.includes('External Codex CLI 0.139 capability:') && body.includes('Zellij stacked panes:') && body.includes('Packlist:'), 'github release body helper missing source truth fields', { body });
+    assertGate(!warnings.some((warning) => warning.includes('package version') || warning.includes('changelog latest') || warning.includes('release proof truth missing')), 'github release body helper source truth warnings must not include version/proof mismatch', { warnings, body });
+}
+console.log(body);
+function readJson(rel) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(root, rel), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function latestChangelogSection(text) {
+    const matches = [...text.matchAll(/^## \[([^\]]+)\][^\n]*\n/gm)];
+    const first = matches.find((match) => /^[0-9]+\.[0-9]+\.[0-9]+$/.test(match[1]));
+    if (!first)
+        return { version: null, body: '' };
+    const second = matches.find((match) => (match.index || 0) > (first.index || 0));
+    const start = (first.index || 0) + first[0].length;
+    const end = second?.index || text.length;
+    return { version: first[1], body: text.slice(start, end) };
+}
+function readCodexSdkPackageVersion() {
+    const lock = readJson('package-lock.json');
+    return lock?.packages?.['node_modules/@openai/codex-sdk']?.version || pkg.dependencies?.['@openai/codex-sdk'] || null;
+}
+//# sourceMappingURL=github-release-body-helper.js.map

package/dist/scripts/release-speed-summary.js

@@ -25,6 +25,17 @@ console.log(JSON.stringify({
     skipped_gate_ids: summary?.skipped_by_affected || [],
     cached: summary?.cached || 0,
     cached_gates: summary?.cached_gates || [],
+    version_neutralized_inputs: [
+        'package.json:version',
+        'package-lock.json:root.version',
+        'src/core/version.ts:PACKAGE_VERSION',
+        'src/core/fsx.ts:PACKAGE_VERSION',
+        'src/bin/sks.ts:FAST_PACKAGE_VERSION',
+        'dist/build-manifest.json:version'
+    ],
+    behavior_affecting_inputs: [],
+    cache_key_policy: 'version-neutral-safe-v1',
+    cache_message: 'Release cache: version-only changes neutralized for behavior gates. Version correctness gates still ran uncached.',
     executed: summary?.executed_gates?.length || 0,
     executed_gates: summary?.executed_gates || [],
     wall_ms: summary?.wall_ms || 0,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -701,7 +701,38 @@
     "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"
+    "codex:0138-feature-probes": "node ./dist/scripts/codex-0138-feature-probes-check.js",
+    "zellij:stacked-version-parser": "node ./dist/scripts/zellij-stacked-version-parser-check.js",
+    "zellij:stacked-version-matrix": "node ./dist/scripts/zellij-stacked-version-matrix-check.js",
+    "zellij:stacked-capability-routing": "node ./dist/scripts/zellij-stacked-capability-routing-check.js",
+    "zellij:pane-creation-lock-metrics": "node ./dist/scripts/zellij-pane-creation-lock-metrics-check.js",
+    "zellij:pane-lock-does-not-block-worker": "node ./dist/scripts/zellij-pane-lock-does-not-block-worker-check.js",
+    "zellij:pane-lock-concurrency-blackbox": "node ./dist/scripts/zellij-pane-lock-concurrency-blackbox.js",
+    "release:cache-input-classifier": "node ./dist/scripts/release-cache-input-classifier-check.js",
+    "release:cache-version-neutral-fixtures": "node ./dist/scripts/release-cache-version-neutral-fixture-check.js",
+    "release:cache-neutralization-report": "node ./dist/scripts/release-cache-neutralization-report-check.js",
+    "agent:message-bus-reader": "node ./dist/scripts/agent-message-bus-reader-check.js",
+    "runtime:proof-summary-messages": "node ./dist/scripts/runtime-proof-summary-messages-check.js",
+    "naruto:proof-message-summary": "node ./dist/scripts/naruto-proof-message-summary-check.js",
+    "zellij:update-prompt-mode": "node ./dist/scripts/zellij-update-prompt-mode-check.js",
+    "zellij:update-prompt-safety": "node ./dist/scripts/zellij-update-prompt-safety-check.js",
+    "zellij:update-prompt-matrix": "node ./dist/scripts/zellij-update-prompt-matrix-check.js",
+    "release:proof-truth": "node ./dist/scripts/release-proof-truth-check.js",
+    "release:github-body-helper": "node ./dist/scripts/github-release-body-helper.js --check",
+    "codex:0139-feature-probes": "node ./dist/scripts/codex-0139-feature-probes-check.js",
+    "codex:0139-interrupt-agent": "node ./dist/scripts/codex-0139-interrupt-agent-check.js",
+    "codex:0139-rich-tool-schema": "node ./dist/scripts/codex-0139-rich-tool-schema-check.js",
+    "codex:0139-doctor-env-redaction": "node ./dist/scripts/codex-0139-doctor-env-redaction-check.js",
+    "codex:0139-code-mode-web-search": "node ./dist/scripts/codex-0139-code-mode-web-search-check.js",
+    "codex:0139-marketplace-source": "node ./dist/scripts/codex-0139-marketplace-source-check.js",
+    "codex:0139-sandbox-profile-alias": "node ./dist/scripts/codex-0139-sandbox-profile-alias-check.js",
+    "codex:0139-real-probes": "node ./dist/scripts/codex-0139-real-probes-check.js --require-real",
+    "zellij:fake-adapter": "node ./dist/scripts/zellij-fake-adapter-check.js",
+    "zellij:pane-lock-open-worker-integration": "node ./dist/scripts/zellij-pane-lock-open-worker-integration-blackbox.js",
+    "zellij:stacked-fallback-integration": "node ./dist/scripts/zellij-stacked-fallback-integration-blackbox.js",
+    "runtime:proof-zellij-stacked-summary": "node ./dist/scripts/runtime-proof-zellij-stacked-summary-check.js",
+    "naruto:proof-zellij-stacked-summary": "node ./dist/scripts/naruto-proof-zellij-stacked-summary-check.js",
+    "docs:codex-0139-wording": "node ./dist/scripts/docs-codex-0139-wording-check.js"
   },
   "keywords": [
     "sneakoscope",