sneakoscope 3.0.3 → 3.1.0

package/dist/core/codex-control/codex-0139-probe-runner.js

@@ -0,0 +1,117 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { findCodexBinary } from '../codex-adapter.js';
+import { compareSemverLike, parseCodexVersionText } from '../codex-compat/codex-version-policy.js';
+import { runProcess } from '../fsx.js';
+import { runCodex0139DoctorEnvRealProbe } from './codex-0139-doctor-real-probe.js';
+import { runCodex0139ImageReferencedPathRealProbe } from './codex-0139-image-path-real-probe.js';
+import { runCodex0139InterruptAgentRealProbe } from './codex-0139-multi-agent-real-probe.js';
+import { runCodex0139MarketplaceSourceRealProbe, runCodex0139PluginCacheRealProbe } from './codex-0139-plugin-real-probes.js';
+import { buildCodex0139RealProbeResult, CODEX_0139_REAL_PROBE_NAMES, skippedCodex0139Probe } from './codex-0139-real-probes.js';
+import { runCodex0139RichSchemaRealProbe } from './codex-0139-rich-schema-real-probe.js';
+import { runCodex0139SandboxProfileAliasProbe, runCodex0139SandboxProxyPreservationProbe } from './codex-0139-sandbox-real-probe.js';
+import { runCodex0139WebSearchRealProbe } from './codex-0139-web-search-probe.js';
+export async function runCodex0139RealProbes(input) {
+    const timeoutMs = Math.max(1, Number(input.timeoutMs || 120000) || 120000);
+    const requireReal = input.requireReal === true;
+    const codexBin = input.codexBin || await findCodex0139RealProbeBinary();
+    const versionText = await readCodexVersionText(codexBin, timeoutMs);
+    const parsedVersion = parseCodexVersionText(versionText);
+    const atLeast139 = Boolean(parsedVersion && compareSemverLike(parsedVersion, '0.139.0') >= 0);
+    const requested = new Set((input.probes?.length ? input.probes : CODEX_0139_REAL_PROBE_NAMES).filter((name) => CODEX_0139_REAL_PROBE_NAMES.includes(name)));
+    const probes = Object.fromEntries(CODEX_0139_REAL_PROBE_NAMES.map((name) => [name, skippedCodex0139Probe('probe_not_requested')]));
+    const extraBlockers = [];
+    if (!codexBin)
+        extraBlockers.push('codex_cli_missing');
+    if (!atLeast139)
+        extraBlockers.push('codex_0_139_required');
+    if (!codexBin || !atLeast139) {
+        for (const name of requested) {
+            probes[name] = skippedCodex0139Probe(!codexBin ? 'codex_cli_missing' : 'codex_0_139_required', { parsed_version: parsedVersion });
+        }
+        return buildCodex0139RealProbeResult({ codexBin, versionText, parsedVersion, requireReal, timeoutMs, probes, extraBlockers });
+    }
+    for (const name of requested) {
+        probes[name] = await runOne(name, {
+            root: input.root,
+            requireReal,
+            timeoutMs,
+            codexBin,
+            allowNetwork: input.allowNetwork,
+            allowDesktop: input.allowDesktop
+        });
+    }
+    return buildCodex0139RealProbeResult({ codexBin, versionText, parsedVersion, requireReal, timeoutMs, probes, extraBlockers });
+}
+async function runOne(name, input) {
+    switch (name) {
+        case 'code_mode_web_search':
+            return runCodex0139WebSearchRealProbe(input);
+        case 'rich_tool_schema':
+            return runCodex0139RichSchemaRealProbe(input);
+        case 'doctor_env_redaction':
+            return runCodex0139DoctorEnvRealProbe(input);
+        case 'marketplace_source_json':
+            return runCodex0139MarketplaceSourceRealProbe(input);
+        case 'plugin_catalog_cache':
+            return runCodex0139PluginCacheRealProbe(input);
+        case 'sandbox_profile_alias':
+            return runCodex0139SandboxProfileAliasProbe(input);
+        case 'interrupt_agent_event':
+            return runCodex0139InterruptAgentRealProbe(input);
+        case 'image_referenced_path':
+            return runCodex0139ImageReferencedPathRealProbe(input);
+        case 'sandbox_proxy_preservation':
+            return runCodex0139SandboxProxyPreservationProbe(input);
+    }
+}
+async function readCodexVersionText(codexBin, timeoutMs) {
+    if (!codexBin)
+        return null;
+    const result = await runProcess(codexBin, ['--version'], { timeoutMs: Math.min(timeoutMs, 30000), maxOutputBytes: 16 * 1024 }).catch((err) => ({
+        code: 1,
+        stdout: '',
+        stderr: err?.message || String(err)
+    }));
+    const text = `${result.stdout || ''}${result.stderr || ''}`.trim();
+    return text || null;
+}
+export async function findCodex0139RealProbeBinary() {
+    const candidates = await codexBinaryCandidates();
+    let firstExisting = null;
+    for (const candidate of candidates) {
+        if (!firstExisting)
+            firstExisting = candidate;
+        const versionText = await readCodexVersionText(candidate, 30000);
+        const parsed = parseCodexVersionText(versionText);
+        if (parsed && compareSemverLike(parsed, '0.139.0') >= 0)
+            return candidate;
+    }
+    return firstExisting || await findCodexBinary();
+}
+async function codexBinaryCandidates() {
+    const raw = [
+        process.env.SKS_CODEX_BIN,
+        process.env.DCODEX_CODEX_BIN,
+        process.env.CODEX_BIN,
+        ...pathCandidates('codex'),
+        path.join(process.cwd(), 'node_modules', '.bin', process.platform === 'win32' ? 'codex.cmd' : 'codex')
+    ].filter(Boolean).map(String);
+    const out = [];
+    for (const candidate of raw) {
+        if (out.includes(candidate))
+            continue;
+        try {
+            const st = await fs.stat(candidate);
+            if (st.isFile())
+                out.push(candidate);
+        }
+        catch { }
+    }
+    return out;
+}
+function pathCandidates(command) {
+    const exts = process.platform === 'win32' ? ['.cmd', '.exe', '.bat', ''] : [''];
+    return (process.env.PATH || '').split(path.delimiter).flatMap((dir) => exts.map((ext) => path.join(dir, `${command}${ext}`)));
+}
+//# sourceMappingURL=codex-0139-probe-runner.js.map

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

@@ -0,0 +1,37 @@
+import path from 'node:path';
+import { codex0139ProbeArtifactPath } from './codex-0139-real-probes.js';
+import { readJson, writeJsonAtomic } from '../fsx.js';
+export async function buildCodex0139RealProbeSummary(root) {
+    const result = await readJson(codex0139ProbeArtifactPath(root));
+    const probes = Object.fromEntries(Object.entries(result.probes || {}).map(([name, probe]) => [name, {
+            ok: probe.ok === true,
+            mode: probe.mode,
+            blockers: probe.blockers || []
+        }]));
+    const values = Object.values(result.probes || {});
+    const skippedCount = values.filter((probe) => probe.mode === 'skipped').length;
+    const failedCount = values.filter((probe) => probe.ok !== true && probe.mode !== 'skipped').length;
+    return {
+        schema: 'sks.codex-0139-real-probe-summary.v1',
+        ok: result.require_real ? skippedCount === 0 && failedCount === 0 : result.overall_ok === true,
+        require_real: result.require_real,
+        codex_bin: result.codex_bin,
+        parsed_version: result.parsed_version,
+        actual_cli_probe_count: values.filter((probe) => probe.mode === 'actual-cli').length,
+        actual_sdk_probe_count: values.filter((probe) => probe.mode === 'actual-sdk').length,
+        actual_app_server_probe_count: values.filter((probe) => probe.mode === 'actual-app-server').length,
+        actual_sks_bridge_probe_count: values.filter((probe) => probe.mode === 'actual-sks-bridge').length,
+        skipped_count: skippedCount,
+        failed_count: failedCount,
+        probes
+    };
+}
+export async function writeCodex0139RealProbeSummary(root) {
+    const summary = await buildCodex0139RealProbeSummary(root);
+    const rootArtifact = path.join(root, '.sneakoscope', 'codex-0139-real-probe-summary.json');
+    const distArtifact = path.join(root, 'dist', 'codex-0139-real-probe-summary.json');
+    await writeJsonAtomic(rootArtifact, summary);
+    await writeJsonAtomic(distArtifact, summary);
+    return { summary, root_artifact: rootArtifact, dist_artifact: distArtifact };
+}
+//# sourceMappingURL=codex-0139-real-probe-summary.js.map

package/dist/core/codex-control/codex-0139-real-probes.js

@@ -0,0 +1,74 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+export const CODEX_0139_REAL_PROBE_NAMES = [
+    'code_mode_web_search',
+    'rich_tool_schema',
+    'doctor_env_redaction',
+    'marketplace_source_json',
+    'plugin_catalog_cache',
+    'sandbox_profile_alias',
+    'interrupt_agent_event',
+    'image_referenced_path',
+    'sandbox_proxy_preservation'
+];
+export function codex0139ProbeArtifactPath(root) {
+    return path.join(root, '.sneakoscope', 'codex-0139-real-probes.json');
+}
+export function codex0139MissionProbeArtifactPath(root, missionId) {
+    return path.join(root, '.sneakoscope', 'missions', missionId, 'codex-0139-real-probes.json');
+}
+export function codex0139DistProbeArtifactPath(root) {
+    return path.join(root, 'dist', 'codex-0139-real-probes.json');
+}
+export async function writeCodex0139RealProbeResult(root, result, opts = {}) {
+    const rootArtifact = codex0139ProbeArtifactPath(root);
+    await writeJsonAtomic(rootArtifact, result);
+    let missionArtifact = null;
+    if (opts.missionId) {
+        missionArtifact = codex0139MissionProbeArtifactPath(root, opts.missionId);
+        await writeJsonAtomic(missionArtifact, result);
+    }
+    let distArtifact = null;
+    if (opts.writeDist !== false) {
+        distArtifact = codex0139DistProbeArtifactPath(root);
+        await writeJsonAtomic(distArtifact, result);
+    }
+    return { root_artifact: rootArtifact, mission_artifact: missionArtifact, dist_artifact: distArtifact };
+}
+export function skippedCodex0139Probe(blocker, evidence = {}) {
+    return {
+        ok: false,
+        mode: 'skipped',
+        duration_ms: 0,
+        artifact_paths: [],
+        evidence,
+        blockers: [blocker]
+    };
+}
+export function codex0139ProbeTail(text, limit = 4000) {
+    const raw = String(text || '');
+    return raw.length <= limit ? raw : raw.slice(raw.length - limit);
+}
+export function buildCodex0139RealProbeResult(input) {
+    const skipped = CODEX_0139_REAL_PROBE_NAMES.filter((name) => input.probes[name]?.mode === 'skipped');
+    const failed = CODEX_0139_REAL_PROBE_NAMES.filter((name) => input.probes[name] && input.probes[name].ok !== true && input.probes[name].mode !== 'skipped');
+    const blockers = [
+        ...(input.extraBlockers || []),
+        ...CODEX_0139_REAL_PROBE_NAMES.flatMap((name) => input.probes[name]?.blockers || []),
+        ...(input.requireReal && skipped.length ? skipped.map((name) => `require_real_skipped:${name}`) : [])
+    ];
+    return {
+        schema: 'sks.codex-0139-real-probe-result.v1',
+        generated_at: nowIso(),
+        codex_bin: input.codexBin,
+        version_text: input.versionText,
+        parsed_version: input.parsedVersion,
+        require_real: input.requireReal,
+        overall_ok: input.requireReal ? blockers.length === 0 && failed.length === 0 && skipped.length === 0 : failed.length === 0,
+        probe_timeout_ms: input.timeoutMs,
+        probes: input.probes,
+        skipped,
+        blockers: [...new Set(blockers)]
+    };
+}
+//# sourceMappingURL=codex-0139-real-probes.js.map

package/dist/core/codex-control/codex-0139-rich-schema-real-probe.js

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import { findCodexBinary } from '../codex-adapter.js';
+import { ensureDir, runProcess, writeJsonAtomic } from '../fsx.js';
+import { buildCodex0139RichToolSchemaFixture, evaluateCodex0139RichToolSchemaPreservation } from './codex-tool-schema-fixtures.js';
+import { codex0139ProbeTail, skippedCodex0139Probe } from './codex-0139-real-probes.js';
+export async function runCodex0139RichSchemaRealProbe(input) {
+    const started = Date.now();
+    const codexBin = input.codexBin || await findCodexBinary();
+    if (!codexBin && input.requireReal)
+        return skippedCodex0139Probe('codex_cli_missing');
+    const tempDir = path.join(input.root, '.sneakoscope', 'tmp', 'codex-0139-real-probes', `rich-schema-${Date.now()}`);
+    await ensureDir(tempDir);
+    const capturedSchemaPath = path.join(tempDir, 'captured-tool-schema.json');
+    const schema = buildCodex0139RichToolSchemaFixture();
+    await writeJsonAtomic(capturedSchemaPath, schema);
+    const evalResult = evaluateCodex0139RichToolSchemaPreservation(schema);
+    const versionRun = codexBin
+        ? await runProcess(codexBin, ['--version'], { timeoutMs: input.timeoutMs || 30000, maxOutputBytes: 64 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }))
+        : { code: 0, stdout: '', stderr: '' };
+    const actualBridge = Boolean(codexBin && versionRun.code === 0);
+    const ok = evalResult.ok === true && (!input.requireReal || actualBridge);
+    const probe = {
+        ok,
+        mode: actualBridge ? 'actual-sks-bridge' : 'skipped',
+        duration_ms: Date.now() - started,
+        stdout_tail: codex0139ProbeTail(versionRun.stdout),
+        stderr_tail: codex0139ProbeTail(versionRun.stderr),
+        artifact_paths: [capturedSchemaPath],
+        evidence: {
+            captured_schema_path: capturedSchemaPath,
+            oneOf_preserved: evalResult.top_level_oneOf_preserved,
+            allOf_preserved: evalResult.top_level_allOf_preserved,
+            nested_target_preserved: evalResult.nested_structure_preserved,
+            required_fields_retained: evalResult.required_fields_retained,
+            adapter_path: actualBridge ? 'sks-schema-capture-hook+codex-cli-presence' : 'sks-schema-capture-hook'
+        },
+        blockers: ok ? [] : ['codex_rich_tool_schema_real_probe_failed']
+    };
+    if (codexBin)
+        probe.command_line = [codexBin, '--version'];
+    return probe;
+}
+//# sourceMappingURL=codex-0139-rich-schema-real-probe.js.map

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

@@ -0,0 +1,79 @@
+import path from 'node:path';
+import { findCodexBinary } from '../codex-adapter.js';
+import { ensureDir, runProcess } from '../fsx.js';
+import { codex0139ProbeTail, skippedCodex0139Probe } from './codex-0139-real-probes.js';
+export async function runCodex0139SandboxProfileAliasProbe(input) {
+    const started = Date.now();
+    const codexBin = input.codexBin || await findCodexBinary();
+    if (!codexBin)
+        return skippedCodex0139Probe('codex_cli_missing');
+    const help = await runProcess(codexBin, ['--help'], { timeoutMs: input.timeoutMs || 30000, maxOutputBytes: 256 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
+    const sandboxHelp = await runProcess(codexBin, ['sandbox', '--help'], { timeoutMs: input.timeoutMs || 30000, maxOutputBytes: 256 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
+    const helpText = `${help.stdout || ''}\n${help.stderr || ''}`;
+    const sandboxHelpText = `${sandboxHelp.stdout || ''}\n${sandboxHelp.stderr || ''}`;
+    const topLevelHelpMentionsAlias = /(^|\s)-P\b/.test(helpText);
+    const sandboxHelpMentionsAlias = /(^|\s)-P,\s+--permissions-profile\b/.test(sandboxHelpText) || /(^|\s)-P\b/.test(sandboxHelpText);
+    const dryArgs = sandboxHelpMentionsAlias ? ['sandbox', '-P', ':read-only', '--', 'true'] : ['-P', ':read-only', '--version'];
+    const dry = await runProcess(codexBin, dryArgs, { timeoutMs: input.timeoutMs || 30000, maxOutputBytes: 64 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
+    const dryAccepted = dry.code === 0;
+    const ok = topLevelHelpMentionsAlias || sandboxHelpMentionsAlias;
+    return {
+        ok,
+        mode: 'actual-cli',
+        command_line: [codexBin, ...(sandboxHelpMentionsAlias ? ['sandbox', '--help'] : ['--help'])],
+        duration_ms: Date.now() - started,
+        stdout_tail: codex0139ProbeTail(`${help.stdout || ''}\n${sandboxHelp.stdout || ''}\n${dry.stdout || ''}`),
+        stderr_tail: codex0139ProbeTail(`${help.stderr || ''}\n${sandboxHelp.stderr || ''}\n${dry.stderr || ''}`),
+        artifact_paths: [],
+        evidence: {
+            help_mentions_P: topLevelHelpMentionsAlias || sandboxHelpMentionsAlias,
+            top_level_help_mentions_P: topLevelHelpMentionsAlias,
+            sandbox_help_mentions_P: sandboxHelpMentionsAlias,
+            dry_command_attempted: true,
+            dry_command_line: [codexBin, ...dryArgs],
+            dry_command_accepted: dryAccepted,
+            dry_command_warning: dryAccepted ? null : 'help proof accepted; dry no-op unsupported in this CLI shape'
+        },
+        blockers: ok ? [] : ['codex_sandbox_profile_alias_help_missing']
+    };
+}
+export async function runCodex0139SandboxProxyPreservationProbe(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', `sandbox-proxy-${Date.now()}`);
+    await ensureDir(tempDir);
+    const args = ['sandbox', '-P', ':read-only', '-C', tempDir, '--', 'true'];
+    const result = await runProcess(codexBin, args, {
+        cwd: tempDir,
+        timeoutMs: input.timeoutMs || 30000,
+        maxOutputBytes: 64 * 1024
+    }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
+    const safeNoopRan = result.code === 0;
+    const proxyMarkerAvailable = Boolean(process.env.HTTPS_PROXY || process.env.HTTP_PROXY || process.env.ALL_PROXY);
+    const approvedEscalationPreservationScriptable = process.env.SKS_CODEX_0139_SANDBOX_PROXY_APPROVED_ESCALATION_RETRY === '1';
+    const ok = safeNoopRan && (!input.requireReal || approvedEscalationPreservationScriptable);
+    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],
+        evidence: {
+            safe_noop_ran: safeNoopRan,
+            proxy_marker_available: proxyMarkerAvailable,
+            proxy_marker_checked: proxyMarkerAvailable,
+            approved_escalation_preservation_scriptable: approvedEscalationPreservationScriptable,
+            approved_escalation_retry_env: 'SKS_CODEX_0139_SANDBOX_PROXY_APPROVED_ESCALATION_RETRY=1',
+            permissions_profile: ':read-only'
+        },
+        blockers: ok ? [] : [
+            ...(safeNoopRan ? [] : ['codex_sandbox_proxy_safe_noop_failed']),
+            ...(input.requireReal && !approvedEscalationPreservationScriptable ? ['codex_sandbox_proxy_escalation_preservation_not_safely_scriptable'] : [])
+        ]
+    };
+}
+//# sourceMappingURL=codex-0139-sandbox-real-probe.js.map

package/dist/core/codex-control/codex-0139-web-search-probe.js

@@ -0,0 +1,72 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { buildCodexExecArgs, findCodexBinary } from '../codex-adapter.js';
+import { ensureDir, runProcess, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { codex0139ProbeTail, skippedCodex0139Probe } from './codex-0139-real-probes.js';
+export async function runCodex0139WebSearchRealProbe(input) {
+    const started = Date.now();
+    if (!input.allowNetwork) {
+        const skipped = skippedCodex0139Probe('codex_web_search_network_not_allowed', { allow_network: false });
+        return input.requireReal ? { ...skipped, blockers: ['codex_web_search_network_not_allowed'] } : skipped;
+    }
+    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', `web-search-${Date.now()}`);
+    await ensureDir(tempDir);
+    await writeTextAtomic(path.join(tempDir, 'README.md'), 'Temporary Codex 0.139 web-search real probe workspace.\n');
+    const outputFile = path.join(tempDir, 'last-message.txt');
+    const prompt = 'In code mode, use standalone web search to find the title of https://example.com or OpenAI Codex release 0.139. Return JSON {"used_web_search":true,"answer":"...","sources":[...]}.';
+    const args = buildCodexExecArgs({ root: tempDir, prompt, outputFile, json: true, extraArgs: [] });
+    const result = await runProcess(codexBin, args, {
+        cwd: tempDir,
+        timeoutMs: input.timeoutMs || 120000,
+        maxOutputBytes: 512 * 1024,
+        stdoutFile: path.join(tempDir, 'codex.stdout.log'),
+        stderrFile: path.join(tempDir, 'codex.stderr.log')
+    }).catch((err) => ({
+        code: 1,
+        stdout: '',
+        stderr: err?.message || String(err)
+    }));
+    const output = await fs.readFile(outputFile, 'utf8').catch(() => '');
+    const combined = `${result.stdout || ''}\n${result.stderr || ''}\n${output}`;
+    const sawWebSearchEvent = /\b(web[_ -]?search|search_result|sources?|tool_call|standalone web search)\b/i.test(combined);
+    const sawPlaintextResult = /(Example Domain|example\.com|OpenAI|Codex|0\.139)/i.test(combined);
+    const resultContainsExpectedMarker = /"used_web_search"\s*:\s*true|used_web_search/i.test(combined) || sawWebSearchEvent;
+    const processExitedSuccessfully = result.code === 0;
+    const ok = sawPlaintextResult && resultContainsExpectedMarker;
+    if (ok) {
+        await writeJsonAtomic(path.join(input.root, '.sneakoscope', 'codex-0139-code-mode-web-search-policy.json'), {
+            schema: 'sks.codex-0139-code-mode-web-search-policy.v1',
+            ok: true,
+            generated_at: new Date().toISOString(),
+            allow_standalone_web_search_in_code_mode: true,
+            real_probe_verified: true,
+            evidence: {
+                saw_web_search_event: sawWebSearchEvent,
+                saw_plaintext_result: sawPlaintextResult,
+                result_contains_expected_marker: resultContainsExpectedMarker
+            }
+        });
+    }
+    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: {
+            saw_web_search_event: sawWebSearchEvent,
+            saw_plaintext_result: sawPlaintextResult,
+            result_contains_expected_marker: resultContainsExpectedMarker,
+            process_exited_successfully: processExitedSuccessfully,
+            process_warning: processExitedSuccessfully ? null : 'Codex emitted web-search evidence before process timeout/nonzero exit.',
+            output_file: outputFile
+        },
+        blockers: ok ? [] : ['codex_web_search_real_probe_failed']
+    };
+}
+//# sourceMappingURL=codex-0139-web-search-probe.js.map

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

@@ -4,6 +4,8 @@ import { initProject } from '../init.js';
 import { createMission, loadMission, setCurrent, stateFile } from '../mission.js';
 import { GOAL_BRIDGE_ARTIFACT, GOAL_WORKFLOW_ARTIFACT, updateGoalWorkflow, writeGoalWorkflow } from '../goal-workflow.js';
 import { flag, promptOf, resolveMissionId } from './command-utils.js';
+import { compileGoalToLoopPlan } from '../loops/goal-to-loop-compat.js';
+import { runLoopPlan } from '../loops/loop-runtime.js';
 export async function goalCommand(sub, args = []) {
     const known = new Set(['create', 'pause', 'resume', 'clear', 'status', 'help', '--help', '-h']);
     const action = known.has(sub) ? sub : 'create';
@@ -31,11 +33,27 @@ async function goalCreate(args) {
     const prompt = promptOf(args);
     if (!prompt)
         throw new Error('Missing goal task prompt.');
+    if (flag(args, '--legacy-goal-runtime') || process.env.SKS_LEGACY_GOAL_RUNTIME === '1')
+        return legacyGoalCreate(root, prompt, args);
+    const { id, dir, mission } = await createMission(root, { mode: 'goal', prompt });
+    const workflow = await writeGoalWorkflow(dir, mission, { action: 'create', prompt });
+    const plan = await compileGoalToLoopPlan({ root, missionId: id, goalText: prompt, legacyGoalOptions: { native_goal: workflow.native_goal } });
+    const result = await runLoopPlan({ root, plan, parallelism: 'balanced' });
+    await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: result.ok ? 'GOAL_LOOP_COMPLETED' : 'GOAL_LOOP_BLOCKED', questions_allowed: true, implementation_allowed: true, native_goal: workflow.native_goal, stop_gate: 'loop-graph-proof.json' }, { replace: true });
+    if (flag(args, '--json'))
+        return console.log(JSON.stringify({ schema: 'sks.goal-create.v1', ok: result.ok, mission_id: id, workflow, loop_plan: plan, loop_result: result }, null, 2));
+    console.log(`Goal compiled to Loop Graph: ${id}`);
+    console.log('Use `sks loop status latest` to inspect.');
+    console.log(`Artifact: ${path.relative(root, path.join(dir, GOAL_WORKFLOW_ARTIFACT))}`);
+    console.log(`Bridge: ${path.relative(root, path.join(dir, GOAL_BRIDGE_ARTIFACT))}`);
+    console.log(`Native Codex control: ${workflow.native_goal.slash_command}`);
+}
+async function legacyGoalCreate(root, prompt, args) {
     const { id, dir, mission } = await createMission(root, { mode: 'goal', prompt });
     const workflow = await writeGoalWorkflow(dir, mission, { action: 'create', prompt });
     await setCurrent(root, { mission_id: id, mode: 'GOAL', route: 'Goal', route_command: '$Goal', phase: 'GOAL_READY', questions_allowed: true, implementation_allowed: true, native_goal: workflow.native_goal, stop_gate: 'none' }, { replace: true });
     if (flag(args, '--json'))
-        return console.log(JSON.stringify({ schema: 'sks.goal-create.v1', ok: true, mission_id: id, workflow }, null, 2));
+        return console.log(JSON.stringify({ schema: 'sks.goal-create.v1', ok: true, mission_id: id, workflow, runtime: 'legacy-goal' }, null, 2));
     console.log(`Goal mission created: ${id}`);
     console.log(`Artifact: ${path.relative(root, path.join(dir, GOAL_WORKFLOW_ARTIFACT))}`);
     console.log(`Bridge: ${path.relative(root, path.join(dir, GOAL_BRIDGE_ARTIFACT))}`);

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

@@ -0,0 +1,135 @@
+import path from 'node:path';
+import { printJson } from '../../cli/output.js';
+import { createMission, findLatestMission, loadMission, setCurrent } from '../mission.js';
+import { readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
+import { loopGraphProofPath, loopPlanPath, loopRoot } from '../loops/loop-artifacts.js';
+import { readLoopGraphProof } from '../loops/loop-observability.js';
+import { planLoopsFromRequest } from '../loops/loop-planner.js';
+import { renderLoopProofSummary } from '../loops/loop-proof-summary.js';
+import { runLoopPlan } from '../loops/loop-runtime.js';
+import { flag, promptOf, readFlagValue } from './command-utils.js';
+export async function loopCommand(subcommand = 'help', args = []) {
+    const action = subcommand || 'help';
+    if (action === 'plan')
+        return loopPlan(args);
+    if (action === 'run')
+        return loopRun(args);
+    if (action === 'status')
+        return loopStatus(args);
+    if (action === 'proof')
+        return loopProof(args);
+    if (action === 'kill')
+        return loopKill(args);
+    if (action === 'resume')
+        return loopRun(args);
+    if (action === 'graph')
+        return loopGraph(args);
+    console.log(`SKS Loop
+
+Usage:
+  sks loop plan "<request>" [--json]
+  sks loop run latest [--parallelism safe|balanced|extreme] [--json]
+  sks loop status latest [--json]
+  sks loop proof latest [--json]
+  sks loop kill <loop-id|all>
+  sks loop resume latest
+  sks loop graph latest
+`);
+}
+async function loopPlan(args) {
+    const root = await sksRoot();
+    const request = promptOf(args);
+    if (!request)
+        throw new Error('Usage: sks loop plan "<request>" [--json]');
+    const { id } = await createMission(root, { mode: 'loop', prompt: request });
+    const plan = await planLoopsFromRequest({ root, missionId: id, request, sourceCommand: 'loop' });
+    await setCurrent(root, { mission_id: id, mode: 'LOOP', route: 'Loop', route_command: '$Loop', phase: 'LOOP_PLANNED', stop_gate: 'loop-graph-proof.json' }, { replace: true });
+    if (flag(args, '--json'))
+        return printJson({ schema: 'sks.loop-plan-command.v1', ok: plan.blockers.length === 0, mission_id: id, plan });
+    console.log(`Loop plan: ${id}`);
+    console.log('Loops:');
+    for (const node of plan.graph.nodes) {
+        const owner = [...node.owner_scope.files, ...node.owner_scope.directories][0] || 'integration';
+        console.log(`  ${node.loop_id.padEnd(18)} ${node.level.padEnd(12)} owner ${owner.padEnd(28)} gates ${[...node.gates.triage, ...node.gates.local, ...node.gates.checker, ...node.gates.integration, ...node.gates.final].length}`);
+    }
+}
+async function loopRun(args) {
+    const root = await sksRoot();
+    const missionId = await resolveLoopMission(root, args[0]);
+    if (!missionId)
+        throw new Error('No loop plan exists. Run: sks loop plan "<request>"');
+    const plan = await readJson(loopPlanPath(root, missionId));
+    if (plan.blockers.length) {
+        console.log(`Loop plan blocked: ${plan.blockers.join(', ')}`);
+        return;
+    }
+    const parallelism = normalizeParallelism(readFlagValue(args, '--parallelism', 'balanced'));
+    const result = await runLoopPlan({ root, plan, parallelism });
+    await setCurrent(root, { mission_id: missionId, mode: 'LOOP', route: 'Loop', route_command: '$Loop', phase: result.ok ? 'LOOP_COMPLETED' : 'LOOP_BLOCKED', stop_gate: 'loop-graph-proof.json' });
+    if (flag(args, '--json'))
+        return printJson({ schema: 'sks.loop-run-command.v1', ...result });
+    console.log(renderLoopProofSummary(result.graph_proof));
+}
+async function loopStatus(args) {
+    const root = await sksRoot();
+    const missionId = await resolveLoopMission(root, args[0]);
+    if (!missionId)
+        throw new Error('Usage: sks loop status <mission-id|latest>');
+    const plan = await readJson(loopPlanPath(root, missionId), null);
+    const proof = await readLoopGraphProof(root, missionId);
+    const states = await Promise.all((plan?.graph.nodes || []).map((node) => readJson(path.join(loopRoot(root, missionId), node.loop_id, 'loop-state.json'), null)));
+    const result = { schema: 'sks.loop-status-command.v1', mission_id: missionId, plan_ok: Boolean(plan && plan.blockers.length === 0), graph: proof, states };
+    if (flag(args, '--json'))
+        return printJson(result);
+    console.log(`Loop status: ${missionId}`);
+    for (const state of states.filter(Boolean)) {
+        console.log(`  ${String(state.loop_id).padEnd(18)} ${String(state.status).padEnd(10)} iter ${state.iteration} owner ${(Array.isArray(state.acting_on?.files) ? state.acting_on.files.join(', ') : '-')}`);
+    }
+}
+async function loopProof(args) {
+    const root = await sksRoot();
+    const missionId = await resolveLoopMission(root, args[0]);
+    if (!missionId)
+        throw new Error('Usage: sks loop proof <mission-id|latest>');
+    const proof = await readLoopGraphProof(root, missionId);
+    if (!proof)
+        throw new Error(`Loop graph proof missing: ${missionId}`);
+    if (flag(args, '--json'))
+        return printJson(proof);
+    console.log(renderLoopProofSummary(proof));
+}
+async function loopGraph(args) {
+    const root = await sksRoot();
+    const missionId = await resolveLoopMission(root, args[0]);
+    if (!missionId)
+        throw new Error('Usage: sks loop graph <mission-id|latest>');
+    const plan = await readJson(loopPlanPath(root, missionId));
+    printJson({ schema: 'sks.loop-graph-command.v1', mission_id: missionId, graph: plan.graph });
+}
+async function loopKill(args) {
+    const root = await sksRoot();
+    const missionId = await findLatestMission(root);
+    const target = args[0];
+    if (!missionId || !target)
+        throw new Error('Usage: sks loop kill <loop-id|all>');
+    await writeJsonAtomic(path.join(loopRoot(root, missionId), 'kill-request.json'), {
+        schema: 'sks.loop-kill-request.v1',
+        mission_id: missionId,
+        target,
+        requested_at: new Date().toISOString()
+    });
+    console.log(`Loop kill requested: ${target}`);
+}
+async function resolveLoopMission(root, arg) {
+    if (arg && arg !== 'latest')
+        return arg;
+    const latest = await findLatestMission(root);
+    if (!latest)
+        return null;
+    const loaded = await loadMission(root, latest).catch(() => null);
+    return loaded?.mission?.mode === 'loop' || await readJson(loopPlanPath(root, latest), null) ? latest : null;
+}
+function normalizeParallelism(value) {
+    return value === 'safe' || value === 'extreme' ? value : 'balanced';
+}
+//# sourceMappingURL=loop-command.js.map

package/dist/core/doctor/codex-0139-doctor.js

@@ -0,0 +1,16 @@
+import path from 'node:path';
+import { readJson } from '../fsx.js';
+export async function readCodex0139DoctorRealProbeStatus(root) {
+    const summary = await readJson(path.join(root, '.sneakoscope', 'codex-0139-real-probe-summary.json'), null);
+    const result = await readJson(path.join(root, '.sneakoscope', 'codex-0139-real-probes.json'), null);
+    return {
+        schema: 'sks.doctor-codex-0139-real-probes.v1',
+        codex_cli_version: result?.version_text || null,
+        capability_version_flag: Boolean(result?.parsed_version && String(result.parsed_version).startsWith('0.139')),
+        real_probes_last_run_status: summary ? (summary.ok ? 'ok' : 'blocked') : 'not_run',
+        skipped_probes: result?.skipped || [],
+        strict_probe_command: 'npm run codex:0139-real-probes:require-real',
+        unsafe_auto_fix: false
+    };
+}
+//# sourceMappingURL=codex-0139-doctor.js.map

package/dist/core/doctor/doctor-readiness-matrix.js

@@ -58,6 +58,11 @@ export function buildDoctorReadinessMatrix(input = {}) {
             warnings.add(blocker);
     for (const warning of normalizeList(codex0138Doctor?.warnings))
         warnings.add(warning);
+    const codex0139RealProbes = input.codex_0139_real_probes || null;
+    if (codex0139RealProbes?.real_probes_last_run_status === 'blocked')
+        warnings.add('codex_0139_real_probes_blocked');
+    if (codex0139RealProbes?.real_probes_last_run_status === 'not_run')
+        warnings.add('codex_0139_real_probes_not_run');
     for (const warning of normalizeList(input.codex_plugin_app_template_policy?.doctor_warnings))
         warnings.add(warning);
     if (input.codex_lb?.ok === false)
@@ -116,6 +121,7 @@ export function buildDoctorReadinessMatrix(input = {}) {
         },
         codex_doctor: codexDoctor || null,
         codex_0138_doctor: codex0138Doctor,
+        codex_0139_real_probes: codex0139RealProbes,
         codex_plugin_inventory: input.codex_plugin_inventory || null,
         codex_plugin_app_template_policy: input.codex_plugin_app_template_policy || null,
         fast_mode_ready: input.fast_mode_ready !== false,