sneakoscope 2.0.16 → 2.0.18

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

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { appendJsonlBounded, ensureDir, nowIso, readText, writeJsonAtomic } from '../fsx.js';
+import { appendJsonlBounded, ensureDir, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
 export const PARALLEL_RUNTIME_EVENT_SCHEMA = 'sks.parallel-runtime-event.v1';
 export const PARALLEL_RUNTIME_PROOF_SCHEMA = 'sks.parallel-runtime-proof.v1';
 export function parallelRuntimeEventPath(root, missionId) {
@@ -92,6 +92,9 @@ export async function buildParallelRuntimeProof(root, missionId, opts = {}) {
     }
     const requestedWorkers = positiveInt(opts.requestedWorkers, workerStarts.size || workerPids.size || maxWorkers);
     const targetActiveSlots = positiveInt(opts.targetActiveSlots, requestedWorkers);
+    const proofMode = opts.proofMode || 'production';
+    const allowMissingPids = proofMode === 'in-process-fixture' && opts.allowMissingPids === true;
+    const requireWorkerPids = opts.requireWorkerPids ?? (proofMode === 'production' && requestedWorkers >= 16);
     const wallMs = Math.max(0, lastMs - firstMs);
     const sequentialEstimateMs = workerDurations.length
         ? workerDurations.reduce((sum, value) => sum + value, 0)
@@ -107,17 +110,33 @@ export async function buildParallelRuntimeProof(root, missionId, opts = {}) {
     const launchEvents = sorted.filter((event) => event.event_type === 'worker_launch_invoked' || event.event_type === 'worker_process_spawned');
     const launchSpanMs = launchEvents.length ? Math.max(...launchEvents.map((event) => event.ms)) - Math.min(...launchEvents.map((event) => event.ms)) : 0;
     const firstBatchLimit = positiveInt(opts.firstBatchLaunchSpanLimitMs, requestedWorkers >= 16 ? 2500 : 30000);
-    const blockers = [
-        ...(sorted.length ? [] : ['parallel_runtime_events_missing']),
-        ...(minActiveWorkers <= 0 || maxWorkers >= minActiveWorkers ? [] : ['max_observed_active_workers_below_target']),
-        ...(requestedWorkers >= 16 && workerPids.size && workerPids.size < minActiveWorkers ? ['unique_worker_pids_below_target'] : []),
-        ...(speedupRatio >= minSpeedup ? [] : ['speedup_ratio_below_target']),
-        ...(firstBatchLaunchSpanMs <= firstBatchLimit ? [] : ['first_batch_launch_span_above_limit'])
-    ];
+    const schedulerState = await readJson(path.join(root, 'agent-scheduler-state.json'), null).catch(() => null);
+    const coalescedOverlapWindows = coalesceOverlapWindows(overlapWindows);
+    const utilizationProofConsistency = buildUtilizationProofConsistency(schedulerState, {
+        proofMaxActive: maxWorkers,
+        proofWallMs: wallMs,
+        proofActiveSlotTimeMs: activeSlotTimeMsFromWindows(coalescedOverlapWindows)
+    });
+    const blockers = [];
+    if (!sorted.length)
+        blockers.push('parallel_runtime_events_missing');
+    if (minActiveWorkers > 0 && maxWorkers < minActiveWorkers)
+        blockers.push('max_observed_active_workers_below_target');
+    if (requireWorkerPids && workerPids.size < minActiveWorkers)
+        blockers.push('unique_worker_pids_below_target');
+    if (requireWorkerPids && workerPids.size === 0)
+        blockers.push('unique_worker_pids_missing_in_production_proof');
+    if (speedupRatio < minSpeedup)
+        blockers.push('speedup_ratio_below_target');
+    if (firstBatchLaunchSpanMs > firstBatchLimit)
+        blockers.push('first_batch_launch_span_above_limit');
     return {
         schema: PARALLEL_RUNTIME_PROOF_SCHEMA,
         mission_id: missionId,
         generated_at: nowIso(),
+        proof_mode: proofMode,
+        require_worker_pids: requireWorkerPids,
+        allow_missing_pids: allowMissingPids,
         requested_workers: requestedWorkers,
         target_active_slots: targetActiveSlots,
         max_observed_active_workers: maxWorkers,
@@ -130,9 +149,10 @@ export async function buildParallelRuntimeProof(root, missionId, opts = {}) {
         wall_ms: wallMs,
         sequential_estimate_ms: sequentialEstimateMs,
         speedup_ratio: speedupRatio,
-        overlap_windows: coalesceOverlapWindows(overlapWindows),
+        overlap_windows: coalescedOverlapWindows,
         visible_panes: visiblePanes,
         headless_workers: headlessWorkers,
+        utilization_proof_consistency: utilizationProofConsistency,
         passed: blockers.length === 0,
         blockers
     };
@@ -196,6 +216,45 @@ function nonNegativeInt(value, fallback) {
         return Math.max(0, Math.floor(fallback || 0));
     return Math.floor(parsed);
 }
+function buildUtilizationProofConsistency(state, input) {
+    if (!state || typeof state !== 'object') {
+        return {
+            ok: true,
+            scheduler_max_active: 0,
+            proof_max_active: input.proofMaxActive,
+            wall_ms_delta: 0,
+            scheduler_active_slot_time_ms: 0,
+            proof_active_slot_time_ms: input.proofActiveSlotTimeMs,
+            active_slot_time_ms_delta: 0,
+            scheduler_observation_delay_tolerance_ms: 0
+        };
+    }
+    const schedulerMaxActive = nonNegativeInt(state.max_observed_active_slots, 0);
+    const schedulerWallMs = nonNegativeInt(state.wall_time_ms, 0);
+    const schedulerActiveSlotTimeMs = nonNegativeInt(state.active_slot_time_ms, 0);
+    const wallDelta = Math.abs(schedulerWallMs - input.proofWallMs);
+    const activeSlotDelta = Math.abs(schedulerActiveSlotTimeMs - input.proofActiveSlotTimeMs);
+    const maxActiveDelta = Math.abs(schedulerMaxActive - input.proofMaxActive);
+    const wallToleranceMs = Math.max(500, Math.round(Math.max(schedulerWallMs, input.proofWallMs) * 0.25));
+    const activeSlotToleranceMs = Math.max(500, Math.round(Math.max(schedulerActiveSlotTimeMs, input.proofActiveSlotTimeMs) * 0.25));
+    const observationDelayToleranceMs = Math.max(activeSlotToleranceMs, wallDelta * Math.max(1, schedulerMaxActive));
+    const wallConsistent = wallDelta <= wallToleranceMs;
+    const activeSlotConsistent = schedulerActiveSlotTimeMs > 0 && input.proofActiveSlotTimeMs > 0 && (activeSlotDelta <= activeSlotToleranceMs
+        || (schedulerActiveSlotTimeMs >= input.proofActiveSlotTimeMs && activeSlotDelta <= observationDelayToleranceMs));
+    return {
+        ok: maxActiveDelta <= 1 && (wallConsistent || activeSlotConsistent),
+        scheduler_max_active: schedulerMaxActive,
+        proof_max_active: input.proofMaxActive,
+        wall_ms_delta: wallDelta,
+        scheduler_active_slot_time_ms: schedulerActiveSlotTimeMs,
+        proof_active_slot_time_ms: input.proofActiveSlotTimeMs,
+        active_slot_time_ms_delta: activeSlotDelta,
+        scheduler_observation_delay_tolerance_ms: observationDelayToleranceMs
+    };
+}
+function activeSlotTimeMsFromWindows(windows) {
+    return windows.reduce((sum, window) => sum + Math.max(0, window.end_ms - window.start_ms) * Math.max(0, window.active_workers), 0);
+}
 function coalesceOverlapWindows(windows) {
     return windows
         .filter((window) => window.end_ms > window.start_ms)

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

@@ -0,0 +1,75 @@
+import path from 'node:path';
+import { findLatestMission, missionDir } from '../mission.js';
+import { readJson, writeJsonAtomic } from '../fsx.js';
+export const RUNTIME_PROOF_SUMMARY_SCHEMA = 'sks.runtime-proof-summary.v1';
+export async function buildRuntimeProofSummary(root, missionIdInput = 'latest') {
+    const missionId = missionIdInput === 'latest' ? await findLatestMission(root) : missionIdInput;
+    if (!missionId)
+        throw new Error('runtime_proof_summary_mission_missing');
+    const dir = missionDir(root, missionId);
+    const agentsDir = path.join(dir, 'agents');
+    const parallel = await readJson(path.join(agentsDir, 'parallel-runtime-proof.json'), null);
+    const scheduler = await readJson(path.join(agentsDir, 'agent-scheduler-state.json'), null);
+    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 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);
+    const headlessWorkers = Number(parallel?.headless_workers ?? swarm?.headless_overflow_worker_count ?? Math.max(0, targetActive - visiblePanes));
+    const blockers = [
+        ...(!parallel ? ['parallel_runtime_proof_missing'] : []),
+        ...(!scheduler ? ['agent_scheduler_state_missing'] : []),
+        ...(parallel?.passed === false ? parallel.blockers || ['parallel_runtime_proof_failed'] : []),
+        ...(telemetryAgeMs > 3000 ? ['zellij_telemetry_stale'] : [])
+    ].map(String);
+    const summary = {
+        schema: RUNTIME_PROOF_SUMMARY_SCHEMA,
+        ok: blockers.length === 0,
+        mission_id: missionId,
+        generated_at: new Date().toISOString(),
+        parallel: {
+            max_active_workers: Number(parallel?.max_observed_active_workers || scheduler?.max_observed_active_slots || 0),
+            unique_worker_pids: Number(parallel?.unique_worker_pids || uniqueNumbers(swarm?.process_ids).length || 0),
+            speedup_ratio: Number(parallel?.speedup_ratio || 0),
+            proof_passed: parallel?.passed === true
+        },
+        ui: {
+            visible_panes: visiblePanes,
+            headless_workers: headlessWorkers,
+            telemetry_age_ms: telemetryAgeMs,
+            stale: telemetryAgeMs > 3000
+        },
+        model_calls: {
+            max_observed: Number(parallel?.max_observed_model_calls || 0),
+            unique_model_call_ids: Number(parallel?.unique_model_call_ids || 0)
+        },
+        scheduler: {
+            largest_batch_size: Number(scheduler?.largest_batch_size || 0),
+            utilization: Number(scheduler?.scheduler_utilization || 0)
+        },
+        blockers
+    };
+    await writeJsonAtomic(path.join(agentsDir, 'runtime-proof-summary.json'), summary);
+    return summary;
+}
+export function renderRuntimeProofSummary(summary) {
+    return [
+        `Parallel proof: ${summary.parallel.proof_passed ? 'passed' : 'blocked'}`,
+        `Active workers: ${summary.parallel.max_active_workers}`,
+        `Unique PIDs: ${summary.parallel.unique_worker_pids}`,
+        `Speedup: ${summary.parallel.speedup_ratio}x`,
+        `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}`,
+        ...(summary.blockers.length ? [`Blockers: ${summary.blockers.join(', ')}`] : [])
+    ].join('\n');
+}
+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;
+}
+function uniqueNumbers(values) {
+    return [...new Set((Array.isArray(values) ? values : []).map((value) => Number(value)).filter((value) => Number.isFinite(value)))];
+}
+//# sourceMappingURL=runtime-proof-summary.js.map

package/dist/core/codex-app/codex-app-handoff.js

@@ -0,0 +1,77 @@
+import path from 'node:path';
+import { detectCodex0138Capability } from '../codex-control/codex-0138-capability.js';
+import { nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+export function buildCodexAppHandoffPrompt(request) {
+    return [
+        'SKS Codex Desktop /app handoff request',
+        `Mission: ${request.mission_id}`,
+        `Route: ${request.route}`,
+        `Reason: ${request.reason}`,
+        `Workspace: ${request.workspace_path}`,
+        request.thread_ref ? `Thread: ${request.thread_ref}` : '',
+        '',
+        'Artifacts:',
+        ...(request.artifacts || []).map((artifact) => `- ${artifact}`),
+        '',
+        'Prompt:',
+        request.prompt,
+        '',
+        'Operator instruction: open Codex Desktop with `codex /app` and continue this mission using the artifacts above. Do not treat this handoff artifact as web UI verification evidence.'
+    ].filter((line) => line !== '').join('\n');
+}
+export async function runCodexAppHandoff(root, request) {
+    const capability = await detectCodex0138Capability();
+    const platformSupported = process.platform === 'darwin' || process.platform === 'win32';
+    const desktopSupported = capability.supports_app_handoff === true && platformSupported;
+    const dir = path.join(root, '.sneakoscope', 'missions', request.mission_id, 'qa-loop');
+    const artifactPath = path.join(dir, 'app-handoff.json');
+    const promptArtifactPath = path.join(dir, 'app-handoff-prompt.md');
+    const blockers = [
+        ...(capability.supports_app_handoff ? [] : ['codex_0_138_app_handoff_unavailable']),
+        ...(platformSupported ? [] : ['codex_app_handoff_platform_unsupported'])
+    ];
+    const prompt = buildCodexAppHandoffPrompt(request);
+    await writeTextAtomic(promptArtifactPath, prompt);
+    const status = request.require_desktop && !desktopSupported
+        ? 'blocked_for_desktop_review'
+        : desktopSupported
+            ? 'pending'
+            : 'skipped';
+    const result = {
+        schema: 'sks.codex-app-handoff-result.v1',
+        ok: request.require_desktop ? desktopSupported : true,
+        attempted: false,
+        launched: false,
+        status,
+        codex_0138_capability: capability,
+        command_line: ['codex', '/app'],
+        desktop_handoff_supported: desktopSupported,
+        fallback_reason: desktopSupported
+            ? 'interactive_tui_handoff_pending_operator'
+            : blockers.join(';') || null,
+        artifact_path: artifactPath,
+        prompt_artifact_path: promptArtifactPath,
+        blockers: request.require_desktop ? blockers : []
+    };
+    await writeJsonAtomic(artifactPath, {
+        ...result,
+        request,
+        operator_instruction: {
+            open: 'codex /app',
+            prompt_artifact: path.relative(root, promptArtifactPath),
+            created_at: nowIso()
+        }
+    });
+    return result;
+}
+export function qaLoopShouldRequestAppHandoff(input = {}) {
+    const args = input.args || [];
+    return args.includes('--app-handoff')
+        || process.env.SKS_QA_LOOP_APP_HANDOFF === '1'
+        || input.visualArtifactsPresent === true
+        || input.zellijUiBlocked === true
+        || input.pluginAppTemplateUnavailable === true
+        || input.userRequestedDesktopReview === true
+        || input.uiRequired === true && process.env.SKS_QA_LOOP_APP_HANDOFF_FOR_VISUAL === '1';
+}
+//# sourceMappingURL=codex-app-handoff.js.map

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

@@ -0,0 +1,64 @@
+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 detectCodex0138Capability(input = {}) {
+    const fake = process.env.SKS_CODEX_0138_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.138.0')
+        : await readCodexVersionText(codexBin);
+    const parsed = parseCodexVersion(versionText);
+    const atLeast138 = Boolean(parsed && semverGte(parsed, '0.138.0'));
+    const blockers = [
+        ...(!codexBin ? ['codex_cli_missing'] : []),
+        ...(atLeast138 ? [] : ['codex_0_138_required_for_app_plugin_features'])
+    ];
+    return {
+        schema: 'sks.codex-0138-capability.v1',
+        ok: atLeast138,
+        codex_bin: codexBin || null,
+        version_text: versionText || null,
+        parsed_version: parsed,
+        supports_app_handoff: atLeast138,
+        supports_plugin_json: atLeast138,
+        supports_image_path_exposure: atLeast138,
+        supports_model_defined_efforts: atLeast138,
+        supports_app_server_token_usage: atLeast138,
+        supports_v2_pat_auth: atLeast138,
+        supports_oauth_mcp_prerefresh: atLeast138,
+        blockers
+    };
+}
+export async function writeCodex0138CapabilityArtifacts(root, input = {}) {
+    const capability = await detectCodex0138Capability({ codexBin: input.codexBin || null });
+    const report = { ...capability, generated_at: nowIso() };
+    const rootArtifact = path.join(root, '.sneakoscope', 'codex-0138-capability.json');
+    await writeJsonAtomic(rootArtifact, report);
+    let missionArtifact = null;
+    if (input.missionId) {
+        missionArtifact = path.join(root, '.sneakoscope', 'missions', input.missionId, 'codex-0138-capability.json');
+        await writeJsonAtomic(missionArtifact, report);
+    }
+    return { report, root_artifact: rootArtifact, mission_artifact: missionArtifact };
+}
+export function parseCodexVersion(text) {
+    return parseCodexVersionText(text);
+}
+export function semverGte(actual, minimum) {
+    return compareSemverLike(actual, minimum) >= 0;
+}
+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-0138-capability.js.map

package/dist/core/codex-control/codex-model-capabilities.js

@@ -0,0 +1,41 @@
+export const SKS_FALLBACK_EFFORT_ORDER = ['minimal', 'low', 'medium', 'high', 'xhigh'];
+export function codexModelEffortCapability(input = {}) {
+    const advertised = normalizeAdvertisedEfforts(input.advertisedEfforts);
+    const order = advertised.length ? advertised : SKS_FALLBACK_EFFORT_ORDER;
+    const defaultEffort = order.includes(String(input.defaultEffort || '')) ? String(input.defaultEffort) : order.includes('medium') ? 'medium' : order[0] || 'medium';
+    return {
+        model: String(input.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || 'gpt-5.5'),
+        advertised_efforts: order,
+        default_effort: defaultEffort,
+        order_source: advertised.length ? 'model-advertised' : 'sks-fallback'
+    };
+}
+export function normalizeAdvertisedEfforts(value) {
+    const rows = Array.isArray(value) ? value : String(value || '').split(',');
+    const seen = new Set();
+    const out = [];
+    for (const row of rows) {
+        const effort = String(row || '').trim().toLowerCase();
+        if (!effort || seen.has(effort))
+            continue;
+        seen.add(effort);
+        out.push(effort);
+    }
+    return out;
+}
+export function nextAdvertisedEffort(current, capability = codexModelEffortCapability()) {
+    const order = capability.advertised_efforts.length ? capability.advertised_efforts : SKS_FALLBACK_EFFORT_ORDER;
+    const index = Math.max(0, order.indexOf(current));
+    return order[Math.min(order.length - 1, index + 1)] || current || capability.default_effort;
+}
+export function modelEffortAtLeast(target, capability = codexModelEffortCapability()) {
+    const order = capability.advertised_efforts.length ? capability.advertised_efforts : SKS_FALLBACK_EFFORT_ORDER;
+    if (order.includes(target))
+        return target;
+    if (target === 'recovery')
+        return order.includes('high') ? 'high' : order[order.length - 1];
+    if (target === 'forensic_vision')
+        return order.includes('xhigh') ? 'xhigh' : order[order.length - 1];
+    return capability.default_effort;
+}
+//# sourceMappingURL=codex-model-capabilities.js.map

package/dist/core/codex-control/codex-sdk-config-policy.js

@@ -2,7 +2,7 @@ export function buildCodexSdkConfig(input) {
     const config = {
         model: String(process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || 'gpt-5.5'),
         service_tier: 'fast',
-        model_reasoning_effort: 'medium',
+        model_reasoning_effort: String(input.modelReasoningEffort || input.reasoningEffort || process.env.SKS_CODEX_REASONING || process.env.CODEX_MODEL_REASONING_EFFORT || 'medium'),
         mcp_servers: {},
         sks: {
             route: input.route,

package/dist/core/codex-control/codex-task-runner.js

@@ -445,7 +445,7 @@ async function ensurePythonCodexLbConfig(env, config) {
         `model = ${tomlQuote(model)}`,
         'model_provider = "codex-lb"',
         'service_tier = "fast"',
-        'model_reasoning_effort = "minimal"',
+        `model_reasoning_effort = ${tomlQuote(String(config.model_reasoning_effort || env.SKS_CODEX_REASONING || env.CODEX_MODEL_REASONING_EFFORT || 'minimal'))}`,
         'approval_policy = "never"',
         '',
         '[model_providers.codex-lb]',

package/dist/core/codex-plugins/codex-plugin-json.js

@@ -0,0 +1,152 @@
+import path from 'node:path';
+import { findCodexBinary } from '../codex-adapter.js';
+import { detectCodex0138Capability } from '../codex-control/codex-0138-capability.js';
+import { nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
+export async function runCodexPluginListJson() {
+    if (process.env.SKS_CODEX_PLUGIN_JSON_FAKE === '1')
+        return fakePluginList();
+    const bin = await findCodexBinary();
+    if (!bin)
+        return { plugins: [], blockers: ['codex_cli_missing'] };
+    return runCodexJson(bin, ['plugin', 'list', '--json']);
+}
+export async function runCodexPluginDetailJson(pluginId) {
+    if (process.env.SKS_CODEX_PLUGIN_JSON_FAKE === '1')
+        return fakePluginDetail(pluginId);
+    const bin = await findCodexBinary();
+    if (!bin)
+        return { blockers: ['codex_cli_missing'] };
+    return runCodexJson(bin, ['plugin', 'detail', pluginId, '--json']);
+}
+export async function buildCodexPluginInventory() {
+    const capability = await detectCodex0138Capability();
+    const listJson = await runCodexPluginListJson();
+    const summaries = normalizePluginList(listJson);
+    const plugins = [];
+    for (const summary of summaries) {
+        const detail = await runCodexPluginDetailJson(summary.id || summary.name).catch((err) => ({ error: err?.message || String(err) }));
+        plugins.push(normalizePlugin(summary, detail));
+    }
+    const blockers = [
+        ...(capability.supports_plugin_json ? [] : ['codex_0_138_plugin_json_unavailable']),
+        ...normalizeList(listJson?.blockers)
+    ];
+    return {
+        schema: 'sks.codex-plugin-inventory.v1',
+        generated_at: nowIso(),
+        codex_0138_capability: capability,
+        plugins,
+        marketplace_available: plugins.some((plugin) => plugin.source === 'marketplace' || plugin.source === 'remote') || Boolean(listJson?.marketplace_available || listJson?.marketplaceAvailable),
+        blockers
+    };
+}
+export async function writeCodexPluginInventoryArtifacts(root, inventory = null) {
+    const report = inventory || await buildCodexPluginInventory();
+    const artifact = path.join(root, '.sneakoscope', 'codex-plugin-inventory.json');
+    await writeJsonAtomic(artifact, report);
+    return { report, artifact };
+}
+export function pluginAppTemplatePolicy(inventory) {
+    const unavailable = inventory.plugins.flatMap((plugin) => plugin.unavailable_app_templates.map((template) => ({
+        plugin: plugin.id,
+        template
+    })));
+    return {
+        schema: 'sks.codex-plugin-app-template-policy.v1',
+        ok: true,
+        unavailable_app_templates: unavailable,
+        qa_loop_app_handoff_recommended: unavailable.length > 0,
+        doctor_warnings: unavailable.map((row) => `plugin_app_template_unavailable:${row.plugin}`)
+    };
+}
+async function runCodexJson(bin, args) {
+    const result = await runProcess(bin, args, { timeoutMs: 20_000, maxOutputBytes: 256 * 1024 }).catch((err) => ({
+        code: 1,
+        stdout: '',
+        stderr: err?.message || String(err)
+    }));
+    const text = `${result.stdout || ''}${result.stderr || ''}`.trim();
+    try {
+        return text ? JSON.parse(text) : {};
+    }
+    catch {
+        return { raw_text: text, blockers: [`codex_plugin_json_parse_failed:${args.join(' ')}`] };
+    }
+}
+function normalizePluginList(value) {
+    if (Array.isArray(value))
+        return value;
+    for (const key of ['plugins', 'installed_plugins', 'installedPlugins', 'items']) {
+        if (Array.isArray(value?.[key]))
+            return value[key];
+    }
+    return [];
+}
+function normalizePlugin(summary, detail) {
+    const raw = { summary, detail };
+    const id = String(detail?.id || summary?.id || summary?.plugin_id || summary?.name || 'unknown');
+    const name = String(detail?.name || summary?.name || id);
+    const sourceText = String(detail?.source || detail?.marketplaceSource || summary?.source || summary?.marketplaceSource || '').toLowerCase();
+    const source = sourceText.includes('marketplace') ? 'marketplace'
+        : sourceText.includes('remote') ? 'remote'
+            : sourceText.includes('local') ? 'local'
+                : 'unknown';
+    return {
+        id,
+        name,
+        source,
+        installed: boolish(detail?.installed ?? summary?.installed, true),
+        enabled: boolish(detail?.enabled ?? summary?.enabled, true),
+        default_prompts: normalizeList(detail?.default_prompts || detail?.defaultPrompts || detail?.prompts),
+        remote_mcp_servers: normalizeMcpServers(detail?.remote_mcp_servers || detail?.remoteMcpServers || detail?.mcp_servers || detail?.mcpServers),
+        unavailable_app_templates: normalizeList(detail?.unavailable_app_templates || detail?.unavailableAppTemplates || detail?.app_templates_unavailable),
+        raw
+    };
+}
+function normalizeMcpServers(value) {
+    const rows = Array.isArray(value) ? value : value && typeof value === 'object' ? Object.entries(value).map(([name, row]) => ({ name, ...(row || {}) })) : [];
+    return rows.map((row, index) => ({
+        name: String(row?.name || row?.id || `remote-mcp-${index + 1}`),
+        url: stringOrNull(row?.url || row?.endpoint),
+        auth_type: stringOrNull(row?.auth_type || row?.authType || row?.auth)
+    }));
+}
+function normalizeList(value) {
+    return Array.isArray(value) ? value.filter(Boolean).map(String) : value ? [String(value)] : [];
+}
+function stringOrNull(value) {
+    const text = String(value || '').trim();
+    return text ? text : null;
+}
+function boolish(value, fallback = false) {
+    if (value === true || value === 'true')
+        return true;
+    if (value === false || value === 'false')
+        return false;
+    return fallback;
+}
+function fakePluginList() {
+    return {
+        marketplace_available: true,
+        plugins: [{
+                id: 'fixture-plugin',
+                name: 'Fixture Plugin',
+                source: 'marketplace',
+                installed: true,
+                enabled: true
+            }]
+    };
+}
+function fakePluginDetail(pluginId) {
+    return {
+        id: pluginId,
+        name: pluginId,
+        source: 'marketplace',
+        installed: true,
+        enabled: true,
+        default_prompts: ['Use the fixture plugin safely.'],
+        remote_mcp_servers: [{ name: 'fixture-db-docs', url: 'https://mcp.example.test', auth_type: 'oauth' }],
+        unavailable_app_templates: ['fixture-desktop-template']
+    };
+}
+//# sourceMappingURL=codex-plugin-json.js.map

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

@@ -20,6 +20,7 @@ import { runCodexLaunchPreflight } from '../preflight/parallel-preflight-engine.
 import { diffCodexAppUiSnapshots, writeCodexAppUiSnapshot } from '../codex-app/codex-app-ui-state-snapshot.js';
 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';
 export async function madHighCommand(args = [], deps = {}) {
     const subcommand = firstSubcommand(args);
     if (subcommand)
@@ -379,6 +380,7 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
     const has = (scope) => allowedScopes.has(scope);
     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);
     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
@@ -564,6 +566,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);
     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 };
@@ -738,6 +741,7 @@ async function materializeMadSksRun(root, targetRoot, permission, userIntent, js
     if (!(await exists(path.join(root, '.sneakoscope'))))
         await initProject(root, {});
     const { id, dir } = await createMission(root, { mode: 'mad-sks', prompt: userIntent });
+    await writeCodex0138CapabilityArtifacts(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

@@ -19,6 +19,8 @@ import { buildNarutoGptFinalPack } from '../naruto/naruto-gpt-final-pack.js';
 import { planNarutoZellijDashboard } from '../zellij/zellij-naruto-dashboard.js';
 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';
 const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
 const NARUTO_ROUTE = '$Naruto';
 // $Naruto — Shadow Clone Swarm (影分身 / Kage Bunshin no Jutsu).
@@ -37,6 +39,8 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
         return narutoDashboard(parsed);
     if (parsed.action === 'workers')
         return narutoWorkers(parsed);
+    if (parsed.action === 'proof')
+        return narutoProof(parsed);
     return narutoRun(parsed);
 }
 async function narutoRun(parsed) {
@@ -70,6 +74,7 @@ async function narutoRun(parsed) {
         maxAgentCount: MAX_NARUTO_AGENT_COUNT
     });
     const mission = await createMission(root, { mode: 'naruto', prompt: parsed.prompt });
+    await writeCodex0138CapabilityArtifacts(root, { missionId: mission.id }).catch(() => null);
     const gitWorktreeCapability = writeCapable
         ? await evaluateGitWorktreeCapability({ root, missionId: mission.id })
         : null;
@@ -379,7 +384,7 @@ async function narutoRun(parsed) {
         && Number(parallelRuntime.max_observed_active_workers || 0) >= Math.min(16, activeSlots));
     await writeJsonAtomic(path.join(mission.dir, 'naruto-gate.json'), {
         schema: 'sks.naruto-gate.v1',
-        passed: result.ok === true && nativeProofOk && finalAccepted,
+        passed: result.ok === true && nativeProofOk && finalAccepted && parallelRuntimeOk,
         mission_id: mission.id,
         clone_roster_built: true,
         clone_count: roster.agent_count,
@@ -702,6 +707,16 @@ async function narutoWorkers(parsed) {
         console.log(`Active ${summary.active} · completed ${summary.completed} · failed ${summary.failed} · visible ${summary.visible_worker_panes.length} · headless ${summary.headless_workers.length}`);
     });
 }
+async function narutoProof(parsed) {
+    const root = await sksRoot();
+    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);
+    return emit(parsed, { ...summary, action: 'proof' }, () => {
+        console.log(renderRuntimeProofSummary(summary));
+    });
+}
 async function narutoHelp(parsed) {
     const help = {
         schema: NARUTO_RESULT_SCHEMA,
@@ -711,7 +726,8 @@ async function narutoHelp(parsed) {
         description: 'Shadow Clone Swarm: fan out up to ' + MAX_NARUTO_AGENT_COUNT + ' parallel clone sessions.',
         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 status [--mission <id>] [--json]',
+            'sks naruto proof latest [--json]'
         ],
         defaults: { clones: DEFAULT_NARUTO_CLONES, max_clones: MAX_NARUTO_AGENT_COUNT, backend: 'codex-sdk' }
     };
@@ -726,7 +742,7 @@ function parseNarutoArgs(args = []) {
     if (hasFlag(args, '--help') || hasFlag(args, '-h'))
         args = ['help', ...args.filter((arg) => arg !== '--help' && arg !== '-h')];
     const first = args[0] && !String(args[0]).startsWith('--') ? String(args[0]) : '';
-    const actions = new Set(['run', 'status', 'help', 'dashboard', 'workers']);
+    const actions = new Set(['run', 'status', 'help', 'dashboard', 'workers', 'proof']);
     const action = (actions.has(first) ? first : 'run');
     const rest = action === first ? args.slice(1) : args;
     const json = hasFlag(args, '--json');
@@ -743,7 +759,7 @@ function parseNarutoArgs(args = []) {
     const readonly = hasFlag(args, '--readonly') || hasFlag(args, '--read-only');
     const writeModeRaw = String(readOption(args, '--write-mode', hasFlag(args, '--parallel-write') ? 'parallel' : '') || '');
     const writeMode = (['proof-safe', 'parallel', 'serial', 'off'].includes(writeModeRaw) ? writeModeRaw : null);
-    const positionalMission = action === 'dashboard' || action === 'workers' || action === 'status'
+    const positionalMission = action === 'dashboard' || action === 'workers' || action === 'status' || action === 'proof'
         ? positionalArgs(rest, new Set()).find((arg) => /^latest$|^M-/.test(arg))
         : null;
     const missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', positionalMission || 'latest')));