sneakoscope 2.0.17 → 3.0.0

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/agents/agent-scheduler.js

@@ -144,30 +144,38 @@ export async function runAgentScheduler(input) {
                 batch_id: batchId,
                 meta: { launch_count: launches.length, active_count_before: active.size }
             }).catch(() => undefined);
+            // Telemetry appends run concurrently across launches (per-slot ordering
+            // preserved inside each async chain). Awaiting these file writes in
+            // series before each dispatch serialized worker launch by 2 disk writes
+            // per slot — with 20 slots that is 40 sequential appends before the last
+            // worker even started.
+            const dispatchTelemetryWrites = [];
             for (const launch of launches) {
                 const { slot, openedSlot, generation, agent, workItem } = launch;
-                await appendParallelRuntimeEvent(input.root, input.missionId, {
-                    event_type: 'slot_reserved',
-                    slot_id: slot.slot_id,
-                    generation_index: generation.generation_index,
-                    session_id: generation.session_id,
-                    pid: null,
-                    backend: 'scheduler',
-                    placement: 'unknown',
-                    batch_id: batchId,
-                    meta: { work_item_id: workItem.id }
-                }).catch(() => undefined);
-                await appendParallelRuntimeEvent(input.root, input.missionId, {
-                    event_type: 'worker_launch_invoked',
-                    slot_id: slot.slot_id,
-                    generation_index: generation.generation_index,
-                    session_id: generation.session_id,
-                    pid: null,
-                    backend: 'scheduler',
-                    placement: 'unknown',
-                    batch_id: batchId,
-                    meta: { work_item_id: workItem.id }
-                }).catch(() => undefined);
+                dispatchTelemetryWrites.push((async () => {
+                    await appendParallelRuntimeEvent(input.root, input.missionId, {
+                        event_type: 'slot_reserved',
+                        slot_id: slot.slot_id,
+                        generation_index: generation.generation_index,
+                        session_id: generation.session_id,
+                        pid: null,
+                        backend: 'scheduler',
+                        placement: 'unknown',
+                        batch_id: batchId,
+                        meta: { work_item_id: workItem.id }
+                    }).catch(() => undefined);
+                    await appendParallelRuntimeEvent(input.root, input.missionId, {
+                        event_type: 'worker_launch_invoked',
+                        slot_id: slot.slot_id,
+                        generation_index: generation.generation_index,
+                        session_id: generation.session_id,
+                        pid: null,
+                        backend: 'scheduler',
+                        placement: 'unknown',
+                        batch_id: batchId,
+                        meta: { work_item_id: workItem.id }
+                    }).catch(() => undefined);
+                })());
                 const promise = Promise.resolve()
                     .then(() => input.launchSession({ agent, workItem, generation, slot: openedSlot, queue, state }))
                     .then((result) => ({
@@ -212,14 +220,14 @@ export async function runAgentScheduler(input) {
                 accumulateActiveSlotTime();
                 active.set(generation.session_id, { slot_id: slot.slot_id, work_item_id: workItem.id, session_id: generation.session_id, promise });
             }
+            await Promise.all(dispatchTelemetryWrites);
             await appendAgentWorkQueueEvent(input.root, 'batch_work_items_dispatched', {
                 batch_id: batchId,
                 launch_count: launches.length,
                 session_ids: launches.map((launch) => launch.generation.session_id),
                 work_item_ids: launches.map((launch) => launch.workItem.id)
             });
-            for (const launch of launches)
-                await appendAgentWorkQueueEvent(input.root, 'work_item_dispatched', { work_item_id: launch.workItem.id, session_id: launch.generation.session_id, slot_id: launch.slot.slot_id });
+            await Promise.all(launches.map((launch) => appendAgentWorkQueueEvent(input.root, 'work_item_dispatched', { work_item_id: launch.workItem.id, session_id: launch.generation.session_id, slot_id: launch.slot.slot_id })));
             if (backfill) {
                 const firstLaunch = launches[0];
                 const refillLatencyMs = Math.max(0, Date.now() - backfill.closed_at_ms);

package/dist/core/agents/native-cli-session-swarm.js

@@ -11,6 +11,7 @@ import { buildZellijSlotPaneCommand } from '../zellij/zellij-slot-pane-renderer.
 import { resolveZellijWorkerPaneUiMode } from '../zellij/zellij-ui-mode.js';
 import { appendZellijSlotTelemetry } from '../zellij/zellij-slot-telemetry.js';
 import { appendParallelRuntimeEvent } from './parallel-runtime-proof.js';
+import { appendAgentMessage } from './agent-message-bus.js';
 export const NATIVE_CLI_SESSION_SWARM_SCHEMA = 'sks.agent-native-cli-session-swarm.v1';
 export function createNativeCliSessionSwarmRecorder(root, input) {
     return new NativeCliSessionSwarmRecorder(root, input);
@@ -625,6 +626,15 @@ class NativeCliSessionSwarmRecorder {
             log_tail: input.logTail || '',
             blockers: input.blockers || []
         }).catch(() => undefined);
+        if (input.eventType === 'worker_completed' || input.eventType === 'worker_failed') {
+            await appendAgentMessage(this.root, {
+                from: String(ctx.agent?.slot_id || ctx.agent?.id || 'worker'),
+                session_id: ctx.agent?.session_id == null ? '' : String(ctx.agent.session_id),
+                to: 'orchestrator',
+                type: input.eventType,
+                body: input.logTail || input.eventType
+            }).catch(() => undefined);
+        }
         const parallelEvent = mapTelemetryToParallelEvent(input.eventType);
         if (parallelEvent) {
             await appendParallelRuntimeEvent(this.root, this.input.missionId, {
@@ -653,6 +663,12 @@ class NativeCliSessionSwarmRecorder {
     summary() {
         const closed = this.records.filter((row) => row.status === 'closed');
         const processIds = this.records.map((row) => row.pid).filter((pid) => Number.isFinite(Number(pid)));
+        // Both pane-backed primitives count as zellij pane worker sessions: the
+        // worker command can run inside the pane (full-debug) or headless behind a
+        // live slot renderer pane (compact-slots default). Counting only the
+        // former under-reported pane sessions as 0 in the default UI mode.
+        const paneBackedRecords = this.records.filter((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane'
+            || row.scaling_primitive === 'native_cli_process_with_zellij_slot_renderer');
         return {
             schema: NATIVE_CLI_SESSION_SWARM_SCHEMA,
             generated_at: nowIso(),
@@ -660,8 +676,12 @@ class NativeCliSessionSwarmRecorder {
             mission_id: this.input.missionId,
             route: this.input.route,
             backend: this.input.backend,
-            scaling_primitive: this.records.some((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane') ? 'native_cli_process_in_zellij_worker_pane' : 'native_cli_process',
-            zellij_pane_worker_sessions: this.records.filter((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane').length,
+            scaling_primitive: this.records.some((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane')
+                ? 'native_cli_process_in_zellij_worker_pane'
+                : paneBackedRecords.length
+                    ? 'native_cli_process_with_zellij_slot_renderer'
+                    : 'native_cli_process',
+            zellij_pane_worker_sessions: paneBackedRecords.length,
             requested_agents: this.input.requestedAgents,
             target_active_slots: this.input.targetActiveSlots,
             spawned_worker_process_count: this.records.length,

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

@@ -0,0 +1,98 @@
+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',
+        `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 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');
+    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 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'
+        : 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 ? status !== 'blocked_for_desktop_review' : true,
+        attempted: launchAttempt.attempted,
+        launched: launchAttempt.launched,
+        status,
+        codex_0138_capability: capability,
+        command_line: launchAttempt.command_line,
+        launch_attempt: launchAttempt,
+        confirmation_required: request.require_desktop,
+        desktop_handoff_supported: desktopSupported,
+        fallback_reason: desktopSupported
+            ? launchAttempt.fallback_reason || 'desktop_handoff_pending_operator_confirmation'
+            : blockers.join(';') || null,
+        artifact_path: artifactPath,
+        prompt_artifact_path: promptArtifactPath,
+        blockers: request.require_desktop ? [...blockers, ...(status === 'blocked_for_desktop_review' ? launchAttempt.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-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

@@ -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 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 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']),
+        ...(probeMode === 'feature-probe' && featureProbeResults.plugin_json === 'failed' ? ['codex_plugin_json_probe_failed'] : [])
+    ];
+    return {
+        schema: 'sks.codex-0138-capability.v1',
+        ok: atLeast138 && blockers.length === 0,
+        probe_mode: probeMode,
+        codex_bin: codexBin || null,
+        version_text: versionText || null,
+        parsed_version: parsed,
+        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
+    };
+}
+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;
+}
+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

@@ -0,0 +1,62 @@
+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 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 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.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',
+        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();
+    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-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-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]',