sneakoscope 2.0.4 → 2.0.6

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

@@ -1,5 +1,6 @@
+import fs from 'node:fs';
 import path from 'node:path';
-import { appendJsonl, ensureDir, nowIso, writeJsonAtomic } from '../fsx.js';
+import { appendJsonl, ensureDir, nowIso, packageRoot, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { validateJsonSchemaRecursive } from '../json-schema-validator.js';
 import { resolveCodexOutputSchema } from './codex-output-schemas.js';
 import { detectCodexSdkCapability } from './codex-sdk-capability.js';
@@ -12,6 +13,9 @@ import { recordCodexThread } from './codex-thread-registry.js';
 import { runWithCodexReliabilityShield } from './codex-reliability-shield.js';
 import { routeCodexTask } from '../router/ultra-router.js';
 import { writeUltraRouterProof } from '../router/router-proof.js';
+import { readLocalModelConfig } from '../agents/ollama-worker-config.js';
+import { runLocalLlmTask } from '../local-llm/local-llm-control-adapter.js';
+import { detectPythonCodexSdkCapability, runPythonCodexSdkTask } from './python-codex-sdk-adapter.js';
 export async function runCodexTask(input) {
     const root = path.resolve(input.mutationLedgerRoot);
     await ensureDir(root);
@@ -19,13 +23,22 @@ export async function runCodexTask(input) {
     const routerDecision = routeCodexTask(input);
     const task = { ...input, tier: input.tier || routerDecision.tier, outputSchema: schema };
     await writeUltraRouterProof(root, { task, decision: routerDecision });
+    const selectedBackend = selectCodexControlBackend(task, routerDecision);
+    if (selectedBackend === 'local-llm')
+        return runLocalControlTask(root, task, schema, routerDecision);
+    if (selectedBackend === 'python-codex-sdk')
+        return runPythonControlTask(root, task, schema, routerDecision);
     const capability = await detectCodexSdkCapability();
     const sandbox = mapCodexSdkSandboxPolicy(task);
     const runtime = codexSdkRuntimePolicies(task);
+    const bundledCodex = resolveBundledCodexBinary();
+    if (bundledCodex && !runtime.env.env.SKS_PYTHON_CODEX_SDK_CODEX_BIN)
+        runtime.env.env.SKS_PYTHON_CODEX_SDK_CODEX_BIN = bundledCodex;
     if (runtime.env.env.HOME)
         await ensureDir(runtime.env.env.HOME);
     if (runtime.env.env.CODEX_HOME)
         await ensureDir(runtime.env.env.CODEX_HOME);
+    await ensurePythonCodexLbConfig(runtime.env.env, runtime.config);
     const fakeAllowed = fakeCodexSdkAllowed();
     const blockers = [
         ...(capability.ok || fakeAllowed ? [] : capability.blockers),
@@ -84,6 +97,7 @@ export async function runCodexTask(input) {
     const result = {
         ok: finalBlockers.length === 0,
         backend: 'codex-sdk',
+        backend_family: fakeAllowed ? 'fake' : 'remote-gpt',
         sdkThreadId: String(adapterResult?.sdkThreadId || ''),
         sdkRunId: adapterResult?.sdkRunId ? String(adapterResult.sdkRunId) : null,
         streamEventCount: events.length,
@@ -99,6 +113,8 @@ export async function runCodexTask(input) {
         translatedEventCount: translatedEvents.length
     };
     await recordCodexThread(root, {
+        backend: result.backend,
+        backend_family: result.backend_family,
         route: task.route,
         mission_id: task.missionId,
         work_item_id: task.workItemId || null,
@@ -126,7 +142,213 @@ export async function runCodexTask(input) {
     });
     return result;
 }
-function normalizeWorkerResult(value, input, blockers, structuredOutputValid) {
+async function runPythonControlTask(root, task, schema, routerDecision) {
+    const capability = await detectPythonCodexSdkCapability();
+    const runtime = codexSdkRuntimePolicies(task);
+    if (runtime.env.env.HOME)
+        await ensureDir(runtime.env.env.HOME);
+    if (runtime.env.env.CODEX_HOME)
+        await ensureDir(runtime.env.env.CODEX_HOME);
+    const fakeAllowed = process.env.SKS_PYTHON_CODEX_SDK_FAKE === '1';
+    const adapterResult = capability.ok || fakeAllowed
+        ? await runPythonCodexSdkTask(task, { env: runtime.env.env, config: runtime.config })
+        : { ok: false, events: [], translatedEvents: [], finalResponse: '', threadId: '', turnId: '', blockers: capability.blockers, capability };
+    const events = Array.isArray(adapterResult.events) ? adapterResult.events : [];
+    const translatedEvents = Array.isArray(adapterResult.translatedEvents) ? adapterResult.translatedEvents : [];
+    for (const event of translatedEvents)
+        await appendJsonl(path.join(root, 'python-codex-sdk-events.jsonl'), event);
+    const structuredOutput = parseStructuredOutput(adapterResult.finalResponse || '');
+    const validation = structuredOutput ? validateJsonSchemaRecursive(structuredOutput, schema) : { ok: false, issues: ['structured_output_missing'] };
+    const finalBlockers = [
+        ...(adapterResult.blockers || []),
+        ...(events.length > 0 ? [] : ['python_codex_sdk_event_stream_missing']),
+        ...(validation.ok ? [] : ['python_codex_sdk_structured_output_invalid', ...validation.issues.map((issue) => `schema:${issue}`)])
+    ];
+    const workerResult = normalizeWorkerResult(structuredOutput, task, finalBlockers, validation.ok, 'python-codex-sdk');
+    const workerResultPath = path.join(root, 'python-codex-sdk-worker-result.json');
+    await writeJsonAtomic(workerResultPath, workerResult);
+    const patchEnvelopePath = Array.isArray(workerResult.patch_envelopes) && workerResult.patch_envelopes.length
+        ? path.join(root, 'python-codex-sdk-patch-envelope.json')
+        : null;
+    if (patchEnvelopePath) {
+        await writeJsonAtomic(patchEnvelopePath, {
+            schema: 'sks.python-codex-sdk-patch-envelope.v1',
+            generated_at: nowIso(),
+            ok: true,
+            envelope_count: workerResult.patch_envelopes.length,
+            envelopes: workerResult.patch_envelopes
+        });
+    }
+    const pythonSdkProofPath = path.join(root, 'python-codex-sdk-proof.json');
+    await writeJsonAtomic(pythonSdkProofPath, {
+        schema: 'sks.python-codex-sdk-proof.v1',
+        generated_at: nowIso(),
+        ok: finalBlockers.length === 0,
+        backend: 'python-codex-sdk',
+        backend_family: fakeAllowed ? 'fake' : 'python-sdk',
+        package_name: capability.package_name,
+        import_name: capability.import_name,
+        python_bin: capability.python_bin,
+        python_version: capability.python_version,
+        sandbox: task.sandboxPolicy,
+        thread_id: adapterResult.threadId || '',
+        turn_id: adapterResult.turnId || '',
+        stream_event_count: events.length,
+        structured_output_valid: validation.ok,
+        worker_result_path: workerResultPath,
+        blockers: finalBlockers
+    });
+    const result = {
+        ok: finalBlockers.length === 0,
+        backend: 'python-codex-sdk',
+        backend_family: fakeAllowed ? 'fake' : 'python-sdk',
+        sdkThreadId: String(adapterResult.threadId || ''),
+        sdkRunId: adapterResult.turnId ? String(adapterResult.turnId) : null,
+        streamEventCount: events.length,
+        structuredOutputValid: validation.ok,
+        workerResultPath,
+        patchEnvelopePath,
+        pythonSdkProofPath,
+        blockers: finalBlockers,
+        reliabilityShield: {},
+        ultraRouterDecision: routerDecision,
+        outputSchemaId: task.outputSchemaId,
+        finalResponse: adapterResult.finalResponse || '',
+        eventTypes: events.map((event) => String(event?.event || event?.type || 'unknown')),
+        translatedEventCount: translatedEvents.length
+    };
+    await recordCodexThread(root, {
+        backend: result.backend,
+        backend_family: result.backend_family,
+        route: task.route,
+        mission_id: task.missionId,
+        work_item_id: task.workItemId || null,
+        slot_id: task.slotId || null,
+        generation_index: task.generationIndex ?? null,
+        session_id: task.sessionId || null,
+        zellij_pane_id: task.zellijPaneId || null,
+        sdk_thread_id: result.sdkThreadId,
+        sdk_run_id: result.sdkRunId,
+        stream_event_count: result.streamEventCount,
+        output_schema_id: task.outputSchemaId,
+        structured_output_valid: result.structuredOutputValid,
+        worker_result_path: result.workerResultPath
+    });
+    await writeCodexControlProof(root, {
+        task,
+        result,
+        capability: capability,
+        sandbox: { ok: true, sandbox_policy: task.sandboxPolicy, python_sandbox: mapPythonSandbox(task.sandboxPolicy), blockers: [] },
+        envProof: { ...runtime.env.proof, python_bin: capability.python_bin, python_version: capability.python_version },
+        config: { ...runtime.config, backend: 'python-codex-sdk', package_name: capability.package_name, import_name: capability.import_name },
+        reliabilityShield: null,
+        routerDecision: routerDecision,
+        translatedEvents
+    });
+    return result;
+}
+async function runLocalControlTask(root, task, schema, routerDecision) {
+    const config = await readLocalModelConfig();
+    const adapterResult = await runLocalLlmTask(task, { config, outputSchema: schema });
+    for (const event of adapterResult.events || [])
+        await appendJsonl(path.join(root, 'local-llm-events.jsonl'), event);
+    const structuredOutput = adapterResult.structuredOutput;
+    const validation = structuredOutput ? validateJsonSchemaRecursive(structuredOutput, schema) : { ok: false, issues: ['structured_output_missing'] };
+    const finalBlockers = [
+        ...(adapterResult.blockers || []),
+        ...(Array.isArray(adapterResult.events) && adapterResult.events.length > 0 ? [] : ['local_llm_event_stream_missing']),
+        ...(validation.ok ? [] : ['local_llm_structured_output_invalid', ...validation.issues.map((issue) => `schema:${issue}`)])
+    ];
+    const workerResult = normalizeWorkerResult(structuredOutput, task, finalBlockers, validation.ok, 'local-llm');
+    const workerResultPath = path.join(root, 'local-llm-worker-result.json');
+    await writeJsonAtomic(workerResultPath, workerResult);
+    const patchEnvelopePath = Array.isArray(workerResult.patch_envelopes) && workerResult.patch_envelopes.length
+        ? path.join(root, 'local-llm-patch-envelope.json')
+        : null;
+    if (patchEnvelopePath) {
+        await writeJsonAtomic(patchEnvelopePath, {
+            schema: 'sks.local-llm-patch-envelope.v1',
+            generated_at: nowIso(),
+            ok: true,
+            envelope_count: workerResult.patch_envelopes.length,
+            envelopes: workerResult.patch_envelopes,
+            requires_gpt_final: true
+        });
+    }
+    const localLlmProofPath = path.join(root, 'local-llm-proof.json');
+    await writeJsonAtomic(localLlmProofPath, adapterResult.proof);
+    const result = {
+        ok: finalBlockers.length === 0,
+        backend: 'local-llm',
+        backend_family: 'local-llm',
+        sdkThreadId: '',
+        sdkRunId: null,
+        streamEventCount: adapterResult.events?.length || 0,
+        structuredOutputValid: validation.ok,
+        workerResultPath,
+        patchEnvelopePath,
+        localLlmProofPath,
+        blockers: finalBlockers,
+        reliabilityShield: {},
+        ultraRouterDecision: routerDecision,
+        outputSchemaId: task.outputSchemaId,
+        finalResponse: adapterResult.finalResponse || '',
+        eventTypes: (adapterResult.events || []).map((event) => String(event?.type || 'unknown')),
+        translatedEventCount: adapterResult.events?.length || 0,
+        localLlmRequestId: adapterResult.requestId
+    };
+    await recordCodexThread(root, {
+        backend: result.backend,
+        backend_family: result.backend_family,
+        route: task.route,
+        mission_id: task.missionId,
+        work_item_id: task.workItemId || null,
+        slot_id: task.slotId || null,
+        generation_index: task.generationIndex ?? null,
+        session_id: task.sessionId || null,
+        zellij_pane_id: task.zellijPaneId || null,
+        sdk_thread_id: null,
+        sdk_run_id: null,
+        local_llm_request_id: adapterResult.requestId,
+        stream_event_count: result.streamEventCount,
+        output_schema_id: task.outputSchemaId,
+        structured_output_valid: result.structuredOutputValid,
+        worker_result_path: result.workerResultPath
+    });
+    await writeCodexControlProof(root, {
+        task,
+        result,
+        capability: config.capability,
+        sandbox: { ok: task.sandboxPolicy !== 'full-access', sandbox_policy: task.sandboxPolicy, blockers: task.sandboxPolicy === 'full-access' ? ['local_llm_full_access_blocked'] : [] },
+        envProof: { provider: config.provider, endpoint: config.base_url },
+        config: { provider: config.provider, model: config.model, endpoint: config.base_url, status: config.status },
+        reliabilityShield: null,
+        routerDecision: routerDecision,
+        translatedEvents: adapterResult.events || []
+    });
+    return result;
+}
+function selectCodexControlBackend(input, routerDecision) {
+    const prefs = Array.isArray(input.backendPreference) ? input.backendPreference : [];
+    for (const pref of prefs) {
+        if (pref === 'python-codex-sdk')
+            return 'python-codex-sdk';
+        if (pref === 'codex-sdk')
+            return 'codex-sdk';
+        if (pref === 'local-llm' && input.tier === 'worker')
+            return 'local-llm';
+    }
+    if (input.localLlmPolicy?.mode === 'disabled')
+        return 'codex-sdk';
+    if (input.allowLocalLlm === true && input.tier === 'worker' && routerDecision?.selected_profile === 'local-llm-worker')
+        return 'local-llm';
+    if (input.allowLocalLlm === true && input.tier === 'worker' && input.localLlmPolicy?.mode === 'local_only')
+        return 'local-llm';
+    if (input.allowLocalLlm === true && input.tier === 'worker' && input.localLlmPolicy?.mode === 'local_preferred')
+        return 'local-llm';
+    return 'codex-sdk';
+}
+function normalizeWorkerResult(value, input, blockers, structuredOutputValid, backend = 'codex-sdk') {
     const status = blockers.length ? 'blocked' : normalizeStatus(value?.status);
     return {
         ...value,
@@ -135,9 +357,9 @@ function normalizeWorkerResult(value, input, blockers, structuredOutputValid) {
         session_id: String(value?.session_id || input.sessionId || input.workItemId || 'codex-sdk-session'),
         persona_id: String(value?.persona_id || value?.agent_id || input.slotId || 'codex-sdk-worker'),
         task_slice_id: String(value?.task_slice_id || input.workItemId || ''),
-        backend: 'codex-sdk',
+        backend,
         status,
-        summary: String(value?.summary || (blockers.length ? 'Codex SDK task blocked.' : 'Codex SDK task completed.')),
+        summary: String(value?.summary || (blockers.length ? `${backend} task blocked.` : `${backend} task completed.`)),
         findings: Array.isArray(value?.findings) ? value.findings : [],
         proposed_changes: Array.isArray(value?.proposed_changes) ? value.proposed_changes : [],
         changed_files: Array.isArray(value?.changed_files) ? value.changed_files : [],
@@ -145,7 +367,7 @@ function normalizeWorkerResult(value, input, blockers, structuredOutputValid) {
         artifacts: Array.isArray(value?.artifacts) ? value.artifacts : [],
         blockers,
         confidence: String(value?.confidence || (structuredOutputValid ? 'verified_partial' : 'blocked')),
-        handoff_notes: String(value?.handoff_notes || 'Codex SDK Control Plane produced this worker result.'),
+        handoff_notes: String(value?.handoff_notes || `${backend} Control Plane produced this worker result.`),
         unverified: Array.isArray(value?.unverified) ? value.unverified : [],
         writes: Array.isArray(value?.writes) ? value.writes : [],
         patch_envelopes: Array.isArray(value?.patch_envelopes) ? value.patch_envelopes : [],
@@ -157,4 +379,106 @@ function normalizeWorkerResult(value, input, blockers, structuredOutputValid) {
 function normalizeStatus(value) {
     return value === 'failed' || value === 'blocked' || value === 'done' ? value : 'done';
 }
+function mapPythonSandbox(value) {
+    if (value === 'workspace-write')
+        return 'workspace_write';
+    if (value === 'full-access')
+        return 'full_access';
+    return 'read_only';
+}
+function parseStructuredOutput(text) {
+    const trimmed = String(text || '').trim();
+    if (!trimmed)
+        return null;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        const start = trimmed.indexOf('{');
+        const end = trimmed.lastIndexOf('}');
+        if (start >= 0 && end > start) {
+            try {
+                return JSON.parse(trimmed.slice(start, end + 1));
+            }
+            catch { }
+        }
+        return null;
+    }
+}
+async function ensurePythonCodexLbConfig(env, config) {
+    const codexHome = env.CODEX_HOME;
+    const lbBaseUrl = normalizeCodexLbBaseUrl(env.CODEX_LB_BASE_URL);
+    if (!codexHome || !lbBaseUrl || !env.CODEX_LB_API_KEY)
+        return;
+    const model = String(config.model || env.SKS_CODEX_MODEL || env.CODEX_MODEL || 'gpt-5.5');
+    const text = [
+        `model = ${tomlQuote(model)}`,
+        'model_provider = "codex-lb"',
+        'service_tier = "fast"',
+        'model_reasoning_effort = "minimal"',
+        'approval_policy = "never"',
+        '',
+        '[model_providers.codex-lb]',
+        'name = "OpenAI"',
+        `base_url = ${tomlQuote(lbBaseUrl)}`,
+        'wire_api = "responses"',
+        'env_key = "CODEX_LB_API_KEY"',
+        'supports_websockets = true',
+        'requires_openai_auth = false',
+        ''
+    ].join('\n');
+    await writeTextAtomic(path.join(codexHome, 'config.toml'), text);
+}
+function normalizeCodexLbBaseUrl(value) {
+    let host = String(value || '').trim();
+    if (!host)
+        return '';
+    if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(host))
+        host = `https://${host}`;
+    host = host.replace(/\/+$/, '');
+    return /\/backend-api\/codex$/i.test(host) ? host : `${host}/backend-api/codex`;
+}
+function tomlQuote(value) {
+    return JSON.stringify(value);
+}
+function resolveBundledCodexBinary() {
+    const platform = process.platform;
+    const arch = process.arch;
+    const pkg = platform === 'darwin' && arch === 'arm64'
+        ? '@openai/codex-darwin-arm64'
+        : platform === 'darwin' && arch === 'x64'
+            ? '@openai/codex-darwin-x64'
+            : platform === 'linux' && arch === 'arm64'
+                ? '@openai/codex-linux-arm64'
+                : platform === 'linux' && arch === 'x64'
+                    ? '@openai/codex-linux-x64'
+                    : platform === 'win32' && arch === 'x64'
+                        ? '@openai/codex-win32-x64'
+                        : platform === 'win32' && arch === 'arm64'
+                            ? '@openai/codex-win32-arm64'
+                            : '';
+    if (!pkg)
+        return '';
+    const binary = platform === 'win32' ? 'codex.exe' : 'codex';
+    const candidates = [
+        path.join(packageRoot(), 'node_modules', pkg, 'vendor', nativeTargetTriple(platform, arch), 'bin', binary),
+        path.join(packageRoot(), 'node_modules', pkg, 'vendor', nativeTargetTriple(platform, arch), 'codex', binary)
+    ];
+    return candidates.find((candidate) => fs.existsSync(candidate)) || '';
+}
+function nativeTargetTriple(platform, arch) {
+    if (platform === 'darwin' && arch === 'arm64')
+        return 'aarch64-apple-darwin';
+    if (platform === 'darwin' && arch === 'x64')
+        return 'x86_64-apple-darwin';
+    if (platform === 'linux' && arch === 'arm64')
+        return 'aarch64-unknown-linux-musl';
+    if (platform === 'linux' && arch === 'x64')
+        return 'x86_64-unknown-linux-musl';
+    if (platform === 'win32' && arch === 'arm64')
+        return 'aarch64-pc-windows-msvc';
+    if (platform === 'win32' && arch === 'x64')
+        return 'x86_64-pc-windows-msvc';
+    return '';
+}
 //# sourceMappingURL=codex-task-runner.js.map

package/dist/core/codex-control/python-codex-sdk-adapter.js

@@ -0,0 +1,197 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { packageRoot, runProcess, which } from '../fsx.js';
+import { translatePythonCodexSdkEvents } from './python-codex-sdk-event-translator.js';
+export async function detectPythonCodexSdkCapability() {
+    const python = await resolvePythonCodexSdkPython();
+    if (!python.path)
+        return capability(false, null, '', ['python_missing'], null, 'Install Python >= 3.10 and install the Codex Python SDK.');
+    const pyOk = parsePythonVersion(python.versionText) >= 3.10;
+    const probes = [];
+    let detected = null;
+    if (pyOk) {
+        for (const candidate of PYTHON_CODEX_SDK_CANDIDATES) {
+            const importProbe = await runProcess(python.path, ['-c', `import ${candidate.importName}; print("ok")`], { timeoutMs: 5000, maxOutputBytes: 4096 })
+                .catch((err) => ({ code: 1, stdout: '', stderr: err.message || String(err) }));
+            probes.push({
+                package_name: candidate.packageName,
+                import_name: candidate.importName,
+                ok: importProbe.code === 0,
+                stderr: String(importProbe.stderr || '').slice(-500)
+            });
+            if (importProbe.code === 0) {
+                detected = candidate;
+                break;
+            }
+        }
+    }
+    const blockers = [
+        ...(pyOk ? [] : ['python_version_below_3_10']),
+        ...(detected ? [] : ['python_codex_sdk_unavailable'])
+    ];
+    return capability(blockers.length === 0, python.path, python.versionText, blockers, detected, blockers.length ? setupAction(python.path) : null, probes);
+}
+export async function runPythonCodexSdkTask(input, opts = {}) {
+    const cap = await detectPythonCodexSdkCapability();
+    if (!cap.ok && process.env.SKS_PYTHON_CODEX_SDK_FAKE !== '1') {
+        return { ok: false, events: [], translatedEvents: [], finalResponse: '', blockers: cap.blockers, capability: cap };
+    }
+    const python = opts.pythonBin || cap.python_bin || await which('python3') || 'python3';
+    const request = {
+        schema: 'sks.python-codex-sdk-request.v1',
+        route: input.route,
+        thread_policy: input.requestedScopeContract?.resume_thread_id ? 'resume' : 'new',
+        sandbox: mapSandbox(input.sandboxPolicy),
+        cwd: input.cwd,
+        model: typeof opts.config?.model === 'string' ? opts.config.model : '',
+        model_reasoning_effort: typeof opts.config?.model_reasoning_effort === 'string' ? opts.config.model_reasoning_effort : 'minimal',
+        prompt: input.prompt,
+        output_schema: input.outputSchema || {}
+    };
+    const events = await runPythonRunner(python, request, opts.env);
+    const translatedEvents = translatePythonCodexSdkEvents(events);
+    const last = [...events].reverse().find((event) => event?.event === 'turn_completed');
+    const errors = events.filter((event) => event?.event === 'error').map((event) => String(event.message || 'python_codex_sdk_error'));
+    return {
+        ok: errors.length === 0 && Boolean(last),
+        events,
+        translatedEvents,
+        finalResponse: String(last?.final_response || ''),
+        threadId: String(events.find((event) => event?.thread_id)?.thread_id || ''),
+        turnId: String(last?.turn_id || ''),
+        blockers: errors,
+        capability: cap
+    };
+}
+function runPythonRunner(python, request, envOverride) {
+    const runner = path.join(packageRoot(), 'pytools', 'codex_sdk_runner.py');
+    return new Promise((resolve, reject) => {
+        const child = spawn(python, [runner], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: envOverride ? { ...process.env, ...envOverride } : process.env,
+            detached: process.platform !== 'win32'
+        });
+        const events = [];
+        let stderr = '';
+        let timedOut = false;
+        const timeoutMs = Number(process.env.SKS_PYTHON_CODEX_SDK_TIMEOUT_MS || 120000);
+        const timer = setTimeout(() => {
+            timedOut = true;
+            events.push({ event: 'error', retryable: true, message: `python_codex_sdk_timeout:${timeoutMs}` });
+            terminatePythonRunner(child);
+        }, timeoutMs);
+        timer.unref?.();
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            for (const line of String(chunk).split(/\n/).filter(Boolean)) {
+                try {
+                    events.push(JSON.parse(line));
+                }
+                catch {
+                    events.push({ event: 'error', retryable: false, message: `invalid_python_jsonl:${line.slice(0, 200)}` });
+                }
+            }
+        });
+        child.stderr.on('data', (chunk) => { stderr += String(chunk); });
+        child.on('error', reject);
+        child.on('close', () => {
+            clearTimeout(timer);
+            if (stderr.trim())
+                events.push({ event: 'stderr', message: stderr.slice(-1000) });
+            if (timedOut && !events.some((event) => String(event?.message || '').startsWith('python_codex_sdk_timeout:'))) {
+                events.push({ event: 'error', retryable: true, message: `python_codex_sdk_timeout:${timeoutMs}` });
+            }
+            resolve(events);
+        });
+        child.stdin.end(JSON.stringify(request));
+    });
+}
+function terminatePythonRunner(child) {
+    if (!child.pid)
+        return;
+    try {
+        if (process.platform !== 'win32')
+            process.kill(-child.pid, 'SIGTERM');
+        else
+            child.kill('SIGTERM');
+    }
+    catch {
+        try {
+            child.kill('SIGTERM');
+        }
+        catch { }
+    }
+    setTimeout(() => {
+        try {
+            if (process.platform !== 'win32')
+                process.kill(-child.pid, 'SIGKILL');
+            else
+                child.kill('SIGKILL');
+        }
+        catch { }
+    }, 5000).unref?.();
+}
+function mapSandbox(value) {
+    if (value === 'workspace-write')
+        return 'workspace_write';
+    if (value === 'full-access')
+        return 'full_access';
+    return 'read_only';
+}
+function parsePythonVersion(text) {
+    const match = text.match(/Python\s+(\d+)\.(\d+)/i);
+    return match ? Number(`${match[1]}.${match[2]}`) : 0;
+}
+async function resolvePythonCodexSdkPython() {
+    const requested = [
+        process.env.SKS_PYTHON_CODEX_SDK_PYTHON,
+        process.env.PYTHON
+    ].filter((value) => Boolean(value && value.trim()));
+    const candidates = [...requested, 'python3.12', 'python3.11', 'python3.10', 'python3', 'python'];
+    const seen = new Set();
+    const probes = [];
+    for (const candidate of candidates) {
+        const resolved = candidate.includes('/') ? candidate : await which(candidate);
+        if (!resolved || seen.has(resolved))
+            continue;
+        seen.add(resolved);
+        const version = await runProcess(resolved, ['--version'], { timeoutMs: 5000, maxOutputBytes: 4096 })
+            .catch((err) => ({ code: 1, stdout: '', stderr: err.message || String(err) }));
+        const versionText = `${version.stdout || ''}${version.stderr || ''}`.trim();
+        probes.push({ path: resolved, versionText, score: parsePythonVersion(versionText) });
+    }
+    const supported = probes.find((probe) => probe.score >= 3.10);
+    return supported || probes[0] || { path: null, versionText: '' };
+}
+const PYTHON_CODEX_SDK_CANDIDATES = [
+    { packageName: 'codex-app-server', importName: 'codex_app_server', source: 'developers.openai.com/codex/sdk' },
+    { packageName: 'openai-codex', importName: 'openai_codex', source: 'sks-2.0.5-directive' },
+    { packageName: 'openai-codex-sdk', importName: 'openai_codex_sdk', source: 'pypi-wheel' }
+];
+function setupAction(pythonBin) {
+    return [
+        `Install the current Codex Python SDK in \`${pythonBin}\`.`,
+        'Preferred official source install: from the Codex repository root run `cd sdk/python && python -m pip install -e .`.',
+        `If using the published wrapper package, run \`${pythonBin} -m pip install openai-codex-sdk\`.`,
+        `If your environment provides the directive package, run \`${pythonBin} -m pip install openai-codex\`.`
+    ].join(' ');
+}
+function capability(ok, pythonBin, versionText, blockers, detected, setupActionValue, probes = []) {
+    const selected = detected || PYTHON_CODEX_SDK_CANDIDATES[0] || { packageName: 'codex-app-server', importName: 'codex_app_server', source: 'developers.openai.com/codex/sdk' };
+    return {
+        schema: 'sks.python-codex-sdk-capability.v1',
+        ok,
+        python_bin: pythonBin,
+        python_version: versionText,
+        package_name: selected.packageName,
+        import_name: selected.importName,
+        source: selected.source,
+        supported_packages: PYTHON_CODEX_SDK_CANDIDATES.map((candidate) => candidate.packageName),
+        supported_imports: PYTHON_CODEX_SDK_CANDIDATES.map((candidate) => candidate.importName),
+        import_probes: probes,
+        setup_action: setupActionValue,
+        blockers
+    };
+}
+//# sourceMappingURL=python-codex-sdk-adapter.js.map

package/dist/core/codex-control/python-codex-sdk-event-translator.js

@@ -0,0 +1,14 @@
+export function translatePythonCodexSdkEvents(events = []) {
+    return events.map((event, index) => ({
+        schema: 'sks.python-codex-sdk-event.v1',
+        index,
+        event_type: String(event?.event || 'unknown'),
+        thread_id: event?.thread_id ? String(event.thread_id) : null,
+        turn_id: event?.turn_id ? String(event.turn_id) : null,
+        status: event?.status ? String(event.status) : null,
+        retryable: event?.retryable === true,
+        message: event?.message ? String(event.message) : null,
+        final_response: event?.final_response ? String(event.final_response) : null
+    }));
+}
+//# sourceMappingURL=python-codex-sdk-event-translator.js.map