sneakoscope 3.0.1 → 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.1** tracks Codex CLI `rust-v0.139.0`: capability detection for code-mode web search, preserved `oneOf`/`allOf` tool schemas, plugin marketplace `source`/cached catalog, the `-P` sandbox profile alias, and the multi-agent v2 `interrupt_agent` rename (accepted alongside `close_agent` in cockpit event classification). 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.1"
+version = "3.0.3"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.0.1"
+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.1"),
+        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.1",
-  "source_digest": "5c97e638daf3eab1aeac1eaa644b771787a9d8cfd1a9756e7ab4e76a7aba523e",
-  "source_file_count": 2265,
-  "built_at_source_time": 1781080652355
+  "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.1';
+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/agent-message-bus.js

@@ -1,11 +1,21 @@
 import path from 'node:path';
-import { appendJsonl } from '../fsx.js';
+import fs from 'node:fs/promises';
+import { appendJsonl, nowIso } from '../fsx.js';
 import { appendAgentLedgerEvent } from './agent-central-ledger.js';
 export async function appendAgentMessage(root, message) {
+    const eventType = normalizeAgentMessageEventType(message.event_type || message.type);
     const entry = {
         schema: 'sks.agent-message.v1',
+        ts: nowIso(),
+        mission_id: message.mission_id || inferMissionIdFromAgentRoot(root),
+        worker_id: message.worker_id || message.from,
+        slot_id: message.slot_id ?? message.from ?? null,
+        session_id: message.session_id || null,
+        level: message.level || (eventType === 'worker_failed' || eventType === 'blocker' ? 'error' : 'info'),
+        event_type: eventType,
+        message: message.body,
+        artifact_paths: message.artifact_paths || [],
         from: message.from,
-        session_id: message.session_id,
         to: message.to || 'orchestrator',
         type: message.type || 'note',
         body: message.body
@@ -14,4 +24,81 @@ export async function appendAgentMessage(root, message) {
     await appendAgentLedgerEvent(root, { agent_id: message.from, session_id: message.session_id, event_type: 'message_appended', payload: { to: entry.to, type: entry.type } });
     return entry;
 }
+export async function readAgentMessageBus(root, missionId, opts = {}) {
+    const file = agentMessageBusPath(root, missionId);
+    let text = '';
+    try {
+        text = await fs.readFile(file, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const levels = new Set((opts.levels || []).map((level) => String(level)));
+    const rows = text.split(/\n+/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return normalizeAgentMessageBusEntry(JSON.parse(line), missionId);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((row) => Boolean(row))
+        .filter((row) => !levels.size || levels.has(row.level));
+    const max = Math.max(0, Math.floor(Number(opts.max || rows.length)));
+    return max > 0 ? rows.slice(-max) : rows;
+}
+export function agentMessageBusPath(root, missionId) {
+    const resolved = path.resolve(root);
+    if (path.basename(resolved) === 'agents')
+        return path.join(resolved, 'agent-messages.jsonl');
+    if (path.basename(resolved) === missionId)
+        return path.join(resolved, 'agents', 'agent-messages.jsonl');
+    return path.join(resolved, '.sneakoscope', 'missions', missionId, 'agents', 'agent-messages.jsonl');
+}
+function normalizeAgentMessageBusEntry(value, missionId) {
+    const eventType = normalizeAgentMessageEventType(value.event_type || value.type);
+    return {
+        schema: 'sks.agent-message.v1',
+        ts: String(value.ts || value.generated_at || nowIso()),
+        mission_id: String(value.mission_id || missionId),
+        worker_id: String(value.worker_id || value.from || value.slot_id || 'worker'),
+        slot_id: value.slot_id == null ? value.from == null ? null : String(value.from) : String(value.slot_id),
+        session_id: value.session_id == null ? null : String(value.session_id),
+        level: normalizeAgentMessageLevel(value.level, eventType),
+        event_type: eventType,
+        message: String(value.message || value.body || ''),
+        artifact_paths: Array.isArray(value.artifact_paths) ? value.artifact_paths.map(String) : [],
+        from: value.from == null ? undefined : String(value.from),
+        to: value.to == null ? undefined : String(value.to),
+        type: value.type == null ? undefined : String(value.type),
+        body: value.body == null ? undefined : String(value.body)
+    };
+}
+function normalizeAgentMessageEventType(value) {
+    const text = String(value || '').toLowerCase();
+    if (text === 'worker_completed' || text === 'completed' || text === 'done')
+        return 'worker_completed';
+    if (text === 'worker_failed' || text === 'failed' || text === 'error')
+        return 'worker_failed';
+    if (text === 'blocker')
+        return 'blocker';
+    if (text === 'handoff')
+        return 'handoff';
+    return 'status';
+}
+function normalizeAgentMessageLevel(value, eventType) {
+    const text = String(value || '').toLowerCase();
+    if (text === 'info' || text === 'warning' || text === 'error')
+        return text;
+    if (eventType === 'worker_failed' || eventType === 'blocker')
+        return 'error';
+    return 'info';
+}
+function inferMissionIdFromAgentRoot(root) {
+    const resolved = path.resolve(root);
+    return path.basename(resolved) === 'agents' ? path.basename(path.dirname(resolved)) : 'unknown';
+}
 //# sourceMappingURL=agent-message-bus.js.map

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

@@ -1,8 +1,10 @@
 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') {
+export async function buildRuntimeProofSummary(root, missionIdInput = 'latest', opts = {}) {
     const missionId = missionIdInput === 'latest' ? await findLatestMission(root) : missionIdInput;
     if (!missionId)
         throw new Error('runtime_proof_summary_mission_missing');
@@ -13,6 +15,11 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest')
     const swarm = await readJson(path.join(agentsDir, 'agent-native-cli-session-swarm.json'), null);
     const telemetry = await readJson(path.join(dir, 'zellij', 'slot-telemetry.snapshot.json'), null);
     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;
     const visiblePanes = Number(parallel?.visible_panes ?? swarm?.zellij_pane_worker_sessions ?? telemetryVisiblePaneCount(telemetry) ?? 0);
     const targetActive = Number(scheduler?.target_active_slots ?? parallel?.target_active_slots ?? swarm?.target_active_slots ?? governor?.target_active_slots ?? 0);
@@ -21,7 +28,9 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest')
         ...(!parallel ? ['parallel_runtime_proof_missing'] : []),
         ...(!scheduler ? ['agent_scheduler_state_missing'] : []),
         ...(parallel?.passed === false ? parallel.blockers || ['parallel_runtime_proof_failed'] : []),
-        ...(telemetryAgeMs > 3000 ? ['zellij_telemetry_stale'] : [])
+        ...(errorMessages.length ? ['agent_message_bus_error_blockers'] : []),
+        ...(telemetryAgeMs > 3000 ? ['zellij_telemetry_stale'] : []),
+        ...(zellijSummary?.blockers || [])
     ].map(String);
     const summary = {
         schema: RUNTIME_PROOF_SUMMARY_SCHEMA,
@@ -48,6 +57,22 @@ export async function buildRuntimeProofSummary(root, missionIdInput = 'latest')
             largest_batch_size: Number(scheduler?.largest_batch_size || 0),
             utilization: Number(scheduler?.scheduler_utilization || 0)
         },
+        messages: {
+            recent: recentMessages,
+            completed_count: messagesAll.filter((row) => row.event_type === 'worker_completed').length,
+            failed_count: failedMessages.length,
+            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);
@@ -62,9 +87,28 @@ 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}`)
+        ] : []),
         ...(summary.blockers.length ? [`Blockers: ${summary.blockers.join(', ')}`] : [])
     ].join('\n');
 }
+function messageStatusLabel(row) {
+    if (row.event_type === 'worker_completed')
+        return '[done]';
+    if (row.event_type === 'worker_failed')
+        return '[fail]';
+    if (row.level === 'warning')
+        return '[warn]';
+    if (row.level === 'error')
+        return '[err]';
+    return '[info]';
+}
 function telemetryVisiblePaneCount(snapshot) {
     const slots = snapshot?.slots && typeof snapshot.slots === 'object' ? Object.values(snapshot.slots) : [];
     return slots.filter((row) => row?.status && row.status !== 'headless').length;

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/commands/naruto-command.js

@@ -741,7 +741,7 @@ async function narutoProof(parsed) {
     const id = parsed.missionId && parsed.missionId !== 'latest' ? parsed.missionId : await findLatestMission(root);
     if (!id)
         return emit(parsed, { schema: NARUTO_RESULT_SCHEMA, ok: false, action: 'proof', status: 'missing_mission' }, () => console.log('No Naruto mission found.'));
-    const summary = await buildRuntimeProofSummary(root, id);
+    const summary = await buildRuntimeProofSummary(root, id, { maxMessages: parsed.messages });
     return emit(parsed, { ...summary, action: 'proof' }, () => {
         console.log(renderRuntimeProofSummary(summary));
     });
@@ -756,7 +756,7 @@ async function narutoHelp(parsed) {
         usage: [
             'sks naruto run "<task>" [--clones N] [--backend codex-sdk|fake|ollama] [--local-model|--no-ollama] [--work-items N] [--real] [--readonly] [--json]',
             'sks naruto status [--mission <id>] [--json]',
-            'sks naruto proof latest [--json]'
+            'sks naruto proof latest [--messages 20] [--json]'
         ],
         defaults: { clones: DEFAULT_NARUTO_CLONES, max_clones: MAX_NARUTO_AGENT_COUNT, backend: 'codex-sdk' }
     };
@@ -798,9 +798,10 @@ function parseNarutoArgs(args = []) {
     const attach = hasFlag(args, '--attach');
     const smoke = hasFlag(args, '--smoke');
     const parallelism = normalizeParallelism(readOption(args, '--parallelism', 'extreme'));
-    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url', '--parallelism']);
+    const messages = normalizeMessages(readOption(args, '--messages', '8'));
+    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url', '--parallelism', '--messages']);
     const prompt = positionalArgs(rest, valueFlags).join(' ').trim() || 'Naruto shadow clone swarm run';
-    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach, smoke, parallelism };
+    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach, smoke, parallelism, messages };
 }
 function normalizeParallelism(value) {
     const text = String(value || 'extreme').toLowerCase();
@@ -808,6 +809,10 @@ function normalizeParallelism(value) {
         return text;
     return 'extreme';
 }
+function normalizeMessages(value) {
+    const parsed = Number(value);
+    return Math.max(0, Math.min(100, Math.floor(Number.isFinite(parsed) ? parsed : 8)));
+}
 async function writeNarutoArtifacts(ledgerRoot, artifacts) {
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-work-graph.json'), artifacts.workGraph);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-role-distribution.json'), artifacts.roleDistribution);

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.1';
+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';
 }