sneakoscope 3.0.0 → 3.0.1

package/README.md

@@ -35,9 +35,11 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **3.0.0** is 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.
+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).
 
-What changed:
+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.
+
+What changed in 3.0.0:
 
 - **Slot panes are finally alive.** The watch renderer froze for entire missions because the telemetry snapshot cache never invalidated; snapshot reads are now mtime-aware, multi-process flushes merge instead of clobbering each other, and the disk `updated_at` stays authoritative for stale detection.
 - **One SLOTS column, vertical stack.** Concurrent workers used to race anchor creation and split the screen into N side-by-side columns. Anchor + worker pane creation is serialized per session, and workers join a native Zellij stacked-pane group (`new-pane --stacked`, opt out with `SKS_ZELLIJ_WORKER_STACKED=0`).

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.0.0"
+version = "3.0.1"
 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.0"),
+        Some("--version") => println!("sks-rs 3.0.1"),
         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.0",
-  "source_digest": "4404689ab837df49f305f9fa2995c5301fefb9305f47cde1abec4613dcbbfeaa",
-  "source_file_count": 2262,
-  "built_at_source_time": 1781078944628
+  "package_version": "3.0.1",
+  "source_digest": "5c97e638daf3eab1aeac1eaa644b771787a9d8cfd1a9756e7ab4e76a7aba523e",
+  "source_file_count": 2265,
+  "built_at_source_time": 1781080652355
 }

package/dist/bin/sks.js

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

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

@@ -0,0 +1,102 @@
+import path from 'node:path';
+import { findCodexBinary } from '../codex-adapter.js';
+import { compareSemverLike, parseCodexVersionText } from '../codex-compat/codex-version-policy.js';
+import { nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
+export async function detectCodex0139Capability(input = {}) {
+    const fake = process.env.SKS_CODEX_0139_FAKE === '1';
+    const codexBin = fake
+        ? input.codexBin || process.env.CODEX_BIN || 'codex'
+        : input.codexBin || process.env.CODEX_BIN || await findCodexBinary();
+    const versionText = fake
+        ? String(process.env.SKS_CODEX_VERSION_FAKE || 'codex-cli 0.139.0')
+        : await readCodexVersionText(codexBin);
+    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 featureProbeResults = probeMode === 'feature-probe'
+        ? await probeCodex0139Features(codexBin, { fake })
+        : {
+            marketplace_list_json: 'skipped',
+            sandbox_profile_alias: 'skipped'
+        };
+    const marketplaceOk = atLeast139 && (probeMode === 'version-only' || featureProbeResults.marketplace_list_json !== 'failed');
+    const profileAliasOk = atLeast139 && (probeMode === 'version-only' || featureProbeResults.sandbox_profile_alias !== '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'] : [])
+    ];
+    return {
+        schema: 'sks.codex-0139-capability.v1',
+        ok: atLeast139 && blockers.length === 0,
+        probe_mode: probeMode,
+        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_marketplace_source_field: marketplaceOk,
+        supports_plugin_catalog_cache: atLeast139,
+        supports_sandbox_profile_alias: profileAliasOk,
+        supports_interrupt_agent_rename: atLeast139,
+        feature_probe_results: featureProbeResults,
+        blockers
+    };
+}
+export async function writeCodex0139CapabilityArtifacts(root, input = {}) {
+    const capability = await detectCodex0139Capability({ codexBin: input.codexBin || null });
+    const report = { ...capability, generated_at: nowIso() };
+    const rootArtifact = path.join(root, '.sneakoscope', 'codex-0139-capability.json');
+    await writeJsonAtomic(rootArtifact, report);
+    let missionArtifact = null;
+    if (input.missionId) {
+        missionArtifact = path.join(root, '.sneakoscope', 'missions', input.missionId, 'codex-0139-capability.json');
+        await writeJsonAtomic(missionArtifact, report);
+    }
+    return { report, root_artifact: rootArtifact, mission_artifact: missionArtifact };
+}
+async function readCodexVersionText(codexBin) {
+    if (!codexBin)
+        return null;
+    const result = await runProcess(codexBin, ['--version'], { timeoutMs: 10_000, maxOutputBytes: 16 * 1024 }).catch((err) => ({
+        code: 1,
+        stdout: '',
+        stderr: err?.message || String(err)
+    }));
+    const text = `${result.stdout || ''}${result.stderr || ''}`.trim();
+    return result.code === 0 ? text : text || null;
+}
+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'
+        };
+    }
+    const timeoutMs = Math.max(1, Number(process.env.SKS_CODEX_0139_PROBE_TIMEOUT_MS || 3000) || 3000);
+    if (!codexBin) {
+        return { marketplace_list_json: 'failed', sandbox_profile_alias: 'failed' };
+    }
+    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 || ''));
+    return {
+        marketplace_list_json: marketplaceListJson,
+        sandbox_profile_alias: aliasOk ? 'passed' : 'failed'
+    };
+}
+export function marketplaceSourcesPresent(stdout) {
+    try {
+        const parsed = JSON.parse(String(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);
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=codex-0139-capability.js.map

package/dist/core/commands/mad-sks-command.js

@@ -21,6 +21,7 @@ import { diffCodexAppUiSnapshots, writeCodexAppUiSnapshot } from '../codex-app/c
 import { checkSksUpdateNotice } from '../update/update-notice.js';
 import { createMadDbCapability, MAD_DB_ACK } from '../mad-db/mad-db-capability.js';
 import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-capability.js';
+import { writeCodex0139CapabilityArtifacts } from '../codex-control/codex-0139-capability.js';
 export async function madHighCommand(args = [], deps = {}) {
     const subcommand = firstSubcommand(args);
     if (subcommand)
@@ -385,6 +386,7 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
     const dbWriteAllowed = has('db_write');
     const { id, dir } = await createMission(root, { mode: 'mad-sks', prompt: 'sks --mad Zellij scoped high-power maintenance session' });
     await writeCodex0138CapabilityArtifacts(root, { missionId: id }).catch(() => null);
+    await writeCodex0139CapabilityArtifacts(root, { missionId: id }).catch(() => null);
     const protectedCore = resolveProtectedCore({ packageRoot: packageRoot(), targetRoot: cwd });
     // The interactive launch 'before' snapshot is only persisted (env + policy json)
     // and is never compared against an 'after' snapshot during the session, so the
@@ -571,6 +573,7 @@ function codexLbImmediateLaunchOpts(args = [], lb = {}, opts = {}) {
 export async function madSksFixture(root) {
     const { id, dir } = await createMission(root, { mode: 'mad-sks', prompt: '$MAD-SKS fixture permission gate' });
     await writeCodex0138CapabilityArtifacts(root, { missionId: id }).catch(() => null);
+    await writeCodex0139CapabilityArtifacts(root, { missionId: id }).catch(() => null);
     const gate = { schema_version: 1, passed: true, mad_sks_permission_active: true, permissions_deactivated: true, catastrophic_safety_guard_active: true, permission_profile: permissionGateSummary(), fixture: true };
     await writeJsonAtomic(path.join(dir, 'mad-sks-gate.json'), gate);
     return { mission_id: id, dir, gate };
@@ -746,6 +749,7 @@ async function materializeMadSksRun(root, targetRoot, permission, userIntent, js
         await initProject(root, {});
     const { id, dir } = await createMission(root, { mode: 'mad-sks', prompt: userIntent });
     await writeCodex0138CapabilityArtifacts(root, { missionId: id }).catch(() => null);
+    await writeCodex0139CapabilityArtifacts(root, { missionId: id }).catch(() => null);
     const before = await snapshotProtectedCore(packageRoot(), 'before');
     const authorization = opts.authorizationManifest || createMadSksAuthorizationManifest({ permission, userIntent });
     const authorizationPath = opts.authorizationManifestPath || path.join(dir, 'mad-sks-authorization.json');

package/dist/core/commands/naruto-command.js

@@ -23,6 +23,7 @@ import { checkPromptPlaceholders } from '../prompt/prompt-placeholder-guard.js';
 import { evaluateGitWorktreeCapability } from '../git/git-worktree-capability.js';
 import { buildRuntimeProofSummary, renderRuntimeProofSummary } from '../agents/runtime-proof-summary.js';
 import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-capability.js';
+import { writeCodex0139CapabilityArtifacts } from '../codex-control/codex-0139-capability.js';
 const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
 const NARUTO_ROUTE = '$Naruto';
 // $Naruto — Shadow Clone Swarm (影分身 / Kage Bunshin no Jutsu).
@@ -83,6 +84,7 @@ async function narutoRun(parsed) {
     });
     const mission = await createMission(root, { mode: 'naruto', prompt: parsed.prompt });
     await writeCodex0138CapabilityArtifacts(root, { missionId: mission.id }).catch(() => null);
+    await writeCodex0139CapabilityArtifacts(root, { missionId: mission.id }).catch(() => null);
     const gitWorktreeCapability = writeCapable
         ? await evaluateGitWorktreeCapability({ root, missionId: mission.id })
         : null;

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.0';
+export const PACKAGE_VERSION = '3.0.1';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

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

@@ -1249,13 +1249,15 @@ function subagentToolName(payload) {
 }
 function subagentStage(payload) {
     const hay = JSON.stringify(payload || {});
-    if (!/(spawn_agent|send_input|wait_agent|close_agent|subagent|worker|explorer)/i.test(hay))
+    // Codex 0.139 renamed multi-agent v2 `close_agent` to `interrupt_agent`;
+    // accept both so cockpit evidence keeps classifying on newer CLIs.
+    if (!/(spawn_agent|send_input|wait_agent|close_agent|interrupt_agent|subagent|worker|explorer)/i.test(hay))
         return null;
     if (/subagent[_ -]?unavailable|subagents unavailable|unsafe to split|unsplittable|cannot safely split/i.test(hay))
         return 'exception';
     if (/spawn_agent/i.test(hay))
         return 'spawn_agent';
-    if (/wait_agent|close_agent|completed|final/i.test(hay))
+    if (/wait_agent|close_agent|interrupt_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.0';
+export const PACKAGE_VERSION = '3.0.1';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -562,6 +562,7 @@
     "release:check:dag:no-cache": "node ./dist/scripts/release-gate-dag-runner.js --preset release --no-cache",
     "release:check:dag:fail-fast": "node ./dist/scripts/release-gate-dag-runner.js --preset release --fail-fast",
     "codex:0138-capability": "node ./dist/scripts/codex-0138-capability-check.js",
+    "codex:0139-capability": "node ./dist/scripts/codex-0139-capability-check.js",
     "codex:0138-capability-artifact": "node ./dist/scripts/codex-0138-capability-artifact-check.js",
     "codex-sdk:version-compat": "node ./dist/scripts/codex-sdk-version-compat-check.js",
     "codex-app:handoff": "node ./dist/scripts/codex-app-handoff-check.js",