sneakoscope 2.0.18 → 3.0.1

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-0139-capability.js

@@ -0,0 +1,102 @@
+import path from 'node:path';
+import { findCodexBinary } from '../codex-adapter.js';
+import { compareSemverLike, parseCodexVersionText } from '../codex-compat/codex-version-policy.js';
+import { nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
+export async function detectCodex0139Capability(input = {}) {
+    const fake = process.env.SKS_CODEX_0139_FAKE === '1';
+    const codexBin = fake
+        ? input.codexBin || process.env.CODEX_BIN || 'codex'
+        : input.codexBin || process.env.CODEX_BIN || await findCodexBinary();
+    const versionText = fake
+        ? String(process.env.SKS_CODEX_VERSION_FAKE || 'codex-cli 0.139.0')
+        : await readCodexVersionText(codexBin);
+    const parsed = parseCodexVersionText(versionText);
+    const atLeast139 = Boolean(parsed && compareSemverLike(parsed, '0.139.0') >= 0);
+    const probeMode = process.env.SKS_CODEX_0139_PROBE === '1' ? 'feature-probe' : 'version-only';
+    const featureProbeResults = probeMode === 'feature-probe'
+        ? await probeCodex0139Features(codexBin, { fake })
+        : {
+            marketplace_list_json: 'skipped',
+            sandbox_profile_alias: 'skipped'
+        };
+    const marketplaceOk = atLeast139 && (probeMode === 'version-only' || featureProbeResults.marketplace_list_json !== 'failed');
+    const profileAliasOk = atLeast139 && (probeMode === 'version-only' || featureProbeResults.sandbox_profile_alias !== 'failed');
+    const blockers = [
+        ...(!codexBin ? ['codex_cli_missing'] : []),
+        ...(atLeast139 ? [] : ['codex_0_139_required_for_search_schema_marketplace_features']),
+        ...(probeMode === 'feature-probe' && featureProbeResults.marketplace_list_json === 'failed' ? ['codex_marketplace_list_json_probe_failed'] : [])
+    ];
+    return {
+        schema: 'sks.codex-0139-capability.v1',
+        ok: atLeast139 && blockers.length === 0,
+        probe_mode: probeMode,
+        codex_bin: codexBin || null,
+        version_text: versionText || null,
+        parsed_version: parsed,
+        supports_code_mode_web_search: atLeast139,
+        supports_rich_tool_schemas: atLeast139,
+        supports_doctor_env_details: atLeast139,
+        supports_marketplace_source_field: marketplaceOk,
+        supports_plugin_catalog_cache: atLeast139,
+        supports_sandbox_profile_alias: profileAliasOk,
+        supports_interrupt_agent_rename: atLeast139,
+        feature_probe_results: featureProbeResults,
+        blockers
+    };
+}
+export async function writeCodex0139CapabilityArtifacts(root, input = {}) {
+    const capability = await detectCodex0139Capability({ codexBin: input.codexBin || null });
+    const report = { ...capability, generated_at: nowIso() };
+    const rootArtifact = path.join(root, '.sneakoscope', 'codex-0139-capability.json');
+    await writeJsonAtomic(rootArtifact, report);
+    let missionArtifact = null;
+    if (input.missionId) {
+        missionArtifact = path.join(root, '.sneakoscope', 'missions', input.missionId, 'codex-0139-capability.json');
+        await writeJsonAtomic(missionArtifact, report);
+    }
+    return { report, root_artifact: rootArtifact, mission_artifact: missionArtifact };
+}
+async function readCodexVersionText(codexBin) {
+    if (!codexBin)
+        return null;
+    const result = await runProcess(codexBin, ['--version'], { timeoutMs: 10_000, maxOutputBytes: 16 * 1024 }).catch((err) => ({
+        code: 1,
+        stdout: '',
+        stderr: err?.message || String(err)
+    }));
+    const text = `${result.stdout || ''}${result.stderr || ''}`.trim();
+    return result.code === 0 ? text : text || null;
+}
+async function probeCodex0139Features(codexBin, opts = {}) {
+    if (opts.fake) {
+        return {
+            marketplace_list_json: process.env.SKS_CODEX_0139_FAKE_MARKETPLACE_FAIL === '1' ? 'failed' : 'passed',
+            sandbox_profile_alias: 'passed'
+        };
+    }
+    const timeoutMs = Math.max(1, Number(process.env.SKS_CODEX_0139_PROBE_TIMEOUT_MS || 3000) || 3000);
+    if (!codexBin) {
+        return { marketplace_list_json: 'failed', sandbox_profile_alias: 'failed' };
+    }
+    const marketplace = await runProcess(codexBin, ['plugin', 'marketplace', 'list', '--json'], { timeoutMs, maxOutputBytes: 256 * 1024 }).catch(() => ({ code: 1, stdout: '' }));
+    const marketplaceListJson = marketplace.code === 0 && marketplaceSourcesPresent(marketplace.stdout) ? 'passed' : 'failed';
+    const help = await runProcess(codexBin, ['--help'], { timeoutMs, maxOutputBytes: 256 * 1024 }).catch(() => ({ code: 1, stdout: '' }));
+    const aliasOk = help.code === 0 && /(^|\s)-P[,\s]/m.test(String(help.stdout || ''));
+    return {
+        marketplace_list_json: marketplaceListJson,
+        sandbox_profile_alias: aliasOk ? 'passed' : 'failed'
+    };
+}
+export function marketplaceSourcesPresent(stdout) {
+    try {
+        const parsed = JSON.parse(String(stdout || ''));
+        const rows = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.marketplaces) ? parsed.marketplaces : Array.isArray(parsed?.items) ? parsed.items : [];
+        if (!rows.length)
+            return true;
+        return rows.some((row) => typeof row?.source === 'string' && row.source.length > 0);
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=codex-0139-capability.js.map

package/dist/core/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