sneakoscope 2.0.2 → 2.0.5

package/dist/core/local-llm/local-collaboration-policy.js

@@ -0,0 +1,93 @@
+import { nowIso } from '../fsx.js';
+export const LOCAL_COLLABORATION_POLICY_SCHEMA = 'sks.local-collaboration-policy.v1';
+export const LOCAL_COLLABORATION_FINAL_GATE_SCHEMA = 'sks.local-collaboration-final-gate.v1';
+export const DEFAULT_LOCAL_COLLABORATION_MODE = 'local-parallel-gpt-final';
+export const LOCAL_COLLABORATION_MODES = [
+    'disabled',
+    'local-draft-gpt-final',
+    'local-worker-gpt-orchestrator',
+    'local-parallel-gpt-final',
+    'local-only-draft'
+];
+export function resolveLocalCollaborationPolicy(input = {}) {
+    const env = input.env || process.env;
+    const requested = firstText(input.mode, env.SKS_LOCAL_COLLAB_MODE, DEFAULT_LOCAL_COLLABORATION_MODE);
+    const mode = normalizeLocalCollaborationMode(requested);
+    const invalid = mode ? [] : [`invalid_local_collaboration_mode:${requested}`];
+    const resolvedMode = mode || DEFAULT_LOCAL_COLLABORATION_MODE;
+    return {
+        schema: LOCAL_COLLABORATION_POLICY_SCHEMA,
+        generated_at: nowIso(),
+        mode: resolvedMode,
+        default_mode: DEFAULT_LOCAL_COLLABORATION_MODE,
+        local_llm_role: resolvedMode === 'disabled' ? 'disabled' : 'draft_worker',
+        gpt_final_required: resolvedMode !== 'disabled' && resolvedMode !== 'local-only-draft',
+        gpt_final_backend_must_be_remote: resolvedMode !== 'disabled',
+        local_only_draft: resolvedMode === 'local-only-draft',
+        final_accepted_statuses: ['approved', 'modified'],
+        final_patch_source_when_enabled: 'gpt_final_arbiter',
+        blockers: [
+            ...invalid,
+            ...(resolvedMode === 'local-only-draft' ? ['needs_gpt_final_review'] : [])
+        ]
+    };
+}
+export function evaluateLocalCollaborationFinalGate(input = {}) {
+    const policy = input.policy || resolveLocalCollaborationPolicy(input.mode === undefined ? {} : { mode: input.mode });
+    const localParticipated = input.localParticipated !== false && policy.mode !== 'disabled';
+    const status = normalizeGptFinalStatus(input.gptFinalStatus);
+    const requiresGptFinal = policy.gpt_final_required && localParticipated;
+    const gptBackend = String(input.gptFinalBackend || '');
+    const remoteBackendOk = !gptBackend || !isLocalBackendName(gptBackend);
+    const blockers = [
+        ...policy.blockers,
+        ...(requiresGptFinal && input.gptFinalAvailable === false ? ['gpt_final_arbiter_unavailable'] : []),
+        ...(requiresGptFinal && !status ? ['gpt_final_arbiter_missing'] : []),
+        ...(requiresGptFinal && status && !policy.final_accepted_statuses.includes(status) ? [`gpt_final_status_not_accepted:${status}`] : []),
+        ...(requiresGptFinal && !remoteBackendOk ? ['gpt_final_backend_must_not_be_local_llm'] : []),
+        ...(policy.local_only_draft && input.applyPatches === true ? ['local_only_draft_apply_blocked'] : [])
+    ];
+    const accepted = blockers.length === 0 && (!requiresGptFinal || status === 'approved' || status === 'modified');
+    return {
+        schema: LOCAL_COLLABORATION_FINAL_GATE_SCHEMA,
+        generated_at: nowIso(),
+        ok: accepted,
+        mode: policy.mode,
+        local_participated: localParticipated,
+        gpt_final_required: requiresGptFinal,
+        gpt_final_status: status,
+        gpt_final_backend: gptBackend || null,
+        final_status: accepted ? 'accepted' : policy.local_only_draft ? 'draft_only' : 'blocked',
+        apply_allowed: accepted && policy.local_only_draft !== true,
+        release_proof_allowed: accepted,
+        final_patch_source: accepted && policy.mode !== 'disabled' ? policy.final_patch_source_when_enabled : 'not_applicable',
+        blockers
+    };
+}
+export function localCollaborationParticipated(results = []) {
+    return results.some((result) => {
+        const backend = String(result?.backend_router_report?.selected_backend || result?.backend || '').toLowerCase();
+        return backend === 'ollama' || backend === 'local-llm' || backend === 'local_llm';
+    });
+}
+export function normalizeLocalCollaborationMode(value) {
+    const text = String(value ?? '').trim();
+    return LOCAL_COLLABORATION_MODES.includes(text) ? text : null;
+}
+export function normalizeGptFinalStatus(value) {
+    const text = String(value ?? '').trim();
+    return text === 'approved' || text === 'modified' || text === 'rejected' || text === 'needs_more_work' ? text : null;
+}
+function firstText(...values) {
+    for (const value of values) {
+        const text = String(value ?? '').trim();
+        if (text)
+            return text;
+    }
+    return '';
+}
+function isLocalBackendName(value) {
+    const text = value.toLowerCase();
+    return text === 'ollama' || text === 'local-llm' || text === 'local_llm';
+}
+//# sourceMappingURL=local-collaboration-policy.js.map

package/dist/core/local-llm/local-llm-backpressure.js

@@ -0,0 +1,20 @@
+export function classifyLocalLlmBackpressure(input) {
+    const max = Math.max(1, Math.floor(Number(input.maxParallelRequests || 1)));
+    const active = Math.max(0, Math.floor(Number(input.activeRequests || 0)));
+    const queue = Math.max(0, Math.floor(Number(input.queueDepth || 0)));
+    const p95 = Math.max(0, Number(input.p95LatencyMs || 0));
+    const state = active >= max && queue >= max
+        ? 'saturated'
+        : active >= max || queue > max || p95 > 10_000
+            ? 'throttled'
+            : 'normal';
+    return {
+        schema: 'sks.local-llm-backpressure.v1',
+        state,
+        active_requests: active,
+        max_parallel_requests: max,
+        queue_depth: queue,
+        p95_latency_ms: p95
+    };
+}
+//# sourceMappingURL=local-llm-backpressure.js.map

package/dist/core/local-llm/local-llm-capability.js

@@ -0,0 +1,29 @@
+import { listLocalLlmModels, probeLocalLlmEndpoint } from './local-llm-client.js';
+export async function detectLocalLlmCapability(config) {
+    const version = await probeLocalLlmEndpoint(config);
+    const tags = version.ok ? await listLocalLlmModels(config) : { ok: false, models: [] };
+    const modelInstalled = tags.models.includes(config.model);
+    const capability = {
+        api_reachable: version.ok,
+        model_installed: modelInstalled,
+        supports_streaming: true,
+        supports_json_schema: config.provider === 'ollama',
+        supports_tools: false,
+        supports_images: false,
+        context_window: config.capability.context_window || 32768,
+        max_parallel_requests: config.capability.max_parallel_requests || 4
+    };
+    const blockers = [
+        ...(version.ok ? [] : ['local_model_endpoint_unreachable']),
+        ...(modelInstalled ? [] : ['local_model_missing'])
+    ];
+    return {
+        ok: blockers.length === 0,
+        provider: config.provider,
+        model: config.model,
+        endpoint: config.base_url,
+        capability,
+        blockers
+    };
+}
+//# sourceMappingURL=local-llm-capability.js.map

package/dist/core/local-llm/local-llm-client.js

@@ -0,0 +1,100 @@
+import { callOllamaGenerate, listOllamaModels, ollamaTokensPerSecond, probeOllamaVersion } from './local-llm-ollama-client.js';
+import { callOpenAiCompatibleLocalChat } from './local-llm-openai-compatible-client.js';
+export async function probeLocalLlmEndpoint(config) {
+    if (config.provider === 'ollama')
+        return probeOllamaVersion(config.base_url, Math.min(5000, Number(config.timeout_ms || 3000)));
+    return probeOpenAiCompatibleModels(config.base_url, Math.min(5000, Number(config.timeout_ms || 3000)));
+}
+export async function listLocalLlmModels(config) {
+    if (config.provider === 'ollama')
+        return listOllamaModels(config.base_url, Math.min(5000, Number(config.timeout_ms || 5000)));
+    return listOpenAiCompatibleModels(config.base_url, Math.min(5000, Number(config.timeout_ms || 5000)));
+}
+export async function callLocalLlmGenerate(config, request) {
+    if (config.provider === 'ollama')
+        return callOllamaGenerate(config, request);
+    const response = await callOpenAiCompatibleLocalChat({
+        endpoint: config.base_url,
+        model: request.model,
+        messages: request.messages || [{ role: 'user', content: request.prompt }],
+        temperature: Number((request.options || {}).temperature ?? config.temperature ?? 0)
+    }, Number(config.timeout_ms || 20_000));
+    if (!response.ok)
+        return { ok: false, status: response.status, error: `http_${response.status}:${String(response.error || '').slice(0, 500)}` };
+    const text = extractOpenAiCompatibleText(response.data);
+    return {
+        ok: true,
+        data: {
+            provider: config.provider,
+            model: request.model,
+            response: text,
+            raw: response.data
+        },
+        text
+    };
+}
+export function localLlmTokensPerSecond(data, fallbackText = '', latencyMs = 0) {
+    return ollamaTokensPerSecond(data, fallbackText, latencyMs);
+}
+export async function detectInstalledLocalModelCandidate(input = {}) {
+    const timeoutMs = input.timeoutMs || 3000;
+    const endpoints = [
+        { provider: 'mlx-lm', base_url: trimTrailingSlash(input.mlxBaseUrl || process.env.SKS_MLX_LM_BASE_URL || process.env.SKS_LOCAL_LLM_BASE_URL || 'http://127.0.0.1:8080'), source: 'mlx_lm_server_v1_models' },
+        { provider: 'openai-compatible', base_url: trimTrailingSlash(input.openAiCompatibleBaseUrl || process.env.SKS_OPENAI_COMPATIBLE_BASE_URL || process.env.SKS_LOCAL_OPENAI_COMPATIBLE_BASE_URL || process.env.LM_STUDIO_BASE_URL || 'http://127.0.0.1:1234'), source: 'openai_compatible_v1_models' },
+        { provider: 'ollama', base_url: trimTrailingSlash(input.ollamaBaseUrl || process.env.SKS_OLLAMA_BASE_URL || 'http://127.0.0.1:11434'), source: 'ollama_api_tags' }
+    ];
+    const seen = new Set();
+    for (const endpoint of endpoints) {
+        if (!endpoint.base_url)
+            continue;
+        const key = `${endpoint.provider}:${endpoint.base_url}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const listed = await listLocalLlmModels({ ...endpoint, timeout_ms: timeoutMs }).catch(() => ({ ok: false, models: [] }));
+        if (!listed.ok || listed.models.length === 0)
+            continue;
+        const model = chooseModel(listed.models, input.preferredModel);
+        return { ...endpoint, endpoint: endpoint.base_url, model, models: listed.models };
+    }
+    return null;
+}
+async function probeOpenAiCompatibleModels(baseUrl, timeoutMs = 3000) {
+    const models = await listOpenAiCompatibleModels(baseUrl, timeoutMs);
+    return { ...models, data: models.ok ? { models: models.models } : null };
+}
+async function listOpenAiCompatibleModels(baseUrl, timeoutMs = 5000) {
+    try {
+        const response = await fetch(`${trimTrailingSlash(baseUrl)}/v1/models`, { signal: AbortSignal.timeout(timeoutMs) });
+        const text = await response.text();
+        const data = response.ok ? JSON.parse(text) : null;
+        const models = Array.isArray(data?.data) ? data.data.map((model) => String(model?.id || '')).filter(Boolean) : [];
+        return { ok: response.ok, status: response.status, models, data, error: response.ok ? null : text.slice(0, 500) };
+    }
+    catch (error) {
+        return { ok: false, status: 0, models: [], data: null, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function extractOpenAiCompatibleText(data) {
+    const choice = Array.isArray(data?.choices) ? data.choices[0] : null;
+    if (typeof choice?.message?.content === 'string')
+        return choice.message.content;
+    if (typeof choice?.text === 'string')
+        return choice.text;
+    if (typeof data?.response === 'string')
+        return data.response;
+    if (typeof data?.content === 'string')
+        return data.content;
+    return '';
+}
+function chooseModel(models, preferredModel = '') {
+    const preferred = String(preferredModel || '').trim();
+    if (preferred && models.includes(preferred))
+        return preferred;
+    const qwen = models.find((model) => /qwen/i.test(model));
+    return qwen || models[0] || '';
+}
+function trimTrailingSlash(value) {
+    return String(value || '').replace(/\/+$/, '');
+}
+//# sourceMappingURL=local-llm-client.js.map

package/dist/core/local-llm/local-llm-config.js

@@ -0,0 +1,20 @@
+import { resolveOllamaWorkerConfig } from '../agents/ollama-worker-config.js';
+export async function resolveLocalLlmConfig(input = {}) {
+    const config = await resolveOllamaWorkerConfig(input);
+    return {
+        schema: 'sks.local-llm-config.v2',
+        ok: config.ok,
+        enabled: config.enabled,
+        status: config.status,
+        provider: config.provider,
+        model: config.model,
+        endpoint: config.endpoint,
+        base_url: config.base_url,
+        worker_only: true,
+        requires_gpt_final: config.policy.requires_gpt_final,
+        capability: config.capability,
+        last_smoke: config.last_smoke,
+        blockers: config.blockers
+    };
+}
+//# sourceMappingURL=local-llm-config.js.map

package/dist/core/local-llm/local-llm-context-cache.js

@@ -0,0 +1,21 @@
+import { sha256 } from '../fsx.js';
+const SECRET_PATTERNS = [/api[_-]?key/i, /token/i, /secret/i, /password/i, /authorization/i];
+export function buildLocalLlmContextCacheKey(parts) {
+    const redacted = redactSecrets(parts);
+    return {
+        schema: 'sks.local-llm-context-cache-key.v1',
+        key: sha256(JSON.stringify(redacted)),
+        redacted
+    };
+}
+export function redactSecrets(value) {
+    if (Array.isArray(value))
+        return value.map(redactSecrets);
+    if (!value || typeof value !== 'object')
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [
+        key,
+        SECRET_PATTERNS.some((pattern) => pattern.test(key)) ? '[redacted]' : redactSecrets(child)
+    ]));
+}
+//# sourceMappingURL=local-llm-context-cache.js.map

package/dist/core/local-llm/local-llm-control-adapter.js

@@ -0,0 +1,101 @@
+import { nowIso, sha256 } from '../fsx.js';
+import { evaluateLocalWorkerEligibility } from './local-worker-eligibility.js';
+import { callLocalLlmGenerate, localLlmTokensPerSecond } from './local-llm-client.js';
+import { enforceLocalLlmJsonSchema } from './local-llm-schema-enforcer.js';
+export async function runLocalLlmTask(input, opts) {
+    const started = Date.now();
+    const requestId = `local-llm:${sha256(`${nowIso()}:${input.missionId}:${input.workItemId || ''}:${input.slotId || ''}`).slice(0, 16)}`;
+    const eligibility = evaluateLocalWorkerEligibility(input, opts.config);
+    if (!eligibility.ok) {
+        return {
+            ok: false,
+            backend: 'local-llm',
+            backendFamily: 'local-llm',
+            requestId,
+            events: [],
+            finalResponse: '',
+            structuredOutput: null,
+            structuredOutputValid: false,
+            proof: buildProof(input, opts.config, requestId, started, eligibility, null, ['local_llm_eligibility_blocked', ...eligibility.blockers]),
+            blockers: ['local_llm_eligibility_blocked', ...eligibility.blockers]
+        };
+    }
+    const prompt = buildLocalLlmTaskPrompt(input, opts.outputSchema);
+    const response = await callLocalLlmGenerate(opts.config, {
+        model: opts.config.model,
+        prompt,
+        stream: false,
+        format: 'json',
+        think: opts.config.think,
+        keep_alive: opts.config.keep_alive,
+        options: { temperature: opts.config.temperature }
+    });
+    const latencyMs = Math.max(0, Date.now() - started);
+    const enforced = response.ok ? enforceLocalLlmJsonSchema(response.text, opts.outputSchema) : { ok: false, value: null, schema_valid: false, issues: [response.error] };
+    const blockers = [
+        ...(response.ok ? [] : ['local_llm_generate_failed', response.error]),
+        ...(enforced.ok ? [] : ['local_llm_structured_output_invalid', ...(enforced.issues || []).map((issue) => `schema:${String(issue)}`)])
+    ];
+    const event = {
+        schema: 'sks.local-llm-event.v1',
+        generated_at: nowIso(),
+        type: response.ok ? 'local_llm_generate_completed' : 'local_llm_generate_failed',
+        request_id: requestId,
+        latency_ms: latencyMs,
+        schema_valid: enforced.schema_valid === true
+    };
+    return {
+        ok: blockers.length === 0,
+        backend: 'local-llm',
+        backendFamily: 'local-llm',
+        requestId,
+        events: [event],
+        finalResponse: JSON.stringify(enforced.value || {}),
+        structuredOutput: enforced.value,
+        structuredOutputValid: enforced.schema_valid === true,
+        proof: buildProof(input, opts.config, requestId, started, eligibility, response.ok ? response.data : null, blockers, latencyMs, response.ok ? localLlmTokensPerSecond(response.data, response.text, latencyMs) : 0),
+        blockers
+    };
+}
+function buildLocalLlmTaskPrompt(input, outputSchema) {
+    return [
+        'You are an SKS local LLM worker backend. You are worker-only.',
+        'You must not make strategy, planning, safety, verification, integration, or final acceptance decisions.',
+        'Return JSON only. Natural language outside JSON is invalid.',
+        'Your output is a draft and requires GPT Final Arbiter before final acceptance or patch application.',
+        JSON.stringify({
+            route: input.route,
+            mission_id: input.missionId,
+            work_item_id: input.workItemId || null,
+            slot_id: input.slotId || null,
+            sandbox_policy: input.sandboxPolicy,
+            prompt: input.prompt,
+            output_schema: outputSchema
+        }, null, 2)
+    ].join('\n');
+}
+function buildProof(input, config, requestId, started, eligibility, rawResponse, blockers, latencyMs = Math.max(0, Date.now() - started), tokensPerSecond = 0) {
+    return {
+        schema: 'sks.local-llm-proof.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        request_id: requestId,
+        provider: config.provider,
+        model: config.model,
+        endpoint: config.base_url,
+        backend: 'local-llm',
+        backend_family: 'local-llm',
+        route: input.route,
+        mission_id: input.missionId,
+        work_item_id: input.workItemId || null,
+        slot_id: input.slotId || null,
+        safety_scope: 'worker_only_requires_gpt_final',
+        latency_ms: latencyMs,
+        tokens_per_second: tokensPerSecond,
+        schema_valid: blockers.length === 0,
+        eligibility,
+        raw_response: rawResponse,
+        blockers
+    };
+}
+//# sourceMappingURL=local-llm-control-adapter.js.map

package/dist/core/local-llm/local-llm-json-repair.js

@@ -0,0 +1,52 @@
+export function parseOrRepairLocalLlmJson(text) {
+    const raw = String(text || '').trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+    const direct = tryParse(raw);
+    if (direct.ok)
+        return { ok: true, value: direct.value, repaired: false, attempts: 0 };
+    const extracted = extractFirstJsonObject(raw);
+    if (extracted) {
+        const parsed = tryParse(extracted);
+        if (parsed.ok)
+            return { ok: true, value: parsed.value, repaired: true, attempts: 1 };
+    }
+    return { ok: false, value: null, repaired: false, attempts: 1, error: direct.error || 'json_parse_failed' };
+}
+function tryParse(text) {
+    try {
+        return { ok: true, value: JSON.parse(text) };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function extractFirstJsonObject(text) {
+    const start = text.indexOf('{');
+    if (start < 0)
+        return '';
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < text.length; i += 1) {
+        const ch = text[i];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (ch === '\\')
+                escaped = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === '{')
+            depth += 1;
+        else if (ch === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return text.slice(start, i + 1);
+        }
+    }
+    return '';
+}
+//# sourceMappingURL=local-llm-json-repair.js.map

package/dist/core/local-llm/local-llm-metrics.js

@@ -0,0 +1,42 @@
+import { classifyLocalLlmBackpressure } from './local-llm-backpressure.js';
+export function buildLocalLlmMetrics(input) {
+    const latencies = numeric(input.latencyMsSamples);
+    const metrics = {
+        schema: 'sks.local-llm-metrics.v1',
+        provider: input.provider || 'ollama',
+        model: input.model || 'unknown',
+        active_requests: Math.max(0, Math.floor(Number(input.activeRequests || 0))),
+        max_parallel_requests: Math.max(1, Math.floor(Number(input.maxParallelRequests || 1))),
+        queue_depth: Math.max(0, Math.floor(Number(input.queueDepth || 0))),
+        avg_first_token_ms: average(numeric(input.firstTokenMsSamples)),
+        avg_tokens_per_second: average(numeric(input.tokenPerSecondSamples)),
+        p95_latency_ms: percentile(latencies, 0.95)
+    };
+    const backpressureInput = {
+        activeRequests: metrics.active_requests,
+        maxParallelRequests: metrics.max_parallel_requests,
+        queueDepth: metrics.queue_depth
+    };
+    if (metrics.p95_latency_ms !== undefined)
+        backpressureInput.p95LatencyMs = metrics.p95_latency_ms;
+    return {
+        ...metrics,
+        backpressure: classifyLocalLlmBackpressure(backpressureInput).state
+    };
+}
+function numeric(values = []) {
+    return values.map(Number).filter((value) => Number.isFinite(value) && value >= 0);
+}
+function average(values) {
+    if (!values.length)
+        return 0;
+    return Number((values.reduce((sum, value) => sum + value, 0) / values.length).toFixed(2));
+}
+function percentile(values, p) {
+    if (!values.length)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.min(sorted.length - 1, Math.ceil(sorted.length * p) - 1);
+    return sorted[index];
+}
+//# sourceMappingURL=local-llm-metrics.js.map

package/dist/core/local-llm/local-llm-ollama-client.js

@@ -0,0 +1,67 @@
+export async function probeOllamaVersion(baseUrl, timeoutMs = 3000) {
+    try {
+        const response = await fetch(`${trimTrailingSlash(baseUrl)}/api/version`, { signal: AbortSignal.timeout(timeoutMs) });
+        const text = await response.text();
+        return { ok: response.ok, status: response.status, data: response.ok ? JSON.parse(text) : null, error: response.ok ? null : text.slice(0, 500) };
+    }
+    catch (error) {
+        return { ok: false, status: 0, data: null, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function listOllamaModels(baseUrl, timeoutMs = 5000) {
+    try {
+        const response = await fetch(`${trimTrailingSlash(baseUrl)}/api/tags`, { signal: AbortSignal.timeout(timeoutMs) });
+        const text = await response.text();
+        const data = response.ok ? JSON.parse(text) : null;
+        const models = Array.isArray(data?.models) ? data.models.map((model) => String(model?.name || '')).filter(Boolean) : [];
+        return { ok: response.ok, status: response.status, models, data, error: response.ok ? null : text.slice(0, 500) };
+    }
+    catch (error) {
+        return { ok: false, status: 0, models: [], data: null, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function callOllamaGenerate(config, request) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), Math.max(1, Number(config.timeout_ms || 20_000)));
+    try {
+        const response = await fetch(`${trimTrailingSlash(config.base_url)}/api/generate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(request),
+            signal: controller.signal
+        });
+        const text = await response.text();
+        if (!response.ok)
+            return { ok: false, status: response.status, error: `http_${response.status}:${text.slice(0, 500)}` };
+        const data = JSON.parse(text);
+        return { ok: true, data, text: extractOllamaText(data) };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function extractOllamaText(data) {
+    if (typeof data.response === 'string')
+        return data.response;
+    if (typeof data.message?.content === 'string')
+        return data.message.content;
+    if (typeof data.content === 'string')
+        return data.content;
+    return '';
+}
+export function ollamaTokensPerSecond(data, fallbackText = '', latencyMs = 0) {
+    const evalCount = Number(data.eval_count || 0);
+    const evalDurationNs = Number(data.eval_duration || 0);
+    if (evalCount > 0 && evalDurationNs > 0)
+        return Number((evalCount / (evalDurationNs / 1_000_000_000)).toFixed(2));
+    const approximateTokens = Math.max(1, Math.ceil(fallbackText.length / 4));
+    const seconds = Math.max(0.001, latencyMs / 1000);
+    return Number((approximateTokens / seconds).toFixed(2));
+}
+function trimTrailingSlash(value) {
+    return String(value || '').replace(/\/+$/, '');
+}
+//# sourceMappingURL=local-llm-ollama-client.js.map

package/dist/core/local-llm/local-llm-openai-compatible-client.js

@@ -0,0 +1,30 @@
+export async function callOpenAiCompatibleLocalChat(input, timeoutMs = 20_000) {
+    try {
+        const response = await fetch(`${input.endpoint.replace(/\/+$/, '')}/v1/chat/completions`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: input.model,
+                messages: input.messages,
+                temperature: input.temperature ?? 0
+            }),
+            signal: AbortSignal.timeout(timeoutMs)
+        });
+        const text = await response.text();
+        return {
+            ok: response.ok,
+            status: response.status,
+            data: response.ok ? JSON.parse(text) : null,
+            error: response.ok ? null : text.slice(0, 500)
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            status: 0,
+            data: null,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+//# sourceMappingURL=local-llm-openai-compatible-client.js.map

package/dist/core/local-llm/local-llm-prompt-cache.js

@@ -0,0 +1,12 @@
+import { buildLocalLlmContextCacheKey } from './local-llm-context-cache.js';
+export function buildLocalLlmPromptCacheRecord(input) {
+    const key = buildLocalLlmContextCacheKey(input);
+    return {
+        schema: 'sks.local-llm-prompt-cache.v1',
+        cache_key: key.key,
+        source_hashes: input,
+        cacheable: Object.values(input).every(Boolean),
+        forbidden_material: ['secrets', 'auth tokens', 'raw private config']
+    };
+}
+//# sourceMappingURL=local-llm-prompt-cache.js.map

package/dist/core/local-llm/local-llm-scheduler.js

@@ -0,0 +1,29 @@
+import { buildLocalLlmMetrics } from './local-llm-metrics.js';
+export function planLocalLlmSchedule(input) {
+    const max = Math.max(1, Math.floor(Number(input.maxParallelRequests || 1)));
+    const active = Math.max(0, Math.floor(Number(input.activeRequests || 0)));
+    const available = Math.max(0, max - active);
+    const queueDepth = Math.max(0, input.workItems.length - available);
+    const dispatch = input.workItems.slice(0, available);
+    const queued = input.workItems.slice(available);
+    const metrics = buildLocalLlmMetrics({
+        activeRequests: active + dispatch.length,
+        maxParallelRequests: max,
+        queueDepth,
+        latencyMsSamples: input.latencyMsSamples || []
+    });
+    return {
+        schema: 'sks.local-llm-scheduler-plan.v1',
+        ok: metrics.active_requests <= max,
+        max_parallel_requests: max,
+        active_requests: metrics.active_requests,
+        dispatch_count: dispatch.length,
+        queued_count: queued.length,
+        backpressure: metrics.backpressure,
+        dispatch,
+        queued,
+        metrics,
+        blockers: metrics.active_requests <= max ? [] : ['local_llm_active_requests_exceeded']
+    };
+}
+//# sourceMappingURL=local-llm-scheduler.js.map

package/dist/core/local-llm/local-llm-schema-enforcer.js

@@ -0,0 +1,15 @@
+import { validateJsonSchemaRecursive } from '../json-schema-validator.js';
+import { parseOrRepairLocalLlmJson } from './local-llm-json-repair.js';
+export function enforceLocalLlmJsonSchema(text, schema) {
+    const parsed = parseOrRepairLocalLlmJson(text);
+    const validation = parsed.ok ? validateJsonSchemaRecursive(parsed.value, schema) : { ok: false, issues: [parsed.error || 'json_parse_failed'] };
+    return {
+        ok: parsed.ok && validation.ok,
+        value: parsed.ok ? parsed.value : null,
+        repaired: parsed.repaired,
+        repair_attempts: parsed.attempts,
+        schema_valid: validation.ok,
+        issues: validation.issues
+    };
+}
+//# sourceMappingURL=local-llm-schema-enforcer.js.map