sneakoscope 2.0.17 → 2.0.18

package/README.md

@@ -16,43 +16,34 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **2.0.17** is the micro-hardening release for strict production PID proof, true scheduler active-time utilization, live Zellij slot telemetry freshness, Mad-DB result lifecycle audit, and unified runtime/release proof summaries.
+SKS **2.0.18** is the Codex 0.138 integration release: capability artifacts, Desktop `/app` handoff, plugin JSON inventory, image saved-path contracts, model-advertised effort order, account usage budget policy, and startup doctor checks.
 
 What changed:
 
-- Zellij slot panes distinguish `slot_status_renderer` panes from Codex worker panes, and the first visible worker now stacks downward below the `SLOTS` anchor with real geometry proof available under `real-check`.
-- Naruto allocation owners now flow into work graph items, scheduler slices, queue ownership, and worker runtime proof; inactive owners are rebalanced and active write conflicts stay out of concurrent execution.
-- Naruto active-pool checks now exercise actual child-worker spawn/result collection paths while production source-of-truth stays with the agent orchestrator scheduler.
-- Worktree candidate output requires GPT Final approval before apply; GPT `modified` output replaces candidate patches and GPT `rejected` blocks apply.
-- Visible Zellij reservations are capped before pane launch so concurrent worker starts cannot over-open the right column.
-- Git worktree integration now proves the primary repo receives validated worktree diffs, with rollback hash evidence recorded around the apply step.
-- Agent role config repair detects stale generated role files and rewrites structured GPT-5.5-compatible configs atomically.
-- Release gates now include slot-only UI, compact slot renderer, headless overflow, role-config repair, worktree primary-runtime, real active-pool, extreme real parallelism, and real right-column geometry checks.
-- Release audit, dynamic selection, and stamp hashing use `release-gates.v2.json` as the manifest source of truth.
-- Git capability checks detect repo roots, Git dirs, worktree support, and safe cache roots while blocking in-repo worktree roots unless `SKS_ALLOW_IN_REPO_WORKTREES=1` is explicit.
-- Worker worktree allocation creates isolated branches/paths under `$SKS_WORKTREE_ROOT`, `$XDG_CACHE_HOME/sks/worktrees`, or `~/.cache/sks/worktrees`; main checkouts stay untouched until integration.
-- Product Design plugin readiness now checks both local and remote Codex App catalogs, auto-installs the remote plugin when needed, and records the installed/enabled skill surface.
-- UI/design/PPT runtime routes prefer Product Design for research, ideation, audit, design QA, prototype, URL-to-code, image-to-code, share, and user-context steps.
-- Naruto read-only runs force write mode off, propagate no-patch reasons through worker proof, and skip changed-file lease checks when no write-capable patch envelope exists.
-- `codex-sdk` is the default native agent backend for Team, QA, Research, Naruto, MAD-SKS, and direct agent runs, with every runtime task entering through `runCodexTask`.
-- Codex App UI snapshot, preservation, clobber guard, and doctor repair checks protect host-owned Fast UI/profile settings around `sks --mad`.
-- Provider context resolves `openai`, `codex-lb`, and `codex-app` with badge/fallback surfaces while avoiding private Codex App UI mutation.
-- UltraRouter writes `ultra-router-proof.json` decisions with tier, scores, hard filters, cache state, and cheapest-good-enough profile selection.
-- Reliability Shield writes `codex-reliability-shield.json` for empty-result retry, stream-idle blocking, tool-result repair, and no-CoT keepalive heartbeats.
-- Raw `codex exec` execution is removed from runtime fallback paths; explicit legacy requests are blocked with `legacy_codex_exec_runtime_removed`.
-- SDK runs write `codex-control-proof.json`, `codex-thread-registry.json`, `codex-sdk-events.jsonl`, and schema-validated worker results.
-- Zellij proof now links `pane_id`, `slot_id`, `generation_index`, `session_id`, `sdk_thread_id`, provider, and `service_tier`.
-- Production runtime scripts are TypeScript source under `src/scripts` and build to `dist/scripts`; Python remains optional diagnostics under `pytools`.
-- Release gates include `codex-control:*`, `ultra-router:*`, `codex-sdk:*`, Codex App Fast UI preservation, provider badges, Zellij spawn-on-demand, slot/pane binding, release truth, and real smoke checks.
-- Research synthesis is now evidence-bound in non-mock runs; deterministic report generation is mock/fallback only.
-- Research quality checks reject repeated paragraphs, template-like prose, low source density, low claim density, and thin implementation sections.
-- Research handoffs now include context, key claims, evidence summary, blueprint sections, parallel work items, acceptance tests, rollback, and source appendix for `$Team` or `$Naruto`.
+- `sks doctor` now reports Codex 0.138 feature readiness, plugin JSON inventory, candidate-only remote MCP servers, unavailable app templates, and repairable plugin discovery cache state.
+- QA-LOOP can write a Codex Desktop `/app` handoff artifact with `--app-handoff` or require it with `--app-handoff-required`; this never substitutes for Codex Chrome Extension web UI evidence.
+- Zellij slot panes and the right-column anchor surface pending QA `/app` handoffs so desktop review is visible during long native-agent runs.
+- Codex plugin detail JSON is normalized into `.sneakoscope/codex-plugin-inventory.json`, and plugin-provided remote MCP servers remain candidate-only until explicitly enabled under DB/Mad-DB safety policy.
+- Imagegen and QA image flows write `image-artifact-path-contract.json` with exact saved file paths and follow-up edit hints.
+- Effort routing now understands the fallback order `minimal < low < medium < high < xhigh`, records model capability, and escalates QA effort after repeated failures.
+- Codex account token usage can be recorded from an app-server usage endpoint, and QA budget policy reduces remote concurrency near limits while preserving GPT final review.
+- Naruto final pass status now depends on the parallel runtime proof, and Mad-DB post-tool lifecycle recording handles MCP `isError` failures.
 
 Quick checks:
 
 ```bash
 npm run typecheck
 npm run build
+npm run codex:0138-capability
+npm run codex-sdk:version-compat
+npm run codex-app:handoff
+npm run codex-plugin:inventory
+npm run qa-loop:app-handoff
+npm run image:artifact-path-contract
+npm run codex:effort-order
+npm run codex:account-usage
+npm run codex:0138-doctor
+npm run doctor:codex-0138-fix
 npm run codex-control:capability
 npm run codex-control:structured-output
 npm run codex-control:event-stream-ledger

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "2.0.17"
+version = "2.0.18"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.17"
+version = "2.0.18"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 2.0.17"),
+        Some("--version") => println!("sks-rs 2.0.18"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "2.0.17",
-  "source_digest": "1c6ef84350a97acdfd592ae544ec9054e2ee0a997076e725bc99b771c4693cf2",
-  "source_file_count": 2201,
-  "built_at_source_time": 1780974441836
+  "package_version": "2.0.18",
+  "source_digest": "3c246288e22bf5f29b5ba20a2a05b3f15a6afb9e6d680c531f7e78ef996c8c33",
+  "source_file_count": 2238,
+  "built_at_source_time": 1780992531184
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '2.0.17';
+const FAST_PACKAGE_VERSION = '2.0.18';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/commands/doctor.js

@@ -19,6 +19,10 @@ import { repairCodexAppFastUi } from '../core/codex-app/codex-app-fast-ui-repair
 import { resolveProviderContext } from '../core/provider/provider-context.js';
 import { readLocalModelConfig } from '../core/agents/ollama-worker-config.js';
 import { repairAgentRoleConfigs } from '../core/agents/agent-role-config.js';
+import { writeCodex0138CapabilityArtifacts } from '../core/codex-control/codex-0138-capability.js';
+import { runCodex0138Doctor } from '../core/doctor/codex-0138-doctor.js';
+import { writeCodexPluginInventoryArtifacts, pluginAppTemplatePolicy } from '../core/codex-plugins/codex-plugin-json.js';
+import { writeMcpPluginInventoryArtifacts } from '../core/mcp/mcp-plugin-inventory.js';
 export async function run(_command, args = []) {
     const doctorFix = flag(args, '--fix');
     let setupRepair = null;
@@ -167,6 +171,13 @@ export async function run(_command, args = []) {
         : null;
     const { detectImagegenCapability } = await import('../core/imagegen/imagegen-capability.js');
     const imagegen = await detectImagegenCapability({ codexBin: codexBin || undefined }).catch((err) => ({ ok: false, error: err.message, auth_readiness: null }));
+    const codex0138Capability = await writeCodex0138CapabilityArtifacts(root, { codexBin: codexBin || null }).catch((err) => ({ error: err?.message || String(err), report: null }));
+    const codex0138Doctor = await runCodex0138Doctor(root, { fix: doctorFix }).catch((err) => ({ schema: 'sks.codex-0138-doctor.v1', ok: false, error: err?.message || String(err), blockers: ['codex_0138_doctor_exception'], warnings: [] }));
+    const pluginInventory = await writeCodexPluginInventoryArtifacts(root).catch((err) => ({ error: err?.message || String(err), report: null, artifact: null }));
+    const pluginPolicy = pluginInventory?.report ? pluginAppTemplatePolicy(pluginInventory.report) : null;
+    const mcpPluginInventory = pluginInventory?.report
+        ? await writeMcpPluginInventoryArtifacts(root, { inventory: pluginInventory.report }).catch((err) => ({ error: err?.message || String(err), candidates: null }))
+        : null;
     const pkgBytes = await dirSize(root).catch(() => 0);
     const ready = await writeDoctorReadinessMatrix(root, {
         codex,
@@ -180,10 +191,14 @@ export async function run(_command, args = []) {
         agent_role_config: agentRoleConfigRepair,
         repair: configRepair,
         codex_app_ui: codexAppUi,
+        codex_0138_doctor: codex0138Doctor,
+        codex_plugin_inventory: pluginInventory?.report || null,
+        codex_plugin_app_template_policy: pluginPolicy,
         require_codex_cli_config_load: flag(args, '--fix') || flag(args, '--require-actual-codex'),
         operator_actions: [
             ...(codexConfig.operator_actions || []),
-            ...(configRepair?.operator_actions || [])
+            ...(configRepair?.operator_actions || []),
+            ...(pluginPolicy?.doctor_warnings || [])
         ]
     });
     const zellijReadiness = buildZellijReadiness(root, zellij, ready);
@@ -211,6 +226,13 @@ export async function run(_command, args = []) {
             auth_readiness: imagegen.auth_readiness || null,
             codex_app_builtin_available: imagegen.codex_app?.available === true
         },
+        codex_0138: {
+            capability: codex0138Capability.report || null,
+            doctor: codex0138Doctor,
+            plugins: pluginInventory?.report || null,
+            plugin_app_template_policy: pluginPolicy,
+            mcp_plugin_inventory: mcpPluginInventory?.candidates || null
+        },
         ready,
         sneakoscope: { ok: await exists(`${root}/.sneakoscope`) },
         package: { bytes: pkgBytes, human: formatBytes(pkgBytes) },
@@ -262,6 +284,22 @@ export async function run(_command, args = []) {
                 console.log(`  - ${action}`);
         }
     }
+    const codex0138 = codex0138Capability.report || {};
+    console.log('Codex 0.138 features:');
+    console.log(`  /app handoff: ${codex0138.supports_app_handoff ? 'ok' : 'unavailable'}`);
+    console.log(`  plugin JSON: ${codex0138.supports_plugin_json ? 'ok' : 'unavailable'}`);
+    console.log(`  image path exposure: ${codex0138.supports_image_path_exposure ? 'ok' : 'unavailable'}`);
+    console.log(`  OAuth MCP pre-refresh: ${codex0138.supports_oauth_mcp_prerefresh ? 'ok' : 'unavailable'}`);
+    const plugins = pluginInventory?.report?.plugins || [];
+    const remoteMcpCount = plugins.flatMap((plugin) => plugin.remote_mcp_servers || []).length;
+    const unavailableTemplates = pluginPolicy?.unavailable_app_templates?.length || 0;
+    console.log(`Codex plugins: ${pluginInventory?.report ? 'ok' : 'warning'}`);
+    console.log(`  Remote MCP servers: ${remoteMcpCount} candidates`);
+    console.log(`  Unavailable app templates: ${unavailableTemplates}`);
+    for (const warning of pluginPolicy?.doctor_warnings || [])
+        console.log(`  warning: ${warning}`);
+    if (codex0138Doctor?.fixed?.length)
+        console.log(`  doctor --fix repaired: ${codex0138Doctor.fixed.join(', ')}`);
     console.log(`codex-lb:  ${codexLb.ok ? 'ok' : `warning ${codexLb.circuit?.state || 'unknown'}`}`);
     if (localModel) {
         console.log('Local LLM:');

package/dist/core/agents/agent-effort-policy.js

@@ -1,3 +1,4 @@
+import { codexModelEffortCapability } from '../codex-control/codex-model-capabilities.js';
 const XHIGH_SIGNAL_RE = /(frontier|autoresearch|novelty|hypothesis|falsif|forensic|from-chat-img|image\s*work\s*order|새로운\s*연구|가설|포렌식)/i;
 const HIGH_SIGNAL_RE = /(database|supabase|sql|migration|security|permission|mad|release|publish|deploy|architecture|policy|schema|hook|rollback|db|보안|배포|마이그레이션|데이터베이스|권한|릴리즈)/i;
 const MEDIUM_SIGNAL_RE = /(tmux|terminal|cli|tool(?:\s|-)?call|router|routing|orchestrat|pipeline|multi[-\s]?session|multi[-\s]?agent|lease|ledger|proof|검증|파이프라인|오케스트레이션|병렬|에이전트)/i;
@@ -26,6 +27,7 @@ export function decideAgentEffort(input = {}) {
         effort = 'high';
         reason = 'implementation_lane_capped_at_high';
     }
+    const modelCapability = codexModelEffortCapability({ defaultEffort: effort });
     return {
         schema: 'sks.agent-effort-decision.v1',
         policy_version: 1,
@@ -33,6 +35,7 @@ export function decideAgentEffort(input = {}) {
         role,
         reasoning_effort: effort,
         model_reasoning_effort: effort,
+        model_effort_capability: modelCapability,
         reasoning_profile: reasoningProfileName(effort),
         service_tier: 'fast',
         reason,
@@ -73,6 +76,7 @@ export function decideNarutoCloneEffort(input = {}) {
     const writes = !readonly || /write|edit|route-local|workspace|patch|integrat/i.test(writePolicy) || hasActionTool;
     const toolUse = writes || NARUTO_ACTION_TOOL_RE.test(prompt);
     const effort = toolUse ? 'medium' : 'low';
+    const modelCapability = codexModelEffortCapability({ defaultEffort: effort });
     return {
         schema: 'sks.agent-effort-decision.v1',
         policy_version: 1,
@@ -80,6 +84,7 @@ export function decideNarutoCloneEffort(input = {}) {
         role,
         reasoning_effort: effort,
         model_reasoning_effort: effort,
+        model_effort_capability: modelCapability,
         reasoning_profile: reasoningProfileName(effort),
         service_tier: 'fast',
         reason: toolUse ? 'naruto_tool_use_medium' : 'naruto_simple_no_tool_low',
@@ -107,7 +112,8 @@ export function buildAgentEffortPolicy(roster = {}) {
         policy_version: 1,
         dynamic: true,
         service_tier: 'fast',
-        allowed_efforts: ['low', 'medium', 'high', 'xhigh'],
+        allowed_efforts: codexModelEffortCapability().advertised_efforts,
+        model_effort_capability: codexModelEffortCapability(),
         max_agents: roster.max_agents || 20,
         agent_count: roster.agent_count || decisions.length,
         concurrency: roster.concurrency || decisions.length,

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');