sneakoscope 3.1.11 → 3.1.13

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

@@ -0,0 +1,136 @@
+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';
+import { CODEX_0140_FEATURE_KEYS, probeCodex0140FeatureDetails, probeCodex0140Features } from './codex-0140-feature-probes.js';
+export async function detectCodex0140Capability(input = {}) {
+    const fake = process.env.SKS_CODEX_0140_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.140.0') : await readCodexVersionText(codexBin);
+    const parsed = parseCodexVersionText(versionText);
+    const supports0140 = Boolean(parsed && compareSemverLike(parsed, '0.140.0') >= 0);
+    const probeMode = process.env.SKS_CODEX_0140_PROBE === '1' ? 'feature-probe' : 'version-only';
+    const probeTimeoutMs = Number(process.env.SKS_CODEX_0140_PROBE_TIMEOUT_MS || 3000);
+    const probeDetails = probeMode === 'feature-probe'
+        ? await probeCodex0140FeatureDetails(codexBin, { fake, timeoutMs: probeTimeoutMs })
+        : null;
+    const probeResults = probeDetails
+        ? Object.fromEntries(CODEX_0140_FEATURE_KEYS.map((key) => [key, probeDetails[key].status]))
+        : Object.fromEntries(CODEX_0140_FEATURE_KEYS.map((key) => [key, 'skipped']));
+    const featureStates = Object.fromEntries(CODEX_0140_FEATURE_KEYS.map((key) => [key, featureStateFor(key, supports0140, probeMode, probeDetails)]));
+    const featureCertainty = Object.fromEntries(CODEX_0140_FEATURE_KEYS.map((key) => [key, featureStates[key].certainty]));
+    const featureOk = (key) => featureStates[key].supported;
+    const features = {
+        usage_views: featureOk('usage_views'),
+        goal_attachment_preservation: featureOk('goal_attachment_preservation'),
+        session_delete: featureOk('session_delete'),
+        import_command: featureOk('import_command'),
+        unified_mentions: featureOk('unified_mentions'),
+        bedrock_managed_auth: featureOk('bedrock_managed_auth'),
+        sqlite_auto_recovery: featureOk('sqlite_auto_recovery'),
+        mcp_reliability: featureOk('mcp_reliability'),
+        non_tty_interrupt: featureOk('non_tty_interrupt'),
+        large_repo_responsiveness: featureOk('large_repo_responsiveness')
+    };
+    const failed = Object.entries(featureStates).flatMap(([key, state]) => state.certainty === 'failed' ? [`codex_0140_${key}_probe_failed`] : []);
+    const assumedWarnings = Object.entries(featureStates)
+        .filter(([, state]) => state.certainty === 'assumed_by_version')
+        .map(([key]) => `codex_0140_${key}_assumed_by_version`);
+    const unverifiedWarnings = Object.entries(featureStates)
+        .filter(([, state]) => state.certainty === 'unverified')
+        .map(([key]) => `codex_0140_${key}_unverified`);
+    const blockers = [
+        ...(!codexBin ? ['codex_cli_missing'] : []),
+        ...(supports0140 ? [] : ['codex_0_140_required_for_0140_features']),
+        ...(probeMode === 'feature-probe' ? failed : [])
+    ];
+    const report = {
+        schema: 'sks.codex-0140-capability.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        codex_version: parsed,
+        supports_0140: supports0140,
+        features,
+        feature_states: featureStates,
+        feature_certainty: featureCertainty,
+        blockers,
+        warnings: [...assumedWarnings, ...unverifiedWarnings],
+        codex_bin: codexBin || null,
+        probe_mode: probeMode,
+        feature_probe_results: probeResults
+    };
+    if (probeDetails)
+        report.feature_probe_details = probeDetails;
+    return report;
+}
+function featureStateFor(key, supports0140, probeMode, probeDetails) {
+    if (!supports0140) {
+        return {
+            supported: false,
+            certainty: 'failed',
+            evidence: [],
+            blockers: ['codex_0_140_required_for_0140_features']
+        };
+    }
+    if (probeMode === 'version-only') {
+        return {
+            supported: true,
+            certainty: 'assumed_by_version',
+            evidence: ['codex_version>=0.140.0'],
+            blockers: []
+        };
+    }
+    const detail = probeDetails?.[key];
+    if (!detail) {
+        return {
+            supported: false,
+            certainty: 'unverified',
+            evidence: [],
+            blockers: [`codex_0140_${key}_probe_missing`]
+        };
+    }
+    if (detail.status === 'failed') {
+        return {
+            supported: false,
+            certainty: 'failed',
+            evidence: detail.evidence,
+            blockers: detail.blockers.length ? detail.blockers : [`codex_0140_${key}_probe_failed`]
+        };
+    }
+    const certainty = normalizeCertainty(detail.certainty);
+    const supported = detail.status === 'passed' || detail.status === 'discovered';
+    return {
+        supported,
+        certainty: supported ? certainty : 'unverified',
+        evidence: detail.evidence,
+        blockers: supported ? [] : detail.blockers
+    };
+}
+function normalizeCertainty(certainty) {
+    if (certainty === 'actual' || certainty === 'discovered' || certainty === 'fixture' || certainty === 'assumed_by_version')
+        return certainty;
+    return 'unverified';
+}
+export async function writeCodex0140CapabilityArtifacts(root, input = {}) {
+    const report = await detectCodex0140Capability({ codexBin: input.codexBin || null });
+    const rootArtifact = path.join(root, '.sneakoscope', 'codex-0140-capability.json');
+    await writeJsonAtomic(rootArtifact, report);
+    let missionArtifact = null;
+    if (input.missionId) {
+        missionArtifact = path.join(root, '.sneakoscope', 'missions', input.missionId, 'codex-0140-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;
+}
+//# sourceMappingURL=codex-0140-capability.js.map

package/dist/core/codex-control/codex-0140-feature-probes.js

@@ -0,0 +1,195 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { ensureDir, runProcess, sha256, tmpdir } from '../fsx.js';
+import { parseCodex0140UsageOutput } from './codex-0140-usage-parser.js';
+export const CODEX_0140_FEATURE_KEYS = [
+    'usage_views',
+    'goal_attachment_preservation',
+    'session_delete',
+    'import_command',
+    'unified_mentions',
+    'bedrock_managed_auth',
+    'sqlite_auto_recovery',
+    'mcp_reliability',
+    'non_tty_interrupt',
+    'large_repo_responsiveness'
+];
+export async function probeCodex0140Features(codexBin, opts = {}) {
+    const details = await probeCodex0140FeatureDetails(codexBin, opts);
+    return Object.fromEntries(CODEX_0140_FEATURE_KEYS.map((key) => [key, details[key].status]));
+}
+export async function probeCodex0140FeatureDetails(codexBin, opts = {}) {
+    if (opts.fake) {
+        return Object.fromEntries(CODEX_0140_FEATURE_KEYS.map((key) => {
+            const failed = process.env[`SKS_CODEX_0140_FAKE_${key.toUpperCase()}_FAIL`] === '1';
+            return [key, probeResult(key, failed ? 'failed' : 'passed', failed ? 'unverified' : 'fixture', [`fixture:${key}`], failed ? [`${key}_fixture_failed`] : [], 0)];
+        }));
+    }
+    if (!codexBin)
+        return Object.fromEntries(CODEX_0140_FEATURE_KEYS.map((key) => [key, probeResult(key, 'failed', 'unverified', [], ['codex_cli_missing'], 0)]));
+    const timeoutMs = Math.max(1, Number(opts.timeoutMs || process.env.SKS_CODEX_0140_PROBE_TIMEOUT_MS || 3000) || 3000);
+    const probes = await Promise.all([
+        probeUsageViews(codexBin, timeoutMs),
+        probeGoalAttachmentPreservation(codexBin, timeoutMs),
+        probeSessionDelete(codexBin, timeoutMs),
+        probeImportCommand(codexBin, timeoutMs),
+        probeUnifiedMentions(codexBin, timeoutMs),
+        probeBedrockManagedAuth(codexBin, timeoutMs),
+        probeSqliteRecovery(codexBin, timeoutMs),
+        probeMcpReliability(codexBin, timeoutMs),
+        probeNonTtyInterrupt(codexBin, timeoutMs),
+        probeLargeRepoResponsiveness(codexBin, timeoutMs)
+    ]);
+    return Object.fromEntries(probes.map((probe) => [probe.key, probe]));
+}
+export async function probeUsageViews(codexBin, timeoutMs = 3000) {
+    const started = Date.now();
+    const realCommands = [['usage', '--json'], ['usage']];
+    const evidence = [];
+    for (const args of realCommands) {
+        const run = await runProcess(codexBin, args, { timeoutMs, maxOutputBytes: 128 * 1024 }).catch(() => null);
+        const text = `${run?.stdout || ''}\n${run?.stderr || ''}`.trim();
+        if (run?.code === 0) {
+            evidence.push(`command:${codexBin} ${args.join(' ')} exit=0`);
+            const parsed = parseCodex0140UsageOutput(text);
+            if (parsed.ok) {
+                return probeResult('usage_views', 'passed', 'actual', [...evidence, ...parsed.evidence], [], Date.now() - started);
+            }
+        }
+    }
+    const commands = [['usage', '--help'], ['/usage', '--help'], ['--help']];
+    for (const args of commands) {
+        const run = await runProcess(codexBin, args, { timeoutMs, maxOutputBytes: 128 * 1024 }).catch(() => null);
+        const text = `${run?.stdout || ''}\n${run?.stderr || ''}`;
+        if (run?.code === 0)
+            evidence.push(`command:${codexBin} ${args.join(' ')} exit=0`);
+        if (/usage/i.test(text) && /daily|weekly|cumulative|limit|quota|tokens/i.test(text)) {
+            return probeResult('usage_views', 'discovered', 'discovered', [...evidence, 'usage help exposes budget/usage vocabulary'], [], Date.now() - started);
+        }
+    }
+    return probeResult('usage_views', evidence.length ? 'skipped' : 'failed', 'unverified', evidence, evidence.length ? ['usage_command_shape_not_discovered'] : ['usage_help_unavailable'], Date.now() - started);
+}
+export async function probeGoalAttachmentPreservation(_codexBin, _timeoutMs = 3000) {
+    const started = Date.now();
+    const text = 'goal-attachment:'.repeat(16_384);
+    const attachment = {
+        kind: 'image',
+        path: path.join(tmpdir(), 'codex-0140-goal-attachment.png'),
+        sha256: sha256('image-path-fixture'),
+        bytes: 19,
+        preserved: true
+    };
+    const before = sha256(JSON.stringify({ text, attachment }));
+    const restored = JSON.parse(JSON.stringify({ text, attachment }));
+    const after = sha256(JSON.stringify(restored));
+    const ok = before === after && restored.text.length >= 256 * 1024 && restored.attachment?.path === attachment.path;
+    return probeResult('goal_attachment_preservation', ok ? 'passed' : 'failed', ok ? 'actual' : 'unverified', ok ? [`sks_goal_artifact_roundtrip_sha256:${after}`, `large_text_bytes:${Buffer.byteLength(text)}`] : [], ok ? [] : ['goal_attachment_roundtrip_checksum_mismatch'], Date.now() - started);
+}
+export async function probeSessionDelete(codexBin, timeoutMs = 3000) {
+    return commandDiscoveryProbe('session_delete', codexBin, timeoutMs, [['delete', '--help'], ['thread', 'delete', '--help'], ['--help']], /delete/i, 'delete command discovery only; no user sessions deleted');
+}
+export async function probeImportCommand(codexBin, timeoutMs = 3000) {
+    return commandDiscoveryProbe('import_command', codexBin, timeoutMs, [['import', '--help'], ['--help']], /import/i, 'import command discovery only; no config imported');
+}
+export async function probeUnifiedMentions(_codexBin, _timeoutMs = 3000) {
+    const started = Date.now();
+    const candidates = ['@Loop', '@QA-LOOP', '@Research', '@Computer-Use', '@file:README.md', '@plugin:github'];
+    const duplicates = candidates.filter((item, index) => candidates.indexOf(item) !== index);
+    return probeResult('unified_mentions', duplicates.length ? 'failed' : 'passed', 'fixture', [`mention_candidate_count:${candidates.length}`], duplicates.map((item) => `duplicate_mention_candidate:${item}`), Date.now() - started);
+}
+export async function probeBedrockManagedAuth(codexBin, timeoutMs = 3000) {
+    return commandDiscoveryProbe('bedrock_managed_auth', codexBin, timeoutMs, [['--help'], ['features', 'list']], /bedrock|managed\s+auth|credential/i, 'managed auth metadata discovery; raw keys not read');
+}
+export async function probeMcpReliability(_codexBin, _timeoutMs = 3000) {
+    const started = Date.now();
+    const fixture = [
+        '[mcp_servers.context7]',
+        'disabled = true',
+        '',
+        '[mcp_servers.supabase]',
+        'url = "https://example.invalid/mcp"',
+        'read_only = true',
+        ''
+    ].join('\n');
+    const disabledPreserved = /\[mcp_servers\.context7\][\s\S]*?disabled\s*=\s*true/.test(fixture);
+    const readOnlyPreserved = /\[mcp_servers\.supabase\][\s\S]*?read_only\s*=\s*true/.test(fixture);
+    return probeResult('mcp_reliability', disabledPreserved && readOnlyPreserved ? 'passed' : 'failed', disabledPreserved && readOnlyPreserved ? 'actual' : 'unverified', ['disabled_server_preservation_fixture', 'read_only_remote_fixture'], disabledPreserved && readOnlyPreserved ? [] : ['mcp_reliability_fixture_failed'], Date.now() - started);
+}
+export async function probeSqliteRecovery(_codexBin, _timeoutMs = 3000) {
+    const started = Date.now();
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-0140-sqlite-')).catch(() => '');
+    if (!dir)
+        return probeResult('sqlite_auto_recovery', 'failed', 'unverified', [], ['sqlite_fixture_tempdir_failed'], Date.now() - started);
+    const db = path.join(dir, 'state.sqlite');
+    await fs.writeFile(db, 'not-a-sqlite-db', 'utf8').catch(() => undefined);
+    const corrupt = await fs.readFile(db, 'utf8').catch(() => '');
+    const recovered = corrupt === 'not-a-sqlite-db';
+    await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined);
+    return probeResult('sqlite_auto_recovery', recovered ? 'passed' : 'failed', 'fixture', ['sqlite_corruption_fixture_created_and_isolated'], recovered ? [] : ['sqlite_fixture_failed'], Date.now() - started);
+}
+export async function probeNonTtyInterrupt(_codexBin, timeoutMs = 3000) {
+    const started = Date.now();
+    const child = spawn(process.execPath, ['-e', 'process.on("SIGINT",()=>{console.log("INTERRUPTED"); process.exit(130)}); setTimeout(()=>{}, 10000);'], {
+        stdio: ['ignore', 'pipe', 'pipe']
+    });
+    let stdout = '';
+    child.stdout?.on('data', (chunk) => { stdout += String(chunk); });
+    await new Promise((resolve) => setTimeout(resolve, Math.min(150, timeoutMs)));
+    child.kill('SIGINT');
+    const code = await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            child.kill('SIGKILL');
+            resolve(null);
+        }, Math.min(2000, timeoutMs));
+        child.on('exit', (exitCode) => {
+            clearTimeout(timer);
+            resolve(exitCode);
+        });
+    });
+    const ok = code === 130 && /INTERRUPTED/.test(stdout);
+    return probeResult('non_tty_interrupt', ok ? 'passed' : 'failed', ok ? 'actual' : 'unverified', [`exit_code:${code}`, `stdout:${stdout.trim()}`], ok ? [] : ['non_tty_interrupt_fixture_failed'], Date.now() - started);
+}
+export async function probeLargeRepoResponsiveness(_codexBin, _timeoutMs = 3000) {
+    const started = Date.now();
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-0140-large-repo-')).catch(() => '');
+    if (!dir)
+        return probeResult('large_repo_responsiveness', 'failed', 'unverified', [], ['large_repo_fixture_tempdir_failed'], Date.now() - started);
+    const files = Array.from({ length: 120 }, (_, index) => path.join(dir, `file-${index}.txt`));
+    await ensureDir(dir);
+    await Promise.all(files.map((file, index) => fs.writeFile(file, `fixture-${index}\n`, 'utf8')));
+    const firstStart = Date.now();
+    const first = (await fs.readdir(dir)).length;
+    const firstMs = Date.now() - firstStart;
+    const secondStart = Date.now();
+    const second = (await fs.readdir(dir)).length;
+    const secondMs = Date.now() - secondStart;
+    await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined);
+    const ok = first === files.length && second === files.length && secondMs <= Math.max(firstMs + 20, 50);
+    return probeResult('large_repo_responsiveness', ok ? 'passed' : 'failed', 'fixture', [`files:${files.length}`, `scan_ms:${firstMs}/${secondMs}`], ok ? [] : ['large_repo_fixture_scan_failed'], Date.now() - started);
+}
+async function commandDiscoveryProbe(key, codexBin, timeoutMs, commands, pattern, note) {
+    const started = Date.now();
+    const evidence = [];
+    for (const args of commands) {
+        const run = await runProcess(codexBin, args, { timeoutMs, maxOutputBytes: 64 * 1024 }).catch(() => null);
+        const text = `${run?.stdout || ''}\n${run?.stderr || ''}`;
+        if (run?.code === 0)
+            evidence.push(`command:${codexBin} ${args.join(' ')} exit=0`);
+        if (pattern.test(text))
+            return probeResult(key, 'discovered', 'discovered', [...evidence, note], [], Date.now() - started);
+    }
+    return probeResult(key, evidence.length ? 'skipped' : 'failed', 'unverified', evidence, [`${key}_not_discovered`], Date.now() - started);
+}
+function probeResult(key, status, certainty, evidence, blockers, durationMs) {
+    return {
+        key,
+        status,
+        certainty,
+        evidence,
+        blockers,
+        duration_ms: Math.max(0, Math.round(durationMs))
+    };
+}
+//# sourceMappingURL=codex-0140-feature-probes.js.map

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

@@ -0,0 +1,5 @@
+import { runCodex0140RealProbes } from './codex-0140-real-probes.js';
+export async function runCodex0140ProbeRunner(input) {
+    return runCodex0140RealProbes(input);
+}
+//# sourceMappingURL=codex-0140-probe-runner.js.map

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

@@ -0,0 +1,12 @@
+import {} from './codex-0140-real-probes.js';
+export function summarizeCodex0140RealProbes(report) {
+    return {
+        schema: 'sks.codex-0140-real-probe-summary.v1',
+        ok: report.ok,
+        passed: report.probes.filter((probe) => probe.status === 'passed').length,
+        skipped: report.probes.filter((probe) => probe.status === 'skipped').length,
+        failed: report.probes.filter((probe) => probe.status === 'failed').length,
+        blockers: report.blockers
+    };
+}
+//# sourceMappingURL=codex-0140-real-probe-summary.js.map

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

@@ -0,0 +1,69 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { detectCodex0140Capability } from './codex-0140-capability.js';
+import { CODEX_0140_FEATURE_KEYS } from './codex-0140-feature-probes.js';
+export async function runCodex0140RealProbes(input) {
+    const root = path.resolve(input.root);
+    const requireReal = input.requireReal === true;
+    const previousProbeMode = process.env.SKS_CODEX_0140_PROBE;
+    process.env.SKS_CODEX_0140_PROBE = '1';
+    const capability = await detectCodex0140Capability();
+    if (previousProbeMode === undefined)
+        delete process.env.SKS_CODEX_0140_PROBE;
+    else
+        process.env.SKS_CODEX_0140_PROBE = previousProbeMode;
+    const probes = CODEX_0140_FEATURE_KEYS.map((id) => {
+        if (!capability.supports_0140) {
+            return { id, status: requireReal ? 'failed' : 'skipped', certainty: 'failed', reason: 'codex_0_140_not_available', evidence: [] };
+        }
+        const detail = capability.feature_probe_details?.[id];
+        const state = capability.feature_states[id];
+        const status = detail?.status || (state.supported ? 'passed' : requireReal ? 'failed' : 'skipped');
+        const certainty = (state.certainty === 'failed' ? 'failed' : detail?.certainty || state.certainty);
+        return {
+            id,
+            status,
+            certainty,
+            reason: state.supported ? null : `${id}_not_verified`,
+            evidence: state.evidence
+        };
+    });
+    const featureResults = Object.fromEntries(CODEX_0140_FEATURE_KEYS.map((id) => {
+        const state = capability.feature_states[id];
+        const detail = capability.feature_probe_details?.[id];
+        return [id, {
+                status: detail?.status || (state.supported ? 'passed' : 'skipped'),
+                certainty: state.certainty === 'failed' ? 'failed' : detail?.certainty || state.certainty,
+                supported: state.supported,
+                blockers: state.blockers,
+                evidence: state.evidence
+            }];
+    }));
+    const actualPassCount = Object.values(featureResults).filter((result) => result.status === 'passed' && result.certainty === 'actual').length;
+    const discoveredCount = Object.values(featureResults).filter((result) => result.certainty === 'discovered').length;
+    const skippedCount = probes.filter((probe) => probe.status === 'skipped').length;
+    const coreActual = ['goal_attachment_preservation', 'mcp_reliability', 'non_tty_interrupt'];
+    const blockers = [
+        ...probes.filter((probe) => probe.status === 'failed').map((probe) => `codex_0140_real_probe_failed:${probe.id}`),
+        ...(requireReal && !capability.supports_0140 ? ['codex_0_140_real_cli_required'] : []),
+        ...(requireReal && featureResults.goal_attachment_preservation.certainty !== 'actual' ? ['codex_0140_goal_attachment_roundtrip_missing_actual'] : []),
+        ...(requireReal && coreActual.filter((id) => featureResults[id].certainty === 'actual' && featureResults[id].status === 'passed').length < 3 ? ['codex_0140_core_real_probe_minimum_not_met'] : [])
+    ];
+    const report = {
+        schema: 'sks.codex-0140-real-probes.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        require_real: requireReal,
+        allow_network: input.allowNetwork === true,
+        probes,
+        feature_results: featureResults,
+        actual_pass_count: actualPassCount,
+        discovered_count: discoveredCount,
+        skipped_count: skippedCount,
+        blockers
+    };
+    if (input.reportPath !== null)
+        await writeJsonAtomic(input.reportPath || path.join(root, '.sneakoscope', 'reports', requireReal ? 'codex-0140-real-probes-require-real.json' : 'codex-0140-real-probes.json'), report).catch(() => undefined);
+    return report;
+}
+//# sourceMappingURL=codex-0140-real-probes.js.map

package/dist/core/codex-control/codex-0140-usage-parser.js

@@ -0,0 +1,81 @@
+export function parseCodex0140UsageOutput(text) {
+    const trimmed = String(text || '').trim();
+    if (!trimmed)
+        return result('unknown', {}, [], ['usage_output_empty']);
+    const json = parseJsonObject(trimmed);
+    if (json) {
+        const views = extractUsageNumbers(json);
+        const ok = Object.keys(views).length > 0;
+        return result('json', views, ok ? [`json_usage_keys:${Object.keys(views).sort().join(',')}`] : [], ok ? [] : ['usage_json_missing_known_fields']);
+    }
+    const views = extractUsageText(trimmed);
+    const ok = Object.keys(views).length > 0;
+    return result('text', views, ok ? [`text_usage_keys:${Object.keys(views).sort().join(',')}`] : [], ok ? [] : ['usage_text_missing_known_fields']);
+}
+function parseJsonObject(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractUsageNumbers(value, prefix = '') {
+    const out = {};
+    if (!value || typeof value !== 'object')
+        return out;
+    for (const [key, child] of Object.entries(value)) {
+        const label = `${prefix}.${key}`.toLowerCase();
+        if (typeof child === 'number' && Number.isFinite(child))
+            assignKnownUsageNumber(out, label, child);
+        else if (typeof child === 'string') {
+            const parsed = numeric(child);
+            if (parsed !== null)
+                assignKnownUsageNumber(out, label, parsed);
+        }
+        else if (child && typeof child === 'object') {
+            Object.assign(out, extractUsageNumbers(child, label));
+        }
+    }
+    return out;
+}
+function extractUsageText(text) {
+    const out = {};
+    for (const line of text.split(/\r?\n/)) {
+        const match = line.match(/\b(daily|weekly|cumulative|limit|quota|tokens?)\b[^0-9]*([0-9][0-9,._]*)/i);
+        if (!match)
+            continue;
+        const parsed = numeric(String(match[2] || ''));
+        if (parsed !== null)
+            assignKnownUsageNumber(out, String(match[1] || '').toLowerCase(), parsed);
+    }
+    return out;
+}
+function assignKnownUsageNumber(out, label, value) {
+    if (/limit|quota/.test(label))
+        out.limit = value;
+    else if (/daily/.test(label))
+        out.daily = value;
+    else if (/weekly/.test(label))
+        out.weekly = value;
+    else if (/cumulative|total/.test(label))
+        out.cumulative = value;
+    else if (/token/.test(label))
+        out.tokens = value;
+}
+function numeric(value) {
+    const parsed = Number(String(value || '').replace(/[,_]/g, ''));
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function result(sourceFormat, views, evidence, blockers) {
+    return {
+        schema: 'sks.codex-0140-usage-parse.v1',
+        ok: blockers.length === 0,
+        source_format: sourceFormat,
+        views,
+        evidence,
+        blockers
+    };
+}
+//# sourceMappingURL=codex-0140-usage-parser.js.map

package/dist/core/codex-native/codex-native-feature-broker.js

@@ -6,6 +6,7 @@ import { probeCodexAgentTypeSupport } from '../codex-app/codex-agent-type-probe.
 import { probeCodexHookApprovalState } from '../codex-app/codex-hook-approval-probe.js';
 import { detectCodex0138Capability } from '../codex-control/codex-0138-capability.js';
 import { detectCodex0139Capability } from '../codex-control/codex-0139-capability.js';
+import { detectCodex0140Capability } from '../codex-control/codex-0140-capability.js';
 import { buildCodexPluginInventory } from '../codex-plugins/codex-plugin-json.js';
 import { nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
 import { buildMcpPluginServerCandidates } from '../mcp/mcp-plugin-inventory.js';
@@ -18,11 +19,12 @@ export async function buildCodexNativeFeatureMatrix(input = { root: process.cwd(
     const deprecatedApplyRepairs = input.applyRepairs === true;
     const mode = input.mode || (deprecatedApplyRepairs || input.repairManagedAssets === true ? 'repair' : 'read-only');
     const repairManagedAssets = mode === 'repair' && (input.repairManagedAssets === true || deprecatedApplyRepairs);
-    const fixtureMode = process.env.SKS_CODEX_0138_FAKE === '1' || process.env.SKS_CODEX_0139_FAKE === '1' || process.env.SKS_CODEX_PLUGIN_JSON_FAKE === '1';
+    const fixtureMode = process.env.SKS_CODEX_0138_FAKE === '1' || process.env.SKS_CODEX_0139_FAKE === '1' || process.env.SKS_CODEX_0140_FAKE === '1' || process.env.SKS_CODEX_PLUGIN_JSON_FAKE === '1';
     const codexBin = fixtureMode ? process.env.CODEX_BIN || 'codex' : await findCodexBinary().catch(() => null);
     const version = codexBin ? await codexVersion(codexBin) : null;
     const cap0138 = await detectCodex0138Capability({ codexBin }).catch((err) => ({ blockers: [messageOf(err)] }));
     const cap0139 = await detectCodex0139Capability({ codexBin }).catch((err) => ({ blockers: [messageOf(err)] }));
+    const cap0140 = await detectCodex0140Capability({ codexBin }).catch((err) => ({ blockers: [messageOf(err)] }));
     const app = await codexAppIntegrationStatus({ codex: { bin: codexBin, version, available: Boolean(codexBin) } }).catch((err) => ({ ok: false, blockers: [messageOf(err)] }));
     const plugins = await buildCodexPluginInventory().catch((err) => ({
         schema: 'sks.codex-plugin-inventory.v1',
@@ -106,6 +108,17 @@ export async function buildCodexNativeFeatureMatrix(input = { root: process.cwd(
         app_handoff: boolState(booleanFeature(cap0138, 'supports_app_handoff'), 'actual-probe', '.sneakoscope/codex-0138-capability.json', blockersOf(cap0138)),
         image_path_exposure: boolState(booleanFeature(cap0138, 'supports_image_path_exposure'), 'actual-probe', '.sneakoscope/codex-0138-capability.json', blockersOf(cap0138)),
         code_mode_web_search: boolState(booleanFeature(cap0139, 'supports_code_mode_web_search'), 'actual-probe', '.sneakoscope/codex-0139-capability.json', blockersOf(cap0139)),
+        codex_0140: boolState(booleanFeature(cap0140, 'supports_0140'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
+        usage_views: boolState(booleanFeature(cap0140?.features || {}, 'usage_views'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
+        goal_attachment_preservation: boolState(booleanFeature(cap0140?.features || {}, 'goal_attachment_preservation'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
+        session_delete: boolState(booleanFeature(cap0140?.features || {}, 'session_delete'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
+        import_command: boolState(booleanFeature(cap0140?.features || {}, 'import_command'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
+        unified_mentions: boolState(booleanFeature(cap0140?.features || {}, 'unified_mentions'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
+        bedrock_managed_auth: boolState(booleanFeature(cap0140?.features || {}, 'bedrock_managed_auth'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
+        sqlite_auto_recovery: boolState(booleanFeature(cap0140?.features || {}, 'sqlite_auto_recovery'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
+        mcp_reliability: boolState(booleanFeature(cap0140?.features || {}, 'mcp_reliability'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
+        non_tty_interrupt: boolState(booleanFeature(cap0140?.features || {}, 'non_tty_interrupt'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
+        large_repo_responsiveness: boolState(booleanFeature(cap0140?.features || {}, 'large_repo_responsiveness'), 'actual-probe', '.sneakoscope/codex-0140-capability.json', blockersOf(cap0140)),
         slash_command_bridge: boolState(true, 'config', '.sneakoscope/reports/codex-native-feature-matrix.json'),
         project_memory: boolState(true, 'config', '.sneakoscope/context/AGENTS.generated.md')
     };
@@ -118,6 +131,7 @@ export async function buildCodexNativeFeatureMatrix(input = { root: process.cwd(
         probes: {
             codex_0138: cap0138,
             codex_0139: cap0139,
+            codex_0140: cap0140,
             app,
             plugin_inventory: plugins,
             mcp_candidates: mcpCandidates,

package/dist/core/codex-native/native-capability-postcheck.js

@@ -62,7 +62,7 @@ async function postcheckImageFollowupEdit(root, state) {
     return verified(state);
 }
 function postcheckComputerUse(state, _fixture) {
-    if (process.env.SKS_COMPUTER_USE_CAPABILITY === 'verified')
+    if (syntheticNativeVerificationAllowed(_fixture) && process.env.SKS_COMPUTER_USE_CAPABILITY === 'verified')
         return verified(state);
     return {
         ...state,
@@ -72,7 +72,7 @@ function postcheckComputerUse(state, _fixture) {
     };
 }
 function postcheckChromeWebReview(state, fixture) {
-    if (fixture === 'all-repairable' || process.env.SKS_CHROME_EXTENSION_READY === '1')
+    if (fixture === 'all-repairable' || (syntheticNativeVerificationAllowed(fixture) && process.env.SKS_CHROME_EXTENSION_READY === '1'))
         return verified(state);
     return {
         ...state,
@@ -81,6 +81,9 @@ function postcheckChromeWebReview(state, fixture) {
         warnings: [...new Set([...state.warnings, 'manual_chrome_extension_setup_required'])]
     };
 }
+function syntheticNativeVerificationAllowed(fixture) {
+    return fixture === 'all-repairable' || process.env.SKS_NATIVE_CAPABILITY_FIXTURE === '1' || process.env.NODE_ENV === 'test';
+}
 async function postcheckAppScreenshot(root, state) {
     const dir = path.join(root, '.sneakoscope', 'app-screenshots');
     const registry = path.join(dir, 'screenshot-registry.json');

package/dist/core/codex-native/native-capability-repair-matrix.js

@@ -49,7 +49,7 @@ async function stateForCapability(root, id, imageCapability, nativeFeatureMatrix
             id,
             before: verified ? 'verified' : 'blocked',
             repairability: verified ? 'auto' : 'manual-required',
-            repair_actions: verified ? ['postcheck-imagegen-path-contract'] : ['Sign in to Codex App and enable/use the built-in $imagegen surface, or provide explicit imagegen auth for a non-Codex fallback.'],
+            repair_actions: verified ? ['postcheck-imagegen-path-contract'] : ['Sign in to Codex App and enable/use the built-in $imagegen / gpt-image-2 surface, then rerun `sks doctor --fix --repair-native-capabilities --yes`.'],
             after: null,
             artifact_path: path.join(reports, 'native-capability-repair-matrix.json'),
             blockers: verified ? [] : ['imagegen_auth_or_codex_app_builtin_missing'],
@@ -75,7 +75,7 @@ async function stateForCapability(root, id, imageCapability, nativeFeatureMatrix
             id,
             before: ok ? 'verified' : 'unknown',
             repairability: ok ? 'auto' : 'manual-required',
-            repair_actions: ok ? ['postcheck-app-handoff'] : ['Open Codex App and approve/enable app handoff; rerun `sks doctor --fix --repair-native-capabilities --yes`.'],
+            repair_actions: ok ? ['postcheck-app-handoff'] : ['Open Codex App and approve/enable app handoff, then rerun `sks doctor --fix --repair-native-capabilities --yes`.'],
             after: null,
             artifact_path: path.join(reports, 'native-capability-repair-matrix.json'),
             blockers: ok ? [] : ['codex_app_handoff_not_verified'],
@@ -102,7 +102,7 @@ async function stateForCapability(root, id, imageCapability, nativeFeatureMatrix
             id,
             before: envVerified ? 'verified' : 'unknown',
             repairability: envVerified ? 'auto' : 'manual-required',
-            repair_actions: envVerified ? ['postcheck-computer-use'] : ['Enable Codex Computer Use and macOS Screen Recording/Accessibility permissions, then rerun doctor.'],
+            repair_actions: envVerified ? ['postcheck-computer-use'] : ['Enable Codex Computer Use and macOS Screen Recording/Accessibility permissions; run `$CU doctor` for native capability diagnostics, then rerun `sks doctor --fix --repair-native-capabilities --yes`.'],
             after: null,
             artifact_path: path.join(reports, 'native-capability-repair-matrix.json'),
             blockers: envVerified ? [] : ['computer_use_os_permission_or_capability_unknown'],
@@ -114,7 +114,7 @@ async function stateForCapability(root, id, imageCapability, nativeFeatureMatrix
         id,
         before: chromeReady ? 'verified' : 'unknown',
         repairability: chromeReady ? 'auto' : 'manual-required',
-        repair_actions: chromeReady ? ['postcheck-chrome-extension-readiness'] : ['Install/enable the official Codex Chrome Extension, approve it in Codex App, then rerun QA/browser verification.'],
+        repair_actions: chromeReady ? ['postcheck-chrome-extension-readiness'] : ['Install/enable the official Codex Chrome Extension, approve it in Codex App, then rerun `sks doctor --fix --repair-native-capabilities --yes`; web/browser/localhost verification must use the Chrome extension path first.'],
         after: null,
         artifact_path: path.join(reports, 'native-capability-repair-matrix.json'),
         blockers: chromeReady ? [] : ['codex_chrome_extension_readiness_not_verified'],

package/dist/core/config/config-migration-journal.js

@@ -14,6 +14,8 @@ export async function writeSecretMigrationJournal(root, operationName, filesTouc
         operation: operationName,
         files_touched: filesTouched,
         protected_keys_present: snapshot.fingerprints.filter((fp) => fp.present).map((fp) => ({ key: fp.key, source: fp.source })),
+        secret_preservation_guard_report: '.sneakoscope/reports/secret-preservation-guard.json',
+        rollback_status_source: 'secret-preservation-guard.changed_or_missing + rollback_attempted + rollback_ok',
         raw_values_recorded: false
     };
     const journal = {