sneakoscope 2.0.2 → 2.0.5

package/dist/core/codex-control/gpt-final-proof-pack.js

@@ -0,0 +1,120 @@
+import { nowIso, sha256 } from '../fsx.js';
+export const GPT_FINAL_PROOF_PACK_SCHEMA = 'sks.gpt-final-proof-pack.v1';
+export function buildGptFinalProofPack(input, opts = {}) {
+    const maxCriticalLogChars = Math.max(1000, Number(opts.maxCriticalLogChars || 6000));
+    const localOutputs = Array.isArray(input.local_outputs) ? input.local_outputs : [];
+    const candidatePatchEnvelopes = Array.isArray(input.candidate_patch_envelopes) ? input.candidate_patch_envelopes : [];
+    const verificationResults = Array.isArray(input.verification_results) ? input.verification_results : [];
+    const pack = {
+        schema: GPT_FINAL_PROOF_PACK_SCHEMA,
+        generated_at: nowIso(),
+        route: String(input.route || ''),
+        mission_id: String(input.mission_id || ''),
+        local_mode: String(input.local_mode || ''),
+        worker_count: localOutputs.length,
+        changed_files: sortedUnique([
+            ...candidatePatchEnvelopes.flatMap((envelope) => envelopeChangedFiles(envelope)),
+            ...localOutputs.flatMap((output) => Array.isArray(output?.changed_files) ? output.changed_files.map(String) : [])
+        ]),
+        local_output_summaries: localOutputs.map((output, index) => ({
+            worker_id: String(output?.worker_id || output?.agent_id || output?.id || `worker-${index + 1}`),
+            backend: String(output?.backend || 'local-llm'),
+            status: String(output?.status || 'unknown'),
+            summary: trim(String(output?.summary || ''), 600),
+            proof: trim(String(output?.proof || output?.verification?.status || ''), 600),
+            blocker_count: Array.isArray(output?.blockers) ? output.blockers.length : 0,
+            patch_envelope_count: Array.isArray(output?.patch_envelopes) ? output.patch_envelopes.length : output?.patch_envelope ? 1 : 0
+        })),
+        candidate_diff_sha256: sha256(String(input.candidate_diff || '')),
+        candidate_diff_tail: tail(String(input.candidate_diff || ''), maxCriticalLogChars),
+        candidate_patch_envelopes: candidatePatchEnvelopes.map((envelope, index) => summarizeEnvelope(envelope, index)),
+        verification_failures: verificationResults.filter((result) => result?.ok === false || result?.status === 'failed').map((result) => ({
+            id: String(result?.id || result?.patch_entry_id || result?.name || 'verification'),
+            status: String(result?.status || (result?.ok === false ? 'failed' : 'unknown')),
+            blockers: stringArray(result?.blockers || result?.violations)
+        })),
+        side_effect_ledger_summary: summarizeObject(input.side_effect_report),
+        mutation_ledger_summary: summarizeObject(input.mutation_ledger),
+        rollback_plan_summary: summarizeObject(input.rollback_plan),
+        conflict_map: buildConflictMap(candidatePatchEnvelopes),
+        critical_logs_tail: tail(JSON.stringify({
+            local_outputs: localOutputs.map((output) => ({
+                id: output?.worker_id || output?.agent_id || output?.id,
+                blockers: output?.blockers || [],
+                unverified: output?.unverified || []
+            })),
+            verification_results: verificationResults
+        }), maxCriticalLogChars),
+        token_budget_estimate: 0
+    };
+    return {
+        ...pack,
+        token_budget_estimate: estimateTokens(pack)
+    };
+}
+export function buildGptFinalLatencyBudgetReport(input) {
+    const workerCount = Math.max(0, Number(input.workerCount || 0));
+    const tokenBudgetEstimate = Math.max(0, Number(input.tokenBudgetEstimate || 0));
+    const capAdjustment = tokenBudgetEstimate > 8000 || workerCount > 20 ? 'reduce_local_parallelism_or_pack_size' : 'within_budget';
+    return {
+        schema: 'sks.gpt-final-latency-budget.v1',
+        generated_at: nowIso(),
+        worker_count: workerCount,
+        token_budget_estimate: tokenBudgetEstimate,
+        latency_ms: input.latencyMs ?? null,
+        cap_adjustment: capAdjustment,
+        ok: capAdjustment === 'within_budget'
+    };
+}
+function summarizeEnvelope(envelope, index) {
+    return {
+        id: String(envelope?.id || envelope?.patch_id || `patch-${index + 1}`),
+        agent_id: String(envelope?.agent_id || 'unknown'),
+        source: String(envelope?.source || 'local-llm'),
+        operations: Array.isArray(envelope?.operations) ? envelope.operations.length : 0,
+        write_paths: envelopeChangedFiles(envelope),
+        lease_id: envelope?.lease_id || envelope?.lease_proof?.lease_id || null,
+        rollback_ready: Boolean(envelope?.rollback_hint || envelope?.lease_proof?.rollback_node_id)
+    };
+}
+function envelopeChangedFiles(envelope) {
+    return Array.isArray(envelope?.operations) ? envelope.operations.map((operation) => String(operation?.path || '')).filter(Boolean) : [];
+}
+function buildConflictMap(envelopes) {
+    const owners = new Map();
+    for (const envelope of envelopes) {
+        const agent = String(envelope?.agent_id || 'unknown');
+        for (const file of envelopeChangedFiles(envelope))
+            owners.set(file, [...(owners.get(file) || []), agent]);
+    }
+    return [...owners.entries()]
+        .filter(([, agents]) => new Set(agents).size > 1)
+        .map(([file, agents]) => ({ file, agents: sortedUnique(agents) }));
+}
+function summarizeObject(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    return {
+        schema: value.schema || null,
+        ok: typeof value.ok === 'boolean' ? value.ok : null,
+        status: value.status || null,
+        blockers: stringArray(value.blockers).slice(0, 20),
+        keys: Object.keys(value).slice(0, 30)
+    };
+}
+function estimateTokens(value) {
+    return Math.ceil(JSON.stringify(value).length / 4);
+}
+function tail(value, max) {
+    return value.length <= max ? value : value.slice(value.length - max);
+}
+function trim(value, max) {
+    return value.length <= max ? value : value.slice(0, max);
+}
+function sortedUnique(values) {
+    return [...new Set(values.map(String).filter(Boolean))].sort();
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.map((entry) => String(entry || '').trim()).filter(Boolean) : [];
+}
+//# sourceMappingURL=gpt-final-proof-pack.js.map

package/dist/core/codex-control/gpt-final-review-schema.js

@@ -0,0 +1,71 @@
+export const GPT_FINAL_ARBITER_RESULT_SCHEMA_ID = 'sks.gpt-final-arbiter-result.v1';
+export const GPT_FINAL_ARBITER_INPUT_SCHEMA = 'sks.gpt-final-arbiter-input.v1';
+export const gptFinalArbiterResultSchema = {
+    type: 'object',
+    required: [
+        'schema',
+        'status',
+        'summary',
+        'gpt_review_findings',
+        'accepted_patch_envelopes',
+        'modified_patch_envelopes',
+        'rejected_patch_envelopes',
+        'required_followup_work',
+        'verification_plan',
+        'rollback_notes',
+        'blockers',
+        'confidence'
+    ],
+    properties: {
+        schema: { const: GPT_FINAL_ARBITER_RESULT_SCHEMA_ID },
+        status: { enum: ['approved', 'modified', 'rejected', 'needs_more_work'] },
+        summary: { type: 'string' },
+        gpt_review_findings: { type: 'array', items: { type: 'object' } },
+        accepted_patch_envelopes: { type: 'array', items: { type: 'object' } },
+        modified_patch_envelopes: { type: 'array', items: { type: 'object' } },
+        rejected_patch_envelopes: { type: 'array', items: { type: 'object' } },
+        required_followup_work: { type: 'array', items: { type: 'object' } },
+        verification_plan: { type: 'array', items: { type: 'string' } },
+        rollback_notes: { type: 'array', items: { type: 'string' } },
+        blockers: { type: 'array', items: { type: 'string' } },
+        confidence: { enum: ['low', 'medium', 'high'] }
+    },
+    additionalProperties: true
+};
+export function normalizeGptFinalArbiterResult(value) {
+    const status = normalizeStatus(value?.status);
+    return {
+        schema: GPT_FINAL_ARBITER_RESULT_SCHEMA_ID,
+        status,
+        summary: String(value?.summary || defaultSummary(status)),
+        gpt_review_findings: array(value?.gpt_review_findings),
+        accepted_patch_envelopes: array(value?.accepted_patch_envelopes),
+        modified_patch_envelopes: array(value?.modified_patch_envelopes),
+        rejected_patch_envelopes: array(value?.rejected_patch_envelopes),
+        required_followup_work: array(value?.required_followup_work),
+        verification_plan: stringArray(value?.verification_plan),
+        rollback_notes: stringArray(value?.rollback_notes),
+        blockers: stringArray(value?.blockers),
+        confidence: normalizeConfidence(value?.confidence)
+    };
+}
+function normalizeStatus(value) {
+    return value === 'approved' || value === 'modified' || value === 'rejected' || value === 'needs_more_work'
+        ? value
+        : 'needs_more_work';
+}
+function normalizeConfidence(value) {
+    return value === 'low' || value === 'medium' || value === 'high' ? value : 'medium';
+}
+function array(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.map((entry) => String(entry || '').trim()).filter(Boolean) : [];
+}
+function defaultSummary(status) {
+    return status === 'approved' || status === 'modified'
+        ? 'GPT final arbiter accepted the candidate result.'
+        : 'GPT final arbiter did not approve the candidate result.';
+}
+//# sourceMappingURL=gpt-final-review-schema.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

package/dist/core/commands/local-model-command.js

@@ -1,4 +1,6 @@
-import { resolveOllamaWorkerConfig, writeLocalModelConfig, readLocalModelConfig } from '../agents/ollama-worker-config.js';
+import { applyLocalLlmSmokeResult, normalizeProvider, resolveOllamaWorkerConfig, writeLocalModelConfig, readLocalModelConfig } from '../agents/ollama-worker-config.js';
+import { detectInstalledLocalModelCandidate, probeLocalLlmEndpoint } from '../local-llm/local-llm-client.js';
+import { runLocalLlmGenerationSmoke, localLlmSmokeSchema } from '../local-llm/local-llm-smoke.js';
 export async function localModelCommand(args = []) {
     const action = normalizeLocalModelAction(args[0]);
     if (action === 'enable')
@@ -26,18 +28,64 @@ function normalizeLocalModelAction(value) {
     return text;
 }
 async function enable(args) {
-    const model = readOption(args, '--model', args[0] || '');
+    const model = readOption(args, '--model', firstPositional(args) || '');
     const baseUrl = readOption(args, '--base-url', '');
+    const provider = readOption(args, '--provider', '');
     const think = readBoolFlag(args, '--think', '--no-think');
-    const patch = { enabled: true, provider: 'ollama' };
+    const skipSmoke = args.includes('--skip-smoke') || process.env.SKS_LOCAL_LLM_TOGGLE_ONLY === '1';
+    const patch = { enabled: true, status: 'enabled_unverified' };
+    const explicitConfig = Boolean(model || baseUrl || provider);
+    let detection = null;
+    if (!explicitConfig) {
+        detection = await detectInstalledLocalModelCandidate();
+        if (!detection) {
+            const config = await writeLocalModelConfig({ enabled: false, blockers: ['local_model_not_found'] });
+            process.exitCode = 1;
+            return {
+                schema: 'sks.local-model-command.v1',
+                ok: false,
+                action: 'enable',
+                message: '확인해보니 로컬 모델이 존재하지 않아 실행할 수 없습니다.',
+                config,
+                detection: null,
+                blockers: ['local_model_not_found']
+            };
+        }
+        patch.provider = detection.provider;
+        patch.model = detection.model;
+        patch.base_url = detection.base_url;
+        patch.endpoint = detection.endpoint;
+    }
+    if (provider)
+        patch.provider = normalizeProvider(provider);
     if (model)
         patch.model = model;
-    if (baseUrl)
+    if (baseUrl) {
         patch.base_url = baseUrl;
+        patch.endpoint = baseUrl;
+    }
     if (think !== null)
         patch.think = think;
     const config = await writeLocalModelConfig(patch);
-    return { schema: 'sks.local-model-command.v1', ok: true, action: 'enable', config };
+    const smoke = skipSmoke
+        ? { ok: false, skipped: true, status: 'enabled_unverified', reason: 'operator_skip_smoke', schema_valid: false, blockers: ['operator_skip_smoke'] }
+        : await runLocalLlmGenerationSmoke(config, {
+            prompt: 'Return strict JSON: {"status":"ok","summary":"local smoke passed"}',
+            schema: localLlmSmokeSchema,
+            timeoutMs: 20_000
+        });
+    const next = await writeLocalModelConfig(applyLocalLlmSmokeResult(config, smoke));
+    if (!skipSmoke && smoke.ok !== true)
+        process.exitCode = 1;
+    return {
+        schema: 'sks.local-model-command.v1',
+        ok: skipSmoke ? true : smoke.ok === true,
+        action: 'enable',
+        config: next,
+        detection,
+        smoke,
+        blockers: next.blockers
+    };
 }
 async function disable() {
     const config = await writeLocalModelConfig({ enabled: false });
@@ -55,37 +103,35 @@ async function setModel(args) {
 async function status() {
     const config = await readLocalModelConfig();
     const resolved = await resolveOllamaWorkerConfig();
-    const api = await probeOllama(resolved.base_url);
+    const api = await probeLocalLlmEndpoint(resolved);
     return { schema: 'sks.local-model-command.v1', ok: true, action: 'status', config, resolved, api };
 }
-async function probeOllama(baseUrl) {
-    try {
-        const response = await fetch(`${baseUrl}/api/version`, { signal: AbortSignal.timeout(3000) });
-        const text = await response.text();
-        return { ok: response.ok, status: response.status, data: response.ok ? JSON.parse(text) : null };
-    }
-    catch (error) {
-        return { ok: false, error: error instanceof Error ? error.message : String(error) };
-    }
-}
 function emit(result, args) {
     if (args.includes('--json')) {
         console.log(JSON.stringify(result, null, 2));
         return result;
     }
     if (result.ok !== true) {
+        if (result.message)
+            console.log(result.message);
         console.log(`Local model: blocked (${(result.blockers || []).join(', ') || 'unknown'})`);
         return result;
     }
     const config = result.config || result.resolved || {};
     console.log(`Local model: ${config.enabled ? 'enabled' : 'disabled'}`);
-    console.log(`Provider: ollama`);
+    console.log(`Provider: ${config.provider || 'unknown'}`);
     console.log(`Model: ${config.model || 'unknown'}`);
     console.log(`Base URL: ${config.base_url || config.baseUrl || 'unknown'}`);
+    if (config.status)
+        console.log(`Status: ${config.status}`);
+    if (result.detection)
+        console.log(`Detected: ${result.detection.source}`);
+    if (config.last_smoke?.result_path)
+        console.log(`Smoke: ${config.last_smoke.ok ? 'ok' : 'failed'} ${config.last_smoke.result_path}`);
     if (typeof config.think === 'boolean')
         console.log(`Think: ${config.think ? 'enabled' : 'disabled'}`);
     if (result.api)
-        console.log(`Ollama API: ${result.api.ok ? 'ok' : 'not reachable'}`);
+        console.log(`Local model API: ${result.api.ok ? 'ok' : 'not reachable'}`);
     return result;
 }
 function readOption(args, name, fallback) {
@@ -102,4 +148,19 @@ function readBoolFlag(args, trueName, falseName) {
         return false;
     return null;
 }
+function firstPositional(args = []) {
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = String(args[i] || '');
+        if (arg === '--model' || arg === '--base-url' || arg === '--provider') {
+            if (args[i + 1] && !String(args[i + 1]).startsWith('--'))
+                i += 1;
+            continue;
+        }
+        if (arg.startsWith('--model=') || arg.startsWith('--base-url=') || arg.startsWith('--provider='))
+            continue;
+        if (!arg.startsWith('--'))
+            return arg;
+    }
+    return '';
+}
 //# sourceMappingURL=local-model-command.js.map