sneakoscope 2.0.18 → 3.0.0

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

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { detectCodex0138Capability } from '../codex-control/codex-0138-capability.js';
 import { nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { attemptCodexAppLaunch } from './codex-app-launcher.js';
 export function buildCodexAppHandoffPrompt(request) {
     return [
         'SKS Codex Desktop /app handoff request',
@@ -23,6 +24,7 @@ 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 launchMode = request.launch_mode || 'artifact-only';
     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');
@@ -32,26 +34,45 @@ export async function runCodexAppHandoff(root, request) {
     ];
     const prompt = buildCodexAppHandoffPrompt(request);
     await writeTextAtomic(promptArtifactPath, prompt);
+    const launchAttempt = desktopSupported
+        ? await attemptCodexAppLaunch({
+            cwd: root,
+            promptArtifactPath,
+            mode: launchMode,
+            timeoutMs: 3000
+        })
+        : await attemptCodexAppLaunch({
+            cwd: root,
+            promptArtifactPath,
+            mode: 'artifact-only',
+            timeoutMs: 3000
+        });
     const status = request.require_desktop && !desktopSupported
         ? 'blocked_for_desktop_review'
-        : desktopSupported
-            ? 'pending'
-            : 'skipped';
+        : request.require_desktop && launchMode === 'attempt-launch' && launchAttempt.attempted && !launchAttempt.launched
+            ? 'blocked_for_desktop_review'
+            : desktopSupported && launchAttempt.launched
+                ? 'launched_pending_confirmation'
+                : desktopSupported
+                    ? 'pending'
+                    : 'skipped';
     const result = {
         schema: 'sks.codex-app-handoff-result.v1',
-        ok: request.require_desktop ? desktopSupported : true,
-        attempted: false,
-        launched: false,
+        ok: request.require_desktop ? status !== 'blocked_for_desktop_review' : true,
+        attempted: launchAttempt.attempted,
+        launched: launchAttempt.launched,
         status,
         codex_0138_capability: capability,
-        command_line: ['codex', '/app'],
+        command_line: launchAttempt.command_line,
+        launch_attempt: launchAttempt,
+        confirmation_required: request.require_desktop,
         desktop_handoff_supported: desktopSupported,
         fallback_reason: desktopSupported
-            ? 'interactive_tui_handoff_pending_operator'
+            ? launchAttempt.fallback_reason || 'desktop_handoff_pending_operator_confirmation'
             : blockers.join(';') || null,
         artifact_path: artifactPath,
         prompt_artifact_path: promptArtifactPath,
-        blockers: request.require_desktop ? blockers : []
+        blockers: request.require_desktop ? [...blockers, ...(status === 'blocked_for_desktop_review' ? launchAttempt.blockers : [])] : []
     };
     await writeJsonAtomic(artifactPath, {
         ...result,

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

@@ -0,0 +1,103 @@
+import { findCodexBinary } from '../codex-adapter.js';
+import { runProcess } from '../fsx.js';
+export async function attemptCodexAppLaunch(input) {
+    const platform = process.platform;
+    const timeoutMs = Math.max(1, Math.min(Number(input.timeoutMs || 3000), 3000));
+    const codexBin = input.codexBin || await findCodexBinary();
+    const commandLine = [codexBin || 'codex', '/app'];
+    if (input.mode === 'artifact-only') {
+        return launchAttempt({
+            attempted: false,
+            launched: false,
+            platform,
+            mode: input.mode,
+            command_line: commandLine,
+            exit_code: null,
+            fallback_reason: 'artifact_only_mode',
+            blockers: []
+        });
+    }
+    const platformSupported = platform === 'darwin' || platform === 'win32';
+    if (!platformSupported) {
+        return launchAttempt({
+            attempted: false,
+            launched: false,
+            platform,
+            mode: input.mode,
+            command_line: commandLine,
+            exit_code: null,
+            fallback_reason: 'unsupported_platform_artifact_only_fallback',
+            blockers: ['codex_app_handoff_platform_unsupported']
+        });
+    }
+    if (!codexBin) {
+        return launchAttempt({
+            attempted: false,
+            launched: false,
+            platform,
+            mode: input.mode,
+            command_line: commandLine,
+            exit_code: null,
+            fallback_reason: 'codex_cli_missing_artifact_only_fallback',
+            blockers: ['codex_cli_missing']
+        });
+    }
+    if (process.env.SKS_CODEX_APP_LAUNCH_FAKE === '1') {
+        const launched = process.env.SKS_CODEX_APP_LAUNCH_FAKE_LAUNCHED !== '0';
+        return launchAttempt({
+            attempted: true,
+            launched,
+            platform,
+            mode: input.mode,
+            command_line: commandLine,
+            exit_code: launched ? 0 : 1,
+            stdout_tail: launched ? 'fake codex /app launched' : '',
+            stderr_tail: launched ? '' : 'fake launch failed',
+            fallback_reason: launched ? null : 'fake_launch_failed',
+            blockers: launched ? [] : ['codex_app_launch_failed']
+        });
+    }
+    const result = await runProcess(codexBin, ['/app'], {
+        cwd: input.cwd,
+        timeoutMs,
+        maxOutputBytes: 32 * 1024,
+        input: `Continue the SKS mission using this prompt artifact:\n${input.promptArtifactPath}\n`
+    }).catch((err) => ({
+        code: -1,
+        stdout: '',
+        stderr: err instanceof Error ? err.message : String(err),
+        timedOut: false
+    }));
+    const code = typeof result.code === 'number' ? result.code : null;
+    const stdout = String(result.stdout || '');
+    const stderr = String(result.stderr || '');
+    const markerLaunched = /(?:handoff|desktop|app).*?(?:launched|opened|ready)|(?:launched|opened).*?(?:handoff|desktop|app)/i.test(`${stdout}\n${stderr}`);
+    const launched = code === 0 || markerLaunched;
+    const timedOut = result.timedOut === true || code === 124;
+    const fallbackReason = launched
+        ? null
+        : timedOut
+            ? 'codex_app_handoff_interactive_or_timed_out_artifact_only_fallback'
+            : 'codex_app_launch_failed_artifact_only_fallback';
+    return launchAttempt({
+        attempted: true,
+        launched,
+        platform,
+        mode: input.mode,
+        command_line: commandLine,
+        exit_code: code,
+        stdout_tail: stdout.slice(-4000),
+        stderr_tail: stderr.slice(-4000),
+        fallback_reason: fallbackReason,
+        blockers: launched ? [] : [timedOut ? 'codex_app_launch_interactive_or_timeout' : 'codex_app_launch_failed']
+    });
+}
+function launchAttempt(input) {
+    return {
+        schema: 'sks.codex-app-launch-attempt.v1',
+        stdout_tail: input.stdout_tail || '',
+        stderr_tail: input.stderr_tail || '',
+        ...input
+    };
+}
+//# sourceMappingURL=codex-app-launcher.js.map

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

@@ -12,23 +12,36 @@ export async function detectCodex0138Capability(input = {}) {
         : await readCodexVersionText(codexBin);
     const parsed = parseCodexVersion(versionText);
     const atLeast138 = Boolean(parsed && semverGte(parsed, '0.138.0'));
+    const probeMode = process.env.SKS_CODEX_0138_PROBE === '1' ? 'feature-probe' : 'version-only';
+    const featureProbeResults = probeMode === 'feature-probe'
+        ? await probeCodex0138Features(codexBin, { fake })
+        : {
+            plugin_json: 'skipped',
+            app_handoff_platform: 'skipped',
+            image_path_exposure_contract: 'sks-enforced'
+        };
+    const pluginJsonOk = atLeast138 && (probeMode === 'version-only' || featureProbeResults.plugin_json !== 'failed');
+    const appHandoffOk = atLeast138 && (probeMode === 'version-only' || featureProbeResults.app_handoff_platform === 'passed');
     const blockers = [
         ...(!codexBin ? ['codex_cli_missing'] : []),
-        ...(atLeast138 ? [] : ['codex_0_138_required_for_app_plugin_features'])
+        ...(atLeast138 ? [] : ['codex_0_138_required_for_app_plugin_features']),
+        ...(probeMode === 'feature-probe' && featureProbeResults.plugin_json === 'failed' ? ['codex_plugin_json_probe_failed'] : [])
     ];
     return {
         schema: 'sks.codex-0138-capability.v1',
-        ok: atLeast138,
+        ok: atLeast138 && blockers.length === 0,
+        probe_mode: probeMode,
         codex_bin: codexBin || null,
         version_text: versionText || null,
         parsed_version: parsed,
-        supports_app_handoff: atLeast138,
-        supports_plugin_json: atLeast138,
+        supports_app_handoff: appHandoffOk,
+        supports_plugin_json: pluginJsonOk,
         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,
+        feature_probe_results: featureProbeResults,
         blockers
     };
 }
@@ -61,4 +74,29 @@ async function readCodexVersionText(codexBin) {
     const text = `${result.stdout || ''}${result.stderr || ''}`.trim();
     return result.code === 0 ? text : text || null;
 }
+async function probeCodex0138Features(codexBin, opts = {}) {
+    if (opts.fake) {
+        return {
+            plugin_json: process.env.SKS_CODEX_0138_FAKE_PLUGIN_JSON_FAIL === '1' ? 'failed' : 'passed',
+            app_handoff_platform: process.platform === 'darwin' || process.platform === 'win32' ? 'passed' : 'failed',
+            image_path_exposure_contract: 'sks-enforced'
+        };
+    }
+    const timeoutMs = Math.max(1, Number(process.env.SKS_CODEX_0138_PROBE_TIMEOUT_MS || 3000) || 3000);
+    const platformSupported = process.platform === 'darwin' || process.platform === 'win32';
+    if (!codexBin) {
+        return {
+            plugin_json: 'failed',
+            app_handoff_platform: platformSupported ? 'skipped' : 'failed',
+            image_path_exposure_contract: 'sks-enforced'
+        };
+    }
+    const list = await runProcess(codexBin, ['plugin', 'list', '--json'], { timeoutMs, maxOutputBytes: 64 * 1024 }).catch(() => ({ code: 1 }));
+    const detailHelp = await runProcess(codexBin, ['plugin', 'detail', '--help'], { timeoutMs, maxOutputBytes: 64 * 1024 }).catch(() => ({ code: 1 }));
+    return {
+        plugin_json: list.code === 0 && detailHelp.code === 0 ? 'passed' : 'failed',
+        app_handoff_platform: platformSupported ? 'passed' : 'failed',
+        image_path_exposure_contract: 'sks-enforced'
+    };
+}
 //# sourceMappingURL=codex-0138-capability.js.map

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

@@ -1,15 +1,36 @@
+import path from 'node:path';
+import { writeJsonAtomic } from '../fsx.js';
+import { collectCodexModelMetadata } from './codex-model-metadata.js';
 export const SKS_FALLBACK_EFFORT_ORDER = ['minimal', 'low', 'medium', 'high', 'xhigh'];
 export function codexModelEffortCapability(input = {}) {
-    const advertised = normalizeAdvertisedEfforts(input.advertisedEfforts);
+    const metadataIsFallback = input.metadata?.source === 'fallback';
+    const advertised = metadataIsFallback ? [] : normalizeAdvertisedEfforts(input.metadata?.advertised_efforts || 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';
+    const requestedDefault = input.metadata?.default_effort || input.defaultEffort;
+    const defaultEffort = order.includes(String(requestedDefault || '')) ? String(requestedDefault) : order.includes('medium') ? 'medium' : order[0] || 'medium';
     return {
-        model: String(input.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || 'gpt-5.5'),
+        model: String(input.metadata?.model || 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'
+        order_source: advertised.length ? 'model-advertised' : 'sks-fallback',
+        metadata_source: input.metadata?.source || null,
+        metadata_blockers: input.metadata?.blockers || []
     };
 }
+export async function resolveCodexModelEffortCapability(input = {}) {
+    const metadata = await collectCodexModelMetadata({ model: input.model || null });
+    return codexModelEffortCapability({ metadata });
+}
+export async function writeCodexModelEffortCapabilityArtifact(root, input) {
+    const capability = await resolveCodexModelEffortCapability({ model: input.model || null });
+    const artifact = path.join(root, '.sneakoscope', 'missions', input.missionId, 'codex-model-effort-capability.json');
+    await writeJsonAtomic(artifact, {
+        schema: 'sks.codex-model-effort-capability-artifact.v1',
+        generated_at: new Date().toISOString(),
+        ...capability
+    });
+    return { capability, artifact };
+}
 export function normalizeAdvertisedEfforts(value) {
     const rows = Array.isArray(value) ? value : String(value || '').split(',');
     const seen = new Set();

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

@@ -0,0 +1,91 @@
+import { findCodexBinary } from '../codex-adapter.js';
+import { runProcess } from '../fsx.js';
+const FALLBACK_EFFORT_ORDER = ['minimal', 'low', 'medium', 'high', 'xhigh'];
+export async function collectCodexModelMetadata(input = {}) {
+    if (process.env.SKS_CODEX_MODEL_METADATA_FAKE === '1') {
+        const advertised = normalizeAdvertisedEfforts(process.env.SKS_CODEX_MODEL_EFFORTS || 'low,medium,high,xhigh');
+        return metadata(String(input.model || process.env.SKS_CODEX_MODEL || 'gpt-5.5'), advertised, 'medium', 'app-server', []);
+    }
+    const model = String(input.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || 'gpt-5.5');
+    const appServer = await readAppServerMetadata(model);
+    if (appServer)
+        return appServer;
+    const cli = await readCodexCliMetadata(model);
+    if (cli)
+        return cli;
+    const envEfforts = normalizeAdvertisedEfforts(process.env.SKS_CODEX_MODEL_EFFORTS || '');
+    if (envEfforts.length)
+        return metadata(model, envEfforts, process.env.SKS_CODEX_MODEL_DEFAULT_EFFORT || 'medium', 'env', []);
+    return metadata(model, FALLBACK_EFFORT_ORDER, 'medium', 'fallback', ['codex_model_metadata_unavailable']);
+}
+async function readAppServerMetadata(model) {
+    const url = String(process.env.CODEX_APP_SERVER_METADATA_URL || process.env.SKS_CODEX_APP_SERVER_METADATA_URL || '').trim();
+    if (!url)
+        return null;
+    try {
+        const response = await fetch(url, { signal: AbortSignal.timeout(3000) });
+        if (!response.ok)
+            return null;
+        const payload = await response.json();
+        return normalizePayload(payload, model, 'app-server');
+    }
+    catch {
+        return null;
+    }
+}
+async function readCodexCliMetadata(model) {
+    const bin = await findCodexBinary();
+    if (!bin)
+        return null;
+    const commands = [
+        ['model', 'metadata', '--json'],
+        ['debug', 'model-metadata', '--json'],
+        ['capabilities', '--json']
+    ];
+    for (const args of commands) {
+        const result = await runProcess(bin, args, { timeoutMs: 3000, maxOutputBytes: 64 * 1024 }).catch(() => null);
+        if (!result || result.code !== 0)
+            continue;
+        try {
+            const payload = JSON.parse(`${result.stdout || ''}${result.stderr || ''}`.trim() || '{}');
+            const normalized = normalizePayload(payload, model, 'codex-cli');
+            if (normalized.advertised_efforts.length)
+                return normalized;
+        }
+        catch { }
+    }
+    return null;
+}
+function normalizePayload(payload, fallbackModel, source) {
+    const row = Array.isArray(payload?.models)
+        ? payload.models.find((candidate) => String(candidate?.id || candidate?.model || candidate?.name || '') === fallbackModel) || payload.models[0]
+        : payload?.model_metadata || payload?.metadata || payload;
+    const efforts = normalizeAdvertisedEfforts(row?.advertised_efforts || row?.advertisedEfforts || row?.reasoning_efforts || row?.reasoningEfforts || payload?.advertised_efforts);
+    return metadata(String(row?.model || row?.id || row?.name || fallbackModel), efforts, row?.default_effort || row?.defaultEffort || payload?.default_effort || 'medium', source, efforts.length ? [] : ['codex_model_metadata_efforts_missing']);
+}
+function metadata(model, efforts, defaultEffort, source, blockers) {
+    const advertised = normalizeAdvertisedEfforts(efforts);
+    const defaultValue = advertised.includes(defaultEffort) ? defaultEffort : advertised.includes('medium') ? 'medium' : advertised[0] || 'medium';
+    return {
+        schema: 'sks.codex-model-metadata.v1',
+        model,
+        advertised_efforts: advertised,
+        default_effort: defaultValue,
+        source,
+        blockers
+    };
+}
+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;
+}
+//# sourceMappingURL=codex-model-metadata.js.map

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

@@ -0,0 +1,38 @@
+import path from 'node:path';
+import { readJson, writeJsonAtomic } from '../fsx.js';
+import { buildCodexPluginInventory } from './codex-plugin-json.js';
+export function codexPluginInventoryCachePath(root) {
+    return path.join(root, '.sneakoscope', 'cache', 'codex-plugin-inventory.json');
+}
+export async function readCodexPluginInventoryCache(root) {
+    const cache = await readJson(codexPluginInventoryCachePath(root), null);
+    return cache?.schema === 'sks.codex-plugin-inventory-cache.v1' ? cache : null;
+}
+export async function writeCodexPluginInventoryCache(root, inventory, ttlMs = defaultTtlMs()) {
+    const generatedAt = new Date();
+    const cache = {
+        schema: 'sks.codex-plugin-inventory-cache.v1',
+        generated_at: generatedAt.toISOString(),
+        expires_at: new Date(generatedAt.getTime() + ttlMs).toISOString(),
+        ttl_ms: ttlMs,
+        inventory
+    };
+    await writeJsonAtomic(codexPluginInventoryCachePath(root), cache);
+    return cache;
+}
+export async function getCodexPluginInventoryCached(root, opts = {}) {
+    const ttlMs = Math.max(1, Number(opts.ttlMs || defaultTtlMs()) || defaultTtlMs());
+    const cachePath = codexPluginInventoryCachePath(root);
+    const existing = opts.forceRefresh ? null : await readCodexPluginInventoryCache(root);
+    if (existing && Date.parse(existing.expires_at) > Date.now()) {
+        return { inventory: existing.inventory, cache_hit: true, cache_path: cachePath, cache: existing };
+    }
+    const inventory = await (opts.inventoryFactory || buildCodexPluginInventory)();
+    const cache = await writeCodexPluginInventoryCache(root, inventory, ttlMs);
+    return { inventory, cache_hit: false, cache_path: cachePath, cache };
+}
+function defaultTtlMs() {
+    const value = Number(process.env.SKS_CODEX_PLUGIN_CACHE_TTL_MS || 10 * 60 * 1000);
+    return Number.isFinite(value) && value > 0 ? value : 10 * 60 * 1000;
+}
+//# sourceMappingURL=codex-plugin-cache.js.map

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

@@ -0,0 +1,73 @@
+import path from 'node:path';
+import { writeJsonAtomic } from '../fsx.js';
+export function diffCodexPluginInventories(previous, current) {
+    const prev = pluginMap(previous);
+    const next = pluginMap(current);
+    const added = [...next.keys()].filter((id) => !prev.has(id)).sort();
+    const removed = [...prev.keys()].filter((id) => !next.has(id)).sort();
+    const shared = [...next.keys()].filter((id) => prev.has(id));
+    const changedRemote = [];
+    const changedTemplates = [];
+    const changedPrompts = [];
+    const changedMetadata = [];
+    for (const id of shared) {
+        const before = prev.get(id);
+        const after = next.get(id);
+        if (!sameJson(normalizePluginMetadata(before), normalizePluginMetadata(after)))
+            changedMetadata.push(id);
+        if (!sameJson(normalizeRemoteServers(before?.remote_mcp_servers), normalizeRemoteServers(after?.remote_mcp_servers)))
+            changedRemote.push(id);
+        if (!sameJson(sorted(before?.unavailable_app_templates), sorted(after?.unavailable_app_templates)))
+            changedTemplates.push(id);
+        if (!sameJson(sorted(before?.default_prompts), sorted(after?.default_prompts)))
+            changedPrompts.push(id);
+    }
+    const changedCount = added.length + removed.length + changedMetadata.length + changedRemote.length + changedTemplates.length + changedPrompts.length;
+    return {
+        schema: 'sks.codex-plugin-inventory-diff.v1',
+        generated_at: new Date().toISOString(),
+        ok: true,
+        added_plugins: added,
+        removed_plugins: removed,
+        changed_remote_mcp_servers: changedRemote.sort(),
+        changed_unavailable_app_templates: changedTemplates.sort(),
+        changed_default_prompts: changedPrompts.sort(),
+        changed_plugin_metadata: changedMetadata.sort(),
+        changed_count: changedCount
+    };
+}
+export async function writeCodexPluginInventoryDiff(root, previous, current) {
+    const diff = diffCodexPluginInventories(previous, current);
+    const artifact = path.join(root, '.sneakoscope', 'codex-plugin-inventory.diff.json');
+    await writeJsonAtomic(artifact, diff);
+    return { diff, artifact };
+}
+function pluginMap(inventory) {
+    const map = new Map();
+    for (const plugin of inventory?.plugins || [])
+        map.set(String(plugin.id || plugin.name), plugin);
+    return map;
+}
+function normalizeRemoteServers(rows) {
+    return (rows || []).map((row) => ({
+        name: row.name,
+        url: row.url,
+        auth_type: row.auth_type
+    })).sort((a, b) => `${a.name}:${a.url}:${a.auth_type}`.localeCompare(`${b.name}:${b.url}:${b.auth_type}`));
+}
+function normalizePluginMetadata(row) {
+    return {
+        id: row?.id || null,
+        name: row?.name || null,
+        source: row?.source || null,
+        installed: row?.installed === true,
+        enabled: row?.enabled === true
+    };
+}
+function sorted(rows) {
+    return [...(rows || [])].map(String).sort();
+}
+function sameJson(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+//# sourceMappingURL=codex-plugin-diff.js.map

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

@@ -19,14 +19,18 @@ export async function runCodexPluginDetailJson(pluginId) {
     return runCodexJson(bin, ['plugin', 'detail', pluginId, '--json']);
 }
 export async function buildCodexPluginInventory() {
+    const started = Date.now();
     const capability = await detectCodex0138Capability();
     const listJson = await runCodexPluginListJson();
     const summaries = normalizePluginList(listJson);
-    const plugins = [];
-    for (const summary of summaries) {
+    const concurrency = Math.max(1, Number(process.env.SKS_CODEX_PLUGIN_DETAIL_CONCURRENCY || 6) || 6);
+    let failed = 0;
+    const plugins = await mapWithConcurrency(summaries, concurrency, async (summary) => {
         const detail = await runCodexPluginDetailJson(summary.id || summary.name).catch((err) => ({ error: err?.message || String(err) }));
-        plugins.push(normalizePlugin(summary, detail));
-    }
+        if (detail?.error || normalizeList(detail?.blockers).length > 0)
+            failed += 1;
+        return normalizePlugin(summary, detail);
+    });
     const blockers = [
         ...(capability.supports_plugin_json ? [] : ['codex_0_138_plugin_json_unavailable']),
         ...normalizeList(listJson?.blockers)
@@ -35,11 +39,29 @@ export async function buildCodexPluginInventory() {
         schema: 'sks.codex-plugin-inventory.v1',
         generated_at: nowIso(),
         codex_0138_capability: capability,
+        fetch_concurrency: concurrency,
+        detail_fetch_count: summaries.length,
+        detail_fetch_failed_count: failed,
+        duration_ms: Date.now() - started,
         plugins,
         marketplace_available: plugins.some((plugin) => plugin.source === 'marketplace' || plugin.source === 'remote') || Boolean(listJson?.marketplace_available || listJson?.marketplaceAvailable),
         blockers
     };
 }
+export async function mapWithConcurrency(items, concurrency, fn) {
+    const limit = Math.max(1, Math.floor(concurrency || 1));
+    const results = new Array(items.length);
+    let next = 0;
+    async function worker() {
+        while (next < items.length) {
+            const index = next;
+            next += 1;
+            results[index] = await fn(items[index]);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length || 1) }, () => worker()));
+    return results;
+}
 export async function writeCodexPluginInventoryArtifacts(root, inventory = null) {
     const report = inventory || await buildCodexPluginInventory();
     const artifact = path.join(root, '.sneakoscope', 'codex-plugin-inventory.json');
@@ -126,15 +148,17 @@ function boolish(value, fallback = false) {
     return fallback;
 }
 function fakePluginList() {
+    const count = Math.max(1, Number(process.env.SKS_CODEX_PLUGIN_JSON_FAKE_COUNT || 1) || 1);
     return {
         marketplace_available: true,
-        plugins: [{
-                id: 'fixture-plugin',
-                name: 'Fixture Plugin',
-                source: 'marketplace',
-                installed: true,
-                enabled: true
-            }]
+        plugins: Array.from({ length: count }, (_, index) => ({
+            id: 'fixture-plugin',
+            name: index === 0 ? 'Fixture Plugin' : `Fixture Plugin ${index + 1}`,
+            ...(index === 0 ? {} : { id: `fixture-plugin-${index + 1}` }),
+            source: 'marketplace',
+            installed: true,
+            enabled: true
+        }))
     };
 }
 function fakePluginDetail(pluginId) {

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

@@ -37,6 +37,10 @@ export async function madHighCommand(args = [], deps = {}) {
         process.exitCode = 1;
         return;
     }
+    // Zellij is checked the same way Codex is, but it stays NON-blocking: a
+    // failed or skipped zellij upgrade never prevents the MAD launch.
+    const zellijUpdate = deps.maybePromptZellijUpdateForLaunch ? await deps.maybePromptZellijUpdateForLaunch(args, { label: 'MAD launch' }).catch(() => ({ status: 'error' })) : { status: 'skipped' };
+    void zellijUpdate;
     const depStatus = deps.ensureMadLaunchDependencies ? await deps.ensureMadLaunchDependencies(args) : { ready: true, actions: [] };
     if (!depStatus.ready) {
         console.error('SKS MAD launch blocked by missing dependencies.');

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

@@ -7,6 +7,7 @@ import { buildNarutoCloneRoster, systemSafeNarutoConcurrency } from '../agents/a
 import { DEFAULT_NARUTO_CLONES, MAX_NARUTO_AGENT_COUNT } from '../agents/agent-schema.js';
 import { resolveOllamaWorkerConfig } from '../agents/ollama-worker-config.js';
 import { attachZellijSessionInteractive, launchZellijLayout } from '../zellij/zellij-launcher.js';
+import { maybePromptZellijUpdateForLaunch } from '../zellij/zellij-update.js';
 import { buildNarutoWorkGraph } from '../naruto/naruto-work-graph.js';
 import { buildNarutoRoleDistribution } from '../naruto/naruto-role-policy.js';
 import { decideNarutoConcurrency } from '../naruto/naruto-concurrency-governor.js';
@@ -15,6 +16,7 @@ import { collectActualNarutoWorker, spawnActualNarutoWorker } from '../naruto/na
 import { allocateNarutoTasksToWorkers } from '../naruto/naruto-allocation-policy.js';
 import { rebalanceNarutoReadyWork } from '../naruto/naruto-rebalance-policy.js';
 import { buildNarutoVerificationDag } from '../naruto/naruto-verification-dag.js';
+import { evaluateNarutoFinalizer } from '../naruto/naruto-finalizer.js';
 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';
@@ -41,6 +43,12 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
         return narutoWorkers(parsed);
     if (parsed.action === 'proof')
         return narutoProof(parsed);
+    // Like the Codex CLI update prompt: check the installed zellij version and
+    // offer an upgrade to the latest stable release before the live session
+    // opens. Never blocks the run.
+    if (!parsed.json && !parsed.mock && !parsed.noOpenZellij) {
+        await maybePromptZellijUpdateForLaunch(args, { label: '$Naruto launch' }).catch(() => undefined);
+    }
     return narutoRun(parsed);
 }
 async function narutoRun(parsed) {
@@ -299,6 +307,10 @@ async function narutoRun(parsed) {
         console.log('  parallelism mode: ' + parsed.parallelism);
         if (activeSlots < roster.agent_count)
             console.log('  cap reasons: ' + (governor.reasons.join(', ') || 'host safety cap'));
+        // Backpressure used to throttle silently (50% when throttled, 25% when
+        // saturated); always tell the operator when host pressure reduced workers.
+        if (governor.backpressure !== 'normal')
+            console.log('  backpressure: ' + governor.backpressure + ' — host resource pressure reduced active workers (memory/cpu/fd/disk thresholds)');
         if (parsed.parallelism !== 'safe' && activeSlots < 10)
             console.log('  warning: active workers below 10 in non-safe mode');
     }
@@ -418,6 +430,18 @@ async function narutoRun(parsed) {
     });
     const clones = result.roster?.agent_count ?? roster.agent_count;
     const localWorkerSummary = summarizeNarutoLocalWorkerResult(localWorker, result);
+    // Finalizer policy: when local LLM workers contributed patches, the GPT
+    // final arbiter must have accepted before patches are considered final.
+    const finalizer = evaluateNarutoFinalizer({
+        localParticipated: Number(localWorkerSummary?.selected_worker_count || 0) > 0,
+        gptFinalStatus: result.proof?.gpt_final_status || null,
+        applyPatches: writeCapable
+    });
+    await writeJsonAtomic(path.join(mission.dir, 'naruto-finalizer.json'), {
+        ...finalizer,
+        generated_at: nowIso(),
+        mission_id: mission.id
+    });
     const summary = {
         schema: NARUTO_RESULT_SCHEMA,
         ok: result.ok === true,
@@ -477,6 +501,7 @@ async function narutoRun(parsed) {
             passed: parallelRuntime.passed
         } : null,
         local_worker: localWorkerSummary,
+        finalizer,
         proof: result.proof?.status || 'missing',
         run: compactNarutoRunResult(result),
         zellij: null
@@ -489,6 +514,8 @@ async function narutoRun(parsed) {
         console.log('Backend: ' + result.backend);
         console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
         console.log('Proof: ' + summary.proof);
+        if (!finalizer.ok)
+            console.log('Finalizer: blocked — ' + finalizer.blockers.join(', '));
         if (summary.parallel_runtime) {
             console.log('$Naruto parallel proof:');
             console.log('  max active workers: ' + summary.parallel_runtime.max_observed_active_workers);