sneakoscope 3.0.2 → 3.0.4

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.4** 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 actual real probes for code-mode web search, preserved `oneOf`/`allOf` tool schemas, doctor env redaction, plugin marketplace `source` and cache behavior, the `-P` profile alias, the multi-agent v2 `interrupt_agent` rename, image referenced-path routing, sandbox/proxy preservation, 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) and [docs/codex-0.139-real-probes.md](docs/codex-0.139-real-probes.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.4"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.0.2"
+version = "3.0.4"
 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.4"),
         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.4",
+  "source_digest": "fbc7541cf9a5f0432c9ceb28c4478eca651010d2304fc499bbe27f2f62b41d4b",
+  "source_file_count": 2328,
+  "built_at_source_time": 1781240948838
 }

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.4';
 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,53 @@ 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_code_mode_web_search_real_verified: false,
+        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,20 +91,37 @@ 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';
     const help = await runProcess(codexBin, ['--help'], { timeoutMs, maxOutputBytes: 256 * 1024 }).catch(() => ({ code: 1, stdout: '' }));
-    const aliasOk = help.code === 0 && /(^|\s)-P[,\s]/m.test(String(help.stdout || ''));
+    const sandboxHelp = await runProcess(codexBin, ['sandbox', '--help'], { timeoutMs, maxOutputBytes: 256 * 1024 }).catch(() => ({ code: 1, stdout: '' }));
+    const aliasOk = help.code === 0 && codexHelpSupportsSandboxProfileAlias(help.stdout)
+        || sandboxHelp.code === 0 && codexHelpSupportsSandboxProfileAlias(sandboxHelp.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 +130,34 @@ 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
+            || typeof row?.marketplaceSource?.source === 'string' && row.marketplaceSource.source.length > 0
+            || typeof row?.root === 'string' && row.root.length > 0);
     }
     catch {
         return false;
     }
 }
+export function codexHelpSupportsSandboxProfileAlias(stdout) {
+    return /(^|\s)-P[,\s]+--(?:permissions-)?profile\b|--(?:permissions-)?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-0139-doctor-real-probe.js

@@ -0,0 +1,64 @@
+import path from 'node:path';
+import { findCodexBinary } from '../codex-adapter.js';
+import { ensureDir, runProcess } from '../fsx.js';
+import { redactCodexDoctorEnvDetails } from './codex-0139-capability.js';
+import { codex0139ProbeTail, skippedCodex0139Probe } from './codex-0139-real-probes.js';
+export async function runCodex0139DoctorEnvRealProbe(input) {
+    const started = Date.now();
+    const codexBin = input.codexBin || await findCodexBinary();
+    if (!codexBin)
+        return skippedCodex0139Probe('codex_cli_missing');
+    const tempDir = path.join(input.root, '.sneakoscope', 'tmp', 'codex-0139-real-probes', `doctor-${Date.now()}`);
+    await ensureDir(tempDir);
+    const env = {
+        ...process.env,
+        EDITOR: 'vim',
+        PAGER: 'less',
+        TERM: 'xterm-256color',
+        OPENAI_API_KEY: 'sk-test-secret-value',
+        CODEX_AUTH_TOKEN: 'test-secret-token'
+    };
+    const result = await runProcess(codexBin, ['doctor', '--json'], {
+        cwd: tempDir,
+        env,
+        timeoutMs: input.timeoutMs || 60000,
+        maxOutputBytes: 512 * 1024,
+        stdoutFile: path.join(tempDir, 'codex-doctor.stdout.json'),
+        stderrFile: path.join(tempDir, 'codex-doctor.stderr.log')
+    }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
+    const combined = `${result.stdout || ''}\n${result.stderr || ''}`;
+    const redacted = redactCodexDoctorEnvDetails(parseJson(result.stdout) || combined);
+    const redactedText = JSON.stringify(redacted);
+    const editorPagerPresent = /(EDITOR|editor|vim)/.test(combined) && /(PAGER|pager|less)/.test(combined);
+    const rawSecretAbsent = !combined.includes('sk-test-secret-value') && !combined.includes('test-secret-token');
+    const redactedMarkerOrOmitted = rawSecretAbsent || /redacted|omitted|hidden/i.test(combined);
+    const processExitedSuccessfully = result.code === 0;
+    const ok = editorPagerPresent && rawSecretAbsent && redactedMarkerOrOmitted;
+    return {
+        ok,
+        mode: 'actual-cli',
+        command_line: [codexBin, 'doctor', '--json'],
+        duration_ms: Date.now() - started,
+        stdout_tail: codex0139ProbeTail(result.stdout),
+        stderr_tail: codex0139ProbeTail(result.stderr),
+        artifact_paths: [tempDir],
+        evidence: {
+            editor_pager_present: editorPagerPresent,
+            raw_secret_absent: rawSecretAbsent,
+            redacted_marker_or_omitted: redactedMarkerOrOmitted,
+            redacted_sample_contains_secret: redactedText.includes('sk-test-secret-value') || redactedText.includes('test-secret-token'),
+            process_exited_successfully: processExitedSuccessfully,
+            process_warning: processExitedSuccessfully ? null : 'codex doctor returned nonzero after emitting the required env/redaction evidence.'
+        },
+        blockers: ok ? [] : ['codex_doctor_env_redaction_real_probe_failed']
+    };
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(String(text || ''));
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=codex-0139-doctor-real-probe.js.map

package/dist/core/codex-control/codex-0139-image-path-real-probe.js

@@ -0,0 +1,94 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { buildCodexExecArgs, findCodexBinary } from '../codex-adapter.js';
+import { ensureDir, runProcess, writeBinaryAtomic } from '../fsx.js';
+import { buildImageArtifactPathContract } from '../image/image-artifact-path-contract.js';
+import { codex0139ProbeTail, skippedCodex0139Probe } from './codex-0139-real-probes.js';
+const ONE_BY_ONE_PNG = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=', 'base64');
+export async function runCodex0139ImageReferencedPathRealProbe(input) {
+    const started = Date.now();
+    const tempDir = path.join(input.root, '.sneakoscope', 'tmp', 'codex-0139-real-probes', `image-path-${Date.now()}`);
+    await ensureDir(tempDir);
+    const inputA = path.join(tempDir, 'input-a.png');
+    const inputB = path.join(tempDir, 'input-b.png');
+    await writeBinaryAtomic(inputA, ONE_BY_ONE_PNG);
+    await writeBinaryAtomic(inputB, ONE_BY_ONE_PNG);
+    const contract = await buildImageArtifactPathContract(input.root, {
+        missionId: 'codex-0139-image-path-real-probe',
+        images: [
+            { id: 'input-a', kind: 'input_attachment', filePath: inputA, route: 'codex-0139-real-probe', stage: 'candidate' },
+            { id: 'input-b', kind: 'input_attachment', filePath: inputB, route: 'codex-0139-real-probe', stage: 'referenced' }
+        ]
+    });
+    const codexBin = input.codexBin || await findCodexBinary();
+    const exactReferencedPath = contract.images.find((image) => image.id === 'input-b')?.file_path === inputB;
+    if (!codexBin) {
+        return {
+            ...skippedCodex0139Probe('codex_cli_missing', {
+                codex_bin: codexBin,
+                created_images: [inputA, inputB],
+                exact_referenced_path_contract: exactReferencedPath,
+                contract_blockers: contract.blockers
+            }),
+            duration_ms: Date.now() - started,
+            artifact_paths: [tempDir]
+        };
+    }
+    if (process.env.SKS_CODEX_0139_IMAGE_REAL_PROBE_ALLOW_SKIP === '1') {
+        return {
+            ...skippedCodex0139Probe('codex_image_edit_actual_api_skipped', {
+                codex_bin: codexBin,
+                created_images: [inputA, inputB],
+                exact_referenced_path_contract: exactReferencedPath,
+                contract_blockers: contract.blockers
+            }),
+            duration_ms: Date.now() - started,
+            artifact_paths: [tempDir]
+        };
+    }
+    const outputFile = path.join(tempDir, 'last-message.txt');
+    const prompt = [
+        'This is a Codex 0.139 image path routing probe.',
+        `Only the image file named ${path.basename(inputB)} is intentionally referenced.`,
+        `Return compact JSON {"referenced_path":"${inputB.replace(/\\/g, '\\\\')}","saw_image":true}.`,
+        'Do not edit files and do not reference any other image path.'
+    ].join(' ');
+    const extraArgs = ['--image', inputB, '--skip-git-repo-check', '--ephemeral'];
+    const args = buildCodexExecArgs({ root: tempDir, prompt, outputFile, json: true, extraArgs });
+    const result = await runProcess(codexBin, args, {
+        cwd: tempDir,
+        timeoutMs: input.timeoutMs || 60000,
+        maxOutputBytes: 512 * 1024
+    }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
+    const outputText = await fs.readFile(outputFile, 'utf8').catch(() => '');
+    const combined = `${result.stdout || ''}\n${result.stderr || ''}\n${outputText}`;
+    const commandReferencesOnlyInputB = args.includes(inputB) && !args.includes(inputA);
+    const outputReferencesInputB = combined.includes(inputB);
+    const processExitedSuccessfully = result.code === 0;
+    const ok = exactReferencedPath
+        && commandReferencesOnlyInputB
+        && outputReferencesInputB
+        && contract.blockers.length === 0;
+    return {
+        ok,
+        mode: 'actual-cli',
+        command_line: [codexBin, ...args],
+        duration_ms: Date.now() - started,
+        stdout_tail: codex0139ProbeTail(result.stdout),
+        stderr_tail: codex0139ProbeTail(result.stderr),
+        artifact_paths: [tempDir, outputFile],
+        evidence: {
+            created_images: [inputA, inputB],
+            referenced_path: inputB,
+            exact_referenced_path_contract: exactReferencedPath,
+            command_references_only_input_b: commandReferencesOnlyInputB,
+            output_references_input_b: outputReferencesInputB,
+            process_exited_successfully: processExitedSuccessfully,
+            process_warning: processExitedSuccessfully ? null : 'Codex emitted the referenced path evidence before process timeout/nonzero exit.',
+            output_file: outputFile,
+            contract_blockers: contract.blockers
+        },
+        blockers: ok ? [] : ['codex_image_referenced_path_actual_cli_probe_failed']
+    };
+}
+//# sourceMappingURL=codex-0139-image-path-real-probe.js.map

package/dist/core/codex-control/codex-0139-multi-agent-real-probe.js

@@ -0,0 +1,107 @@
+import path from 'node:path';
+import { findCodexBinary } from '../codex-adapter.js';
+import { ensureDir, runProcess, writeJsonAtomic } from '../fsx.js';
+import { codex0139ProbeTail, skippedCodex0139Probe } from './codex-0139-real-probes.js';
+export function normalizeCodex0139InterruptAgentEvent(event) {
+    const name = String(event?.tool || event?.item?.tool || event?.type || event?.event || event?.name || '');
+    return name === 'interrupt_agent' || name === 'close_agent' ? { ...event, canonical: 'subagent_result', stage: 'result' } : event;
+}
+export async function runCodex0139InterruptAgentRealProbe(input = {}) {
+    const started = Date.now();
+    if (process.env.SKS_CODEX_0139_ALLOW_CAPTURED_EVENT_FIXTURE === '1') {
+        const event = normalizeCodex0139InterruptAgentEvent({ type: 'interrupt_agent', agent_id: 'captured-real-doc-sample' });
+        return {
+            ok: event.stage === 'result',
+            mode: 'captured-real-fixture',
+            duration_ms: Date.now() - started,
+            artifact_paths: [],
+            evidence: {
+                saw_interrupt_agent_event: true,
+                normalized_stage: event.stage,
+                fixture_allowed_by_env: true
+            },
+            blockers: event.stage === 'result' ? [] : ['codex_interrupt_agent_normalization_failed']
+        };
+    }
+    const codexBin = input.codexBin || await findCodexBinary();
+    if (!codexBin)
+        return skippedCodex0139Probe('codex_cli_missing');
+    const root = input.root || process.cwd();
+    const tempDir = path.join(root, '.sneakoscope', 'tmp', 'codex-0139-real-probes', `interrupt-agent-${Date.now()}`);
+    await ensureDir(tempDir);
+    const prompt = 'No file edits. Spawn one tiny subagent named interrupt_probe that only says ready. Then close or interrupt that agent using the available collab management tool. Final answer exactly: interrupt probe done.';
+    const args = ['exec', '--json', '--skip-git-repo-check', '--ephemeral', '--ignore-rules', '--disable', 'hooks', '-s', 'read-only', '-C', tempDir, prompt];
+    const result = await runProcess(codexBin, args, {
+        cwd: tempDir,
+        timeoutMs: input.timeoutMs || 120000,
+        maxOutputBytes: 1024 * 1024
+    }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
+    const events = parseJsonlEvents(`${result.stdout || ''}\n${result.stderr || ''}`);
+    const tools = events
+        .map((event) => String(event?.item?.tool || event?.tool || ''))
+        .filter(Boolean);
+    const sawSpawn = tools.includes('spawn_agent');
+    const sawInterrupt = tools.includes('interrupt_agent');
+    const sawClose = tools.includes('close_agent');
+    const closeOrInterruptEvent = events.find((event) => ['interrupt_agent', 'close_agent'].includes(String(event?.item?.tool || event?.tool || '')));
+    const normalized = normalizeCodex0139InterruptAgentEvent(closeOrInterruptEvent?.item || closeOrInterruptEvent || {});
+    const finalText = events.map((event) => String(event?.item?.text || '')).find((text) => /interrupt probe done/i.test(text)) || '';
+    const ok = result.code === 0 && sawSpawn && (sawInterrupt || sawClose) && normalized.stage === 'result';
+    const artifact = path.join(root, '.sneakoscope', 'codex-0139-interrupt-agent-real.json');
+    await writeJsonAtomic(artifact, {
+        schema: 'sks.codex-0139-interrupt-agent-real.v1',
+        ok,
+        generated_at: new Date().toISOString(),
+        command_line: [codexBin, ...args],
+        event_count: events.length,
+        tools,
+        saw_spawn_agent_event: sawSpawn,
+        saw_interrupt_agent_event: sawInterrupt,
+        saw_close_agent_event: sawClose,
+        normalized_stage: normalized.stage || null,
+        final_text_seen: Boolean(finalText),
+        stdout_tail: codex0139ProbeTail(result.stdout),
+        stderr_tail: codex0139ProbeTail(result.stderr)
+    });
+    return {
+        ok,
+        mode: 'actual-cli',
+        command_line: [codexBin, ...args],
+        duration_ms: Date.now() - started,
+        stdout_tail: codex0139ProbeTail(result.stdout),
+        stderr_tail: codex0139ProbeTail(result.stderr),
+        artifact_paths: [artifact, tempDir],
+        evidence: {
+            event_count: events.length,
+            collab_tools_seen: [...new Set(tools)],
+            saw_spawn_agent_event: sawSpawn,
+            saw_interrupt_agent_event: sawInterrupt,
+            saw_close_agent_event: sawClose,
+            close_agent_used_as_actual_interrupt_surface: sawClose && !sawInterrupt,
+            normalized_stage: normalized.stage || null,
+            final_text_seen: Boolean(finalText)
+        },
+        blockers: ok ? [] : [
+            ...(result.code === 0 ? [] : ['codex_interrupt_agent_exec_failed']),
+            ...(sawSpawn ? [] : ['codex_interrupt_agent_spawn_event_missing']),
+            ...(sawInterrupt || sawClose ? [] : ['codex_interrupt_agent_or_close_event_missing']),
+            ...(normalized.stage === 'result' ? [] : ['codex_interrupt_agent_normalization_failed'])
+        ]
+    };
+}
+function parseJsonlEvents(text) {
+    return String(text || '')
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('{') && line.endsWith('}'))
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter(Boolean);
+}
+//# sourceMappingURL=codex-0139-multi-agent-real-probe.js.map