sneakoscope 3.0.2 → 3.0.3

package/README.md

@@ -35,7 +35,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **3.0.2** tracks Codex CLI `rust-v0.139.0` and hardens the 3.0.0 swarm release: capability detection for code-mode web search, preserved `oneOf`/`allOf` tool schemas, plugin marketplace `source`/cached catalog, the `-P` sandbox profile alias, the multi-agent v2 `interrupt_agent` rename, Zellij stacked-pane version gates, pane-lock concurrency proof, release cache safety fixtures, agent message proof summaries, and release proof source-truth artifacts. See [docs/codex-0.139-compat.md](docs/codex-0.139-compat.md).
+SKS **3.0.3** is Codex 0.139-aware while it bundles @openai/codex-sdk 0.138.0 at this release boundary. It detects and uses 0.139 features from the external Codex CLI when that CLI supports them, with release gates that include hermetic fixtures and optional real probes for code-mode web search markers, preserved `oneOf`/`allOf` tool schemas, plugin marketplace `source`, the `-P` profile alias, the multi-agent v2 `interrupt_agent` rename, Zellij stacked/fallback pane proof, pane-lock openWorkerPane integration, release cache safety fixtures, runtime proof summaries, and release proof source-truth artifacts. See [docs/codex-0.139-compat.md](docs/codex-0.139-compat.md).
 
 SKS 3.0.0 was the parallel-runtime stabilization release. The whole live-swarm experience — what you actually *see* while 5, 20, or 100 workers run — was rebuilt and proven end-to-end.
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "3.0.2"
+version = "3.0.3"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.0.2"
+version = "3.0.3"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 3.0.2"),
+        Some("--version") => println!("sks-rs 3.0.3"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "3.0.2",
-  "source_digest": "5d782324cdb5c0cb66ce53c5733ebdd754313abc22b579907de282270a0e6178",
-  "source_file_count": 2284,
-  "built_at_source_time": 1781100033829
+  "package_version": "3.0.3",
+  "source_digest": "4630d65c17e3297a1a79b5b96be0b849ee4ada4ac1ff010a4e024b06d8b7b750",
+  "source_file_count": 2304,
+  "built_at_source_time": 1781142991546
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '3.0.2';
+const FAST_PACKAGE_VERSION = '3.0.3';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/core/agents/runtime-proof-summary.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { findLatestMission, missionDir } from '../mission.js';
 import { readJson, writeJsonAtomic } from '../fsx.js';
 import { readAgentMessageBus } from './agent-message-bus.js';
+import { buildZellijWorkerPaneSummary } from '../zellij/zellij-worker-pane-summary.js';
 export const RUNTIME_PROOF_SUMMARY_SCHEMA = 'sks.runtime-proof-summary.v1';
 export async function buildRuntimeProofSummary(root, missionIdInput = 'latest', opts = {}) {
     const missionId = missionIdInput === 'latest' ? await findLatestMission(root) : missionIdInput;
@@ -16,6 +17,7 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest',
     const governor = await readJson(path.join(agentsDir, 'naruto-concurrency-governor.json'), null);
     const messagesAll = await readAgentMessageBus(root, missionId, { max: 500 });
     const recentMessages = await readAgentMessageBus(root, missionId, { max: opts.maxMessages || 8 });
+    const zellijSummary = await buildZellijWorkerPaneSummary(root, missionId).catch(() => null);
     const failedMessages = messagesAll.filter((row) => row.event_type === 'worker_failed');
     const errorMessages = messagesAll.filter((row) => row.level === 'error');
     const telemetryAgeMs = telemetry?.updated_at ? Math.max(0, Date.now() - Date.parse(telemetry.updated_at)) : Number.MAX_SAFE_INTEGER;
@@ -27,7 +29,8 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest',
         ...(!scheduler ? ['agent_scheduler_state_missing'] : []),
         ...(parallel?.passed === false ? parallel.blockers || ['parallel_runtime_proof_failed'] : []),
         ...(errorMessages.length ? ['agent_message_bus_error_blockers'] : []),
-        ...(telemetryAgeMs > 3000 ? ['zellij_telemetry_stale'] : [])
+        ...(telemetryAgeMs > 3000 ? ['zellij_telemetry_stale'] : []),
+        ...(zellijSummary?.blockers || [])
     ].map(String);
     const summary = {
         schema: RUNTIME_PROOF_SUMMARY_SCHEMA,
@@ -61,6 +64,15 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest',
             warning_count: messagesAll.filter((row) => row.level === 'warning').length,
             error_count: errorMessages.length
         },
+        zellij: {
+            stacked_requested_count: Number(zellijSummary?.stacked_requested_count || 0),
+            stacked_applied_count: Number(zellijSummary?.stacked_applied_count || 0),
+            stacked_fallback_count: Number(zellijSummary?.stacked_fallback_count || 0),
+            fallback_modes: zellijSummary?.fallback_modes || {},
+            pane_lock_wait_p95_ms: Number(zellijSummary?.pane_lock_wait_p95_ms || 0),
+            pane_lock_held_p95_ms: Number(zellijSummary?.pane_lock_held_p95_ms || 0),
+            duplicate_slot_anchor_count: Number(zellijSummary?.duplicate_slot_anchor_count || 0)
+        },
         blockers
     };
     await writeJsonAtomic(path.join(agentsDir, 'runtime-proof-summary.json'), summary);
@@ -75,6 +87,10 @@ export function renderRuntimeProofSummary(summary) {
         `Visible/headless: ${summary.ui.visible_panes} / ${summary.ui.headless_workers}`,
         `Telemetry: ${summary.ui.stale ? `stale ${(summary.ui.telemetry_age_ms / 1000).toFixed(1)}s` : `fresh ${(summary.ui.telemetry_age_ms / 1000).toFixed(1)}s`}`,
         `Model calls max: ${summary.model_calls.max_observed}`,
+        `Zellij stacked panes: ${summary.zellij.stacked_applied_count}/${summary.zellij.stacked_requested_count} applied`,
+        `Stack fallback: ${summary.zellij.stacked_fallback_count}`,
+        `Pane lock wait p95: ${summary.zellij.pane_lock_wait_p95_ms}ms`,
+        `SLOTS anchors: ${summary.zellij.duplicate_slot_anchor_count}`,
         ...(summary.messages.recent.length ? [
             'Recent worker messages:',
             ...summary.messages.recent.map((row) => `  ${messageStatusLabel(row)} ${row.slot_id || row.worker_id}: ${row.message}`)

package/dist/core/codex/codex-cli-syntax-builder.js

@@ -23,7 +23,7 @@ export function buildCodexExecArgs(opts) {
     if (opts.skipGitRepoCheck)
         args.push('--skip-git-repo-check');
     if (opts.profile)
-        args.push('--profile', opts.profile);
+        args.push(...buildCodexProfileArgs(opts.profile, opts.profileAlias));
     else if (opts.ignoreUserConfig)
         args.push('--ignore-user-config');
     if (opts.ignoreRules)
@@ -40,6 +40,9 @@ export function buildCodexExecArgs(opts) {
     args.push(opts.prompt);
     return args;
 }
+export function buildCodexProfileArgs(profile, alias = 'long') {
+    return alias === 'short' ? ['-P', profile] : ['--profile', profile];
+}
 function normalizeCodexServiceTier(value) {
     const text = String(value || '').toLowerCase();
     if (text === 'fast' || text === 'priority')

package/dist/core/codex-control/codex-0139-capability.js

@@ -13,33 +13,52 @@ export async function detectCodex0139Capability(input = {}) {
     const parsed = parseCodexVersionText(versionText);
     const atLeast139 = Boolean(parsed && compareSemverLike(parsed, '0.139.0') >= 0);
     const probeMode = process.env.SKS_CODEX_0139_PROBE === '1' ? 'feature-probe' : 'version-only';
+    const probeTimeoutMs = Math.max(1, Number(process.env.SKS_CODEX_0139_PROBE_TIMEOUT_MS || 3000) || 3000);
     const featureProbeResults = probeMode === 'feature-probe'
-        ? await probeCodex0139Features(codexBin, { fake })
+        ? await probeCodex0139Features(codexBin, { fake, timeoutMs: probeTimeoutMs })
         : {
             marketplace_list_json: 'skipped',
-            sandbox_profile_alias: 'skipped'
+            sandbox_profile_alias: 'skipped',
+            interrupt_agent_event_mapping: 'skipped',
+            rich_tool_schema_preservation: 'skipped',
+            doctor_env_redaction: 'skipped',
+            code_mode_web_search: 'skipped'
         };
     const marketplaceOk = atLeast139 && (probeMode === 'version-only' || featureProbeResults.marketplace_list_json !== 'failed');
     const profileAliasOk = atLeast139 && (probeMode === 'version-only' || featureProbeResults.sandbox_profile_alias !== 'failed');
+    const interruptAgentOk = atLeast139 && (probeMode === 'version-only' || featureProbeResults.interrupt_agent_event_mapping !== 'failed');
+    const richSchemaOk = atLeast139 && (probeMode === 'version-only' || featureProbeResults.rich_tool_schema_preservation !== 'failed');
+    const doctorEnvOk = atLeast139 && (probeMode === 'version-only' || featureProbeResults.doctor_env_redaction !== 'failed');
+    const codeSearchOk = atLeast139 && (probeMode === 'version-only' || featureProbeResults.code_mode_web_search !== 'failed');
+    const probeErrorSummary = Object.entries(featureProbeResults)
+        .filter(([, status]) => status === 'failed')
+        .map(([name]) => `${name}:failed`);
     const blockers = [
         ...(!codexBin ? ['codex_cli_missing'] : []),
         ...(atLeast139 ? [] : ['codex_0_139_required_for_search_schema_marketplace_features']),
-        ...(probeMode === 'feature-probe' && featureProbeResults.marketplace_list_json === 'failed' ? ['codex_marketplace_list_json_probe_failed'] : [])
+        ...(probeMode === 'feature-probe' && featureProbeResults.marketplace_list_json === 'failed' ? ['codex_marketplace_list_json_probe_failed'] : []),
+        ...(probeMode === 'feature-probe' && featureProbeResults.sandbox_profile_alias === 'failed' ? ['codex_sandbox_profile_alias_probe_failed'] : []),
+        ...(probeMode === 'feature-probe' && featureProbeResults.interrupt_agent_event_mapping === 'failed' ? ['codex_interrupt_agent_probe_failed'] : []),
+        ...(probeMode === 'feature-probe' && featureProbeResults.rich_tool_schema_preservation === 'failed' ? ['codex_rich_tool_schema_probe_failed'] : []),
+        ...(probeMode === 'feature-probe' && featureProbeResults.doctor_env_redaction === 'failed' ? ['codex_doctor_env_redaction_probe_failed'] : []),
+        ...(probeMode === 'feature-probe' && featureProbeResults.code_mode_web_search === 'failed' ? ['codex_code_mode_web_search_probe_failed'] : [])
     ];
     return {
         schema: 'sks.codex-0139-capability.v1',
         ok: atLeast139 && blockers.length === 0,
         probe_mode: probeMode,
+        probe_timeout_ms: probeTimeoutMs,
+        probe_error_summary: probeErrorSummary,
         codex_bin: codexBin || null,
         version_text: versionText || null,
         parsed_version: parsed,
-        supports_code_mode_web_search: atLeast139,
-        supports_rich_tool_schemas: atLeast139,
-        supports_doctor_env_details: atLeast139,
+        supports_code_mode_web_search: codeSearchOk,
+        supports_rich_tool_schemas: richSchemaOk,
+        supports_doctor_env_details: doctorEnvOk,
         supports_marketplace_source_field: marketplaceOk,
         supports_plugin_catalog_cache: atLeast139,
         supports_sandbox_profile_alias: profileAliasOk,
-        supports_interrupt_agent_rename: atLeast139,
+        supports_interrupt_agent_rename: interruptAgentOk,
         feature_probe_results: featureProbeResults,
         blockers
     };
@@ -71,12 +90,23 @@ async function probeCodex0139Features(codexBin, opts = {}) {
     if (opts.fake) {
         return {
             marketplace_list_json: process.env.SKS_CODEX_0139_FAKE_MARKETPLACE_FAIL === '1' ? 'failed' : 'passed',
-            sandbox_profile_alias: 'passed'
+            sandbox_profile_alias: process.env.SKS_CODEX_0139_FAKE_PROFILE_ALIAS_FAIL === '1' ? 'failed' : 'passed',
+            interrupt_agent_event_mapping: process.env.SKS_CODEX_0139_FAKE_INTERRUPT_FAIL === '1' ? 'failed' : 'passed',
+            rich_tool_schema_preservation: process.env.SKS_CODEX_0139_FAKE_RICH_SCHEMA_FAIL === '1' ? 'failed' : 'passed',
+            doctor_env_redaction: process.env.SKS_CODEX_0139_FAKE_DOCTOR_ENV_FAIL === '1' ? 'failed' : 'passed',
+            code_mode_web_search: process.env.SKS_CODEX_0139_FAKE_WEB_SEARCH_FAIL === '1' ? 'failed' : 'passed'
         };
     }
-    const timeoutMs = Math.max(1, Number(process.env.SKS_CODEX_0139_PROBE_TIMEOUT_MS || 3000) || 3000);
+    const timeoutMs = Math.max(1, Number(opts.timeoutMs || process.env.SKS_CODEX_0139_PROBE_TIMEOUT_MS || 3000) || 3000);
     if (!codexBin) {
-        return { marketplace_list_json: 'failed', sandbox_profile_alias: 'failed' };
+        return {
+            marketplace_list_json: 'failed',
+            sandbox_profile_alias: 'failed',
+            interrupt_agent_event_mapping: 'skipped',
+            rich_tool_schema_preservation: 'skipped',
+            doctor_env_redaction: 'skipped',
+            code_mode_web_search: 'skipped'
+        };
     }
     const marketplace = await runProcess(codexBin, ['plugin', 'marketplace', 'list', '--json'], { timeoutMs, maxOutputBytes: 256 * 1024 }).catch(() => ({ code: 1, stdout: '' }));
     const marketplaceListJson = marketplace.code === 0 && marketplaceSourcesPresent(marketplace.stdout) ? 'passed' : 'failed';
@@ -84,7 +114,11 @@ async function probeCodex0139Features(codexBin, opts = {}) {
     const aliasOk = help.code === 0 && /(^|\s)-P[,\s]/m.test(String(help.stdout || ''));
     return {
         marketplace_list_json: marketplaceListJson,
-        sandbox_profile_alias: aliasOk ? 'passed' : 'failed'
+        sandbox_profile_alias: aliasOk ? 'passed' : 'failed',
+        interrupt_agent_event_mapping: 'skipped',
+        rich_tool_schema_preservation: 'skipped',
+        doctor_env_redaction: 'skipped',
+        code_mode_web_search: 'skipped'
     };
 }
 export function marketplaceSourcesPresent(stdout) {
@@ -93,10 +127,32 @@ export function marketplaceSourcesPresent(stdout) {
         const rows = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.marketplaces) ? parsed.marketplaces : Array.isArray(parsed?.items) ? parsed.items : [];
         if (!rows.length)
             return true;
-        return rows.some((row) => typeof row?.source === 'string' && row.source.length > 0);
+        return rows.every((row) => typeof row?.source === 'string' && row.source.length > 0);
     }
     catch {
         return false;
     }
 }
+export function codexHelpSupportsSandboxProfileAlias(stdout) {
+    return /(^|\s)-P[,\s]+--profile\b|--profile[,\s]+-P\b|(^|\s)-P\b/m.test(String(stdout || ''));
+}
+export function redactCodexDoctorEnvDetails(value) {
+    if (Array.isArray(value))
+        return value.map((item) => redactCodexDoctorEnvDetails(item));
+    if (!value || typeof value !== 'object') {
+        return secretLikeValue(value) ? '<redacted>' : value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
+        if (secretLikeKey(key) || secretLikeValue(entry))
+            return [key, '<redacted>'];
+        return [key, redactCodexDoctorEnvDetails(entry)];
+    }));
+}
+function secretLikeKey(key) {
+    return /(?:api[_-]?key|auth[_-]?token|secret|password|credential|bearer|session[_-]?token)/i.test(key);
+}
+function secretLikeValue(value) {
+    const text = typeof value === 'string' ? value : '';
+    return /(?:sk-[A-Za-z0-9_-]{6,}|Bearer\s+[A-Za-z0-9._-]{8,}|[A-Za-z0-9._-]{12,}\.[A-Za-z0-9._-]{12,}\.[A-Za-z0-9._-]{12,})/.test(text);
+}
 //# sourceMappingURL=codex-0139-capability.js.map

package/dist/core/codex-control/codex-multi-agent-event-normalizer.js

@@ -0,0 +1,15 @@
+export function normalizeCodexMultiAgentEventName(name) {
+    const sourceName = String(name || '');
+    const normalized = sourceName.trim().toLowerCase().replace(/[-.\s]+/g, '_');
+    if (normalized === 'start_agent' || normalized === 'spawn_agent' || normalized === 'subagent_start') {
+        return { canonical: 'start_agent', stage: 'start', source_name: sourceName };
+    }
+    if (normalized === 'interrupt_agent') {
+        return { canonical: 'interrupt_agent', stage: 'result', source_name: sourceName };
+    }
+    if (normalized === 'close_agent' || normalized === 'subagent_stop') {
+        return { canonical: 'close_agent', stage: 'result', source_name: sourceName };
+    }
+    return { canonical: 'unknown', stage: 'unknown', source_name: sourceName };
+}
+//# sourceMappingURL=codex-multi-agent-event-normalizer.js.map

package/dist/core/codex-control/codex-tool-schema-fixtures.js

@@ -0,0 +1,57 @@
+import { compactMcpToolSchema } from '../mcp/mcp-0-134-policy.js';
+export function buildCodex0139RichToolSchemaFixture() {
+    return {
+        type: 'object',
+        description: 'Codex 0.139 rich tool schema preservation fixture',
+        oneOf: [
+            { required: ['mode'], properties: { mode: { const: 'guided' } } },
+            { required: ['query'], properties: { query: { type: 'string' } } }
+        ],
+        allOf: [
+            { required: ['kind'] },
+            { properties: { kind: { enum: ['search', 'inspect'] } } }
+        ],
+        required: ['kind', 'payload'],
+        properties: {
+            kind: { enum: ['search', 'inspect'] },
+            payload: {
+                type: 'object',
+                required: ['target'],
+                properties: {
+                    target: { type: 'string' },
+                    filters: {
+                        type: 'object',
+                        properties: {
+                            depth: { enum: ['shallow', 'deep'] }
+                        }
+                    }
+                }
+            }
+        }
+    };
+}
+export function passCodex0139RichToolSchemaThroughBridge(schema = buildCodex0139RichToolSchemaFixture()) {
+    return compactMcpToolSchema(schema, 128).schema;
+}
+export function evaluateCodex0139RichToolSchemaPreservation(schema = buildCodex0139RichToolSchemaFixture()) {
+    const bridged = passCodex0139RichToolSchemaThroughBridge(schema);
+    const required = Array.isArray(bridged?.required) ? bridged.required : [];
+    const result = {
+        schema: 'sks.codex-0139-rich-tool-schema-preservation.v1',
+        ok: Array.isArray(bridged?.oneOf)
+            && Array.isArray(bridged?.allOf)
+            && Boolean(bridged?.properties?.payload?.properties?.target)
+            && required.includes('kind')
+            && required.includes('payload'),
+        top_level_oneOf_preserved: Array.isArray(bridged?.oneOf),
+        top_level_allOf_preserved: Array.isArray(bridged?.allOf),
+        nested_structure_preserved: Boolean(bridged?.properties?.payload?.properties?.target),
+        required_fields_retained: required.includes('kind') && required.includes('payload'),
+        bridged_schema: bridged
+    };
+    return {
+        ...result,
+        blockers: result.ok ? [] : ['codex_rich_tool_schema_preservation_failed']
+    };
+}
+//# sourceMappingURL=codex-tool-schema-fixtures.js.map

package/dist/core/fsx.js

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

package/dist/core/mcp/mcp-0-134-policy.js

@@ -63,6 +63,9 @@ export function compactMcpToolSchema(schema, maxBytes = 8192) {
             type: schema?.type || 'object',
             description: String(schema?.description || '').slice(0, 512),
             properties: Object.fromEntries(Object.entries(schema?.properties || {}).slice(0, 50)),
+            ...(Array.isArray(schema?.oneOf) ? { oneOf: schema.oneOf } : {}),
+            ...(Array.isArray(schema?.allOf) ? { allOf: schema.allOf } : {}),
+            ...(Array.isArray(schema?.required) ? { required: schema.required } : {}),
             ...preservedDefs,
             ...(refs.length ? { refs } : {})
         },

package/dist/core/pipeline-internals/runtime-core.js

@@ -29,6 +29,7 @@ import { CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_COMPUTER_USE_EVIDENCE_SOURCE,
 import { TEAM_DECOMPOSITION_ARTIFACT, TEAM_GRAPH_ARTIFACT, TEAM_INBOX_DIR, TEAM_RUNTIME_TASKS_ARTIFACT, teamRuntimePlanMetadata, teamRuntimeRequiredArtifacts, validateTeamRuntimeArtifacts, writeTeamRuntimeArtifacts } from '../team-dag.js';
 import { formatAgentReasoning, formatRoleCounts, initTeamLive, parseTeamSpecText, teamReasoningPolicy } from '../team-live.js';
 import { evaluateTeamReviewPolicyGate, MIN_TEAM_REVIEWER_LANES, MIN_TEAM_REVIEW_POLICY_TEXT, teamReviewPolicy } from '../team-review-policy.js';
+import { normalizeCodexMultiAgentEventName } from '../codex-control/codex-multi-agent-event-normalizer.js';
 export { routePrompt };
 export const PIPELINE_PLAN_ARTIFACT = 'pipeline-plan.json';
 export const PIPELINE_PLAN_SCHEMA_VERSION = 1;
@@ -1257,7 +1258,11 @@ function subagentStage(payload) {
         return 'exception';
     if (/spawn_agent/i.test(hay))
         return 'spawn_agent';
-    if (/wait_agent|close_agent|interrupt_agent|completed|final/i.test(hay))
+    for (const name of ['interrupt_agent', 'close_agent']) {
+        if (hay.includes(name) && normalizeCodexMultiAgentEventName(name).stage === 'result')
+            return 'result';
+    }
+    if (/wait_agent|completed|final/i.test(hay))
         return 'result';
     return 'subagent';
 }

package/dist/core/version.js

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

package/dist/core/zellij/zellij-command.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { runProcess } from '../fsx.js';
+import { runFakeZellij } from './zellij-fake-adapter.js';
 export const ZELLIJ_UNIX_SOCKET_PATH_LIMIT = 103;
 export async function runZellij(args = [], opts = {}) {
     const started = Date.now();
@@ -16,7 +17,17 @@ export async function runZellij(args = [], opts = {}) {
         runOpts.stdoutFile = opts.stdoutFile;
     if (opts.stderrFile !== undefined)
         runOpts.stderrFile = opts.stderrFile;
-    const result = await runProcess('zellij', args, runOpts);
+    const fakeOpts = {
+        cwd: runOpts.cwd || process.cwd(),
+        env: preparedEnv.env
+    };
+    if (runOpts.timeoutMs !== undefined)
+        fakeOpts.timeoutMs = runOpts.timeoutMs;
+    if (runOpts.maxOutputBytes !== undefined)
+        fakeOpts.maxOutputBytes = runOpts.maxOutputBytes;
+    const result = process.env.SKS_ZELLIJ_FAKE_ADAPTER === '1' || preparedEnv.env.SKS_ZELLIJ_FAKE_ADAPTER === '1'
+        ? await runFakeZellij(args, fakeOpts)
+        : await runProcess('zellij', args, runOpts);
     const ok = result.code === 0;
     const stderr = String(result.stderr || '');
     const missing = result.code === -1 && /ENOENT|not found|spawn zellij/i.test(stderr);

package/dist/core/zellij/zellij-fake-adapter.js

@@ -0,0 +1,163 @@
+import path from 'node:path';
+import { appendJsonl, ensureDir, nowIso } from '../fsx.js';
+const sessions = new Map();
+export async function runFakeZellij(args = [], opts = {}) {
+    const env = { ...process.env, ...(opts.env || {}) };
+    const root = path.resolve(String(env.SKS_ZELLIJ_FAKE_ROOT || opts.cwd || process.cwd()));
+    const version = String(env.SKS_ZELLIJ_FAKE_VERSION || '0.43.1');
+    const delayMs = Math.max(0, Number(env.SKS_ZELLIJ_FAKE_DELAY_MS || 0) || 0);
+    const sessionName = sessionFromArgs(args);
+    const startedAt = Date.now();
+    let result;
+    if (args.length === 1 && args[0] === '--version') {
+        result = ok(`zellij ${version}\n`);
+    }
+    else if (args[0] === 'attach' && args[1] === '--create-background') {
+        getSession(String(args[2] || 'default'));
+        result = ok('');
+    }
+    else if (args.includes('new-pane')) {
+        if (args.includes('--stacked') && !supportsStacked(version)) {
+            result = fail('unknown option --stacked');
+        }
+        else {
+            if (delayMs > 0)
+                await sleep(delayMs);
+            const session = getSession(sessionName);
+            const name = optionValue(args, '--name') || `pane-${session.next_id}`;
+            const paneId = `terminal_${session.next_id++}`;
+            const command = commandAfter(args, '--') || '';
+            const pane = { pane_id: paneId, title: name, name, terminal_command: command, exited: false };
+            session.panes.push(pane);
+            session.focused_pane_id = paneId;
+            result = ok(`${JSON.stringify({ pane_id: paneId })}\n`);
+        }
+    }
+    else if (args.includes('focus-pane-id')) {
+        const paneId = String(args[args.indexOf('focus-pane-id') + 1] || '');
+        const session = getSession(sessionName);
+        const pane = findPane(session, paneId);
+        if (!pane)
+            result = fail(`Pane ${paneId} not found`);
+        else {
+            session.focused_pane_id = pane.pane_id;
+            result = ok('');
+        }
+    }
+    else if (args.includes('list-panes')) {
+        const session = getSession(sessionName);
+        result = ok(`${JSON.stringify(session.panes)}\n`);
+    }
+    else if (args.includes('dump-screen')) {
+        const session = getSession(sessionName);
+        result = ok(session.panes.map((pane) => pane.title).join('\n') + '\n');
+    }
+    else if (args.includes('rename-pane')) {
+        const session = getSession(sessionName);
+        const paneId = optionValue(args, '--pane-id');
+        const name = String(args[args.length - 1] || '');
+        const pane = paneId ? findPane(session, paneId) : session.panes.find((row) => row.pane_id === session.focused_pane_id);
+        if (!pane)
+            result = fail(`Pane ${paneId || 'focused'} not found`);
+        else {
+            pane.title = name;
+            pane.name = name;
+            result = ok('');
+        }
+    }
+    else if (args.includes('close-pane')) {
+        const session = getSession(sessionName);
+        const paneId = optionValue(args, '--pane-id');
+        const pane = paneId ? findPane(session, paneId) : session.panes.find((row) => row.pane_id === session.focused_pane_id);
+        if (!pane)
+            result = fail(`Pane ${paneId || 'focused'} not found`);
+        else {
+            pane.exited = true;
+            result = ok('');
+        }
+    }
+    else {
+        result = ok('');
+    }
+    await recordFakeZellijCall(root, args, {
+        session_name: sessionName,
+        version,
+        exit_code: result.code,
+        duration_ms: Date.now() - startedAt
+    });
+    return result;
+}
+async function recordFakeZellijCall(root, args, meta) {
+    const file = path.join(root, '.sneakoscope', 'fake-zellij-calls.jsonl');
+    await ensureDir(path.dirname(file));
+    await appendJsonl(file, {
+        schema: 'sks.fake-zellij-call.v1',
+        ts: nowIso(),
+        args: [...args],
+        ...meta
+    });
+}
+function getSession(name) {
+    const key = String(name || 'default');
+    const existing = sessions.get(key);
+    if (existing)
+        return existing;
+    const next = { next_id: 1, focused_pane_id: null, panes: [] };
+    sessions.set(key, next);
+    return next;
+}
+function sessionFromArgs(args) {
+    const explicit = optionValue(args, '--session');
+    if (explicit)
+        return explicit;
+    if (args[0] === 'attach' && args[1] === '--create-background')
+        return String(args[2] || 'default');
+    return 'default';
+}
+function optionValue(args, flag) {
+    const index = args.indexOf(flag);
+    if (index < 0)
+        return null;
+    const value = args[index + 1];
+    return value == null ? null : String(value);
+}
+function commandAfter(args, marker) {
+    const index = args.indexOf(marker);
+    if (index < 0)
+        return null;
+    return args.slice(index + 1).map(String).join(' ');
+}
+function findPane(session, id) {
+    const normalized = String(id || '').replace(/^terminal_/, '');
+    return session.panes.find((pane) => pane.pane_id === id || pane.pane_id.replace(/^terminal_/, '') === normalized) || null;
+}
+function supportsStacked(version) {
+    const parts = String(version || '0.0.0').match(/(\d+)\.(\d+)\.(\d+)/)?.slice(1).map((part) => Number.parseInt(part, 10) || 0) || [0, 0, 0];
+    return parts[0] > 0 || parts[1] > 43 || (parts[1] === 43 && parts[2] >= 0);
+}
+function ok(stdout) {
+    return {
+        code: 0,
+        stdout,
+        stderr: '',
+        stdoutBytes: Buffer.byteLength(stdout),
+        stderrBytes: 0,
+        truncated: false,
+        timedOut: false
+    };
+}
+function fail(stderr) {
+    return {
+        code: 1,
+        stdout: '',
+        stderr,
+        stdoutBytes: 0,
+        stderrBytes: Buffer.byteLength(stderr),
+        truncated: false,
+        timedOut: false
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=zellij-fake-adapter.js.map

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

@@ -6,12 +6,27 @@ 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()
@@ -19,7 +34,8 @@ const body = [
 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('Packlist:'), 'github release body helper missing source truth fields', { body });
+    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) {
@@ -40,4 +56,8 @@ function latestChangelogSection(text) {
     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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "3.0.2",
+  "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",
@@ -718,7 +718,21 @@
     "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"
+    "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",