sneakoscope 2.0.4 → 2.0.5

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')
@@ -28,16 +30,62 @@ function normalizeLocalModelAction(value) {
 async function enable(args) {
     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) {
@@ -105,12 +151,12 @@ function readBoolFlag(args, trueName, falseName) {
 function firstPositional(args = []) {
     for (let i = 0; i < args.length; i += 1) {
         const arg = String(args[i] || '');
-        if (arg === '--model' || arg === '--base-url') {
+        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='))
+        if (arg.startsWith('--model=') || arg.startsWith('--base-url=') || arg.startsWith('--provider='))
             continue;
         if (!arg.startsWith('--'))
             return arg;

package/dist/core/commands/naruto-command.js

@@ -1,12 +1,20 @@
 import path from 'node:path';
 import { createMission, findLatestMission, loadMission } from '../mission.js';
-import { readJson, sksRoot } from '../fsx.js';
+import { readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { classifyOllamaWorkerSlice } from '../agents/agent-runner-ollama.js';
 import { buildNarutoCloneRoster, systemSafeNarutoConcurrency } from '../agents/agent-roster.js';
 import { DEFAULT_NARUTO_CLONES, MAX_NARUTO_AGENT_COUNT } from '../agents/agent-schema.js';
 import { resolveOllamaWorkerConfig } from '../agents/ollama-worker-config.js';
 import { attachZellijSessionInteractive, launchZellijLayout } from '../zellij/zellij-launcher.js';
+import { buildNarutoWorkGraph } from '../naruto/naruto-work-graph.js';
+import { buildNarutoRoleDistribution } from '../naruto/naruto-role-policy.js';
+import { decideNarutoConcurrency } from '../naruto/naruto-concurrency-governor.js';
+import { simulateNarutoActivePool } from '../naruto/naruto-active-pool.js';
+import { buildNarutoVerificationDag } from '../naruto/naruto-verification-dag.js';
+import { buildNarutoGptFinalPack } from '../naruto/naruto-gpt-final-pack.js';
+import { planNarutoZellijDashboard } from '../zellij/zellij-naruto-dashboard.js';
+import { checkPromptPlaceholders } from '../prompt/prompt-placeholder-guard.js';
 const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
 const NARUTO_ROUTE = '$Naruto';
 // $Naruto — Shadow Clone Swarm (影分身 / Kage Bunshin no Jutsu).
@@ -25,6 +33,27 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
 }
 async function narutoRun(parsed) {
     const root = await sksRoot();
+    const writeCapable = parsed.readonly !== true && parsed.writeMode !== 'off';
+    const placeholderGuard = checkPromptPlaceholders({
+        prompt: parsed.prompt,
+        writeCapable,
+        targetPaths: writeCapable ? ['.sneakoscope/naruto/patch-envelopes'] : []
+    });
+    if (!placeholderGuard.ok) {
+        return emit(parsed, {
+            schema: NARUTO_RESULT_SCHEMA,
+            ok: false,
+            mode: 'NARUTO',
+            action: 'run',
+            status: 'blocked',
+            prompt_placeholder_guard: placeholderGuard,
+            blockers: placeholderGuard.blockers
+        }, () => {
+            console.log('$Naruto blocked before work graph creation: unresolved prompt placeholder or empty write target path.');
+            for (const blocker of placeholderGuard.blockers)
+                console.log('- ' + blocker);
+        });
+    }
     const roster = buildNarutoCloneRoster({
         clones: parsed.clones,
         prompt: parsed.prompt,
@@ -37,9 +66,52 @@ async function narutoRun(parsed) {
     const localWorker = await resolveNarutoLocalWorkerMode(parsed);
     const schedulerBackend = localWorker.auto_select_eligible ? 'ollama' : parsed.backend;
     const safe = systemSafeNarutoConcurrency({ backend: schedulerBackend });
-    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || safe.cap));
+    const workGraph = buildNarutoWorkGraph({
+        prompt: parsed.prompt,
+        requestedClones: roster.agent_count,
+        totalWorkItems: parsed.workItems,
+        readonly: parsed.readonly,
+        writeCapable,
+        targetPaths: ['.sneakoscope/naruto/patch-envelopes'],
+        maxActiveWorkers: parsed.concurrency || safe.cap
+    });
+    const roleDistribution = buildNarutoRoleDistribution(workGraph.work_items, { readonly: parsed.readonly });
+    const governor = decideNarutoConcurrency({
+        requestedClones: roster.agent_count,
+        totalWorkItems: workGraph.total_work_items,
+        pendingWorkQueueSize: workGraph.total_work_items,
+        backend: schedulerBackend
+    });
+    const backendMinimum = schedulerBackend === 'fake' ? roster.agent_count : Math.min(roster.agent_count, 2);
+    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || Math.max(governor.safe_active_workers, backendMinimum), safe.cap));
+    const zellijVisiblePanes = Math.max(1, Math.min(activeSlots, governor.safe_zellij_visible_panes));
+    const activePool = simulateNarutoActivePool({ graph: workGraph, governor: { ...governor, safe_active_workers: activeSlots } });
+    const verificationDag = buildNarutoVerificationDag(workGraph, { cwd: root });
+    const gptFinalPack = buildNarutoGptFinalPack({
+        missionId: 'pending',
+        graph: workGraph,
+        roleDistribution,
+        localLlmMetrics: localWorker
+    });
+    const zellijDashboard = planNarutoZellijDashboard({
+        targetActiveWorkers: activeSlots,
+        visiblePaneCap: governor.safe_zellij_visible_panes,
+        backpressure: governor.backpressure,
+        roles: roleDistribution.work_item_roles.map((row) => row.role),
+        backend: schedulerBackend
+    });
     const mission = await createMission(root, { mode: 'naruto', prompt: parsed.prompt });
     const ledgerRoot = path.join(mission.dir, 'agents');
+    await writeNarutoArtifacts(ledgerRoot, {
+        workGraph,
+        roleDistribution,
+        governor,
+        activePool,
+        verificationDag,
+        gptFinalPack: { ...gptFinalPack, mission_id: mission.id },
+        zellijDashboard,
+        placeholderGuard
+    });
     let liveZellij = null;
     if (!parsed.json && !parsed.mock && !parsed.noOpenZellij) {
         liveZellij = await launchZellijLayout({
@@ -47,12 +119,12 @@ async function narutoRun(parsed) {
             missionId: mission.id,
             ledgerRoot,
             kind: 'naruto',
-            slotCount: roster.agent_count,
+            slotCount: zellijVisiblePanes,
             dryRun: false,
             attach: false
         });
         if (liveZellij?.ok && liveZellij.capability?.status === 'ok') {
-            console.log('Zellij: prepared ' + roster.agent_count + ' live clone lane(s) in ' + liveZellij.session_name + '. Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
+            console.log('Zellij: prepared ' + zellijVisiblePanes + ' visible active clone lane(s) in ' + liveZellij.session_name + ' with ' + Math.max(0, activeSlots - zellijVisiblePanes) + ' headless active worker(s). Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
             if (parsed.attach)
                 attachZellijSessionInteractive(liveZellij.session_name, { cwd: process.cwd(), configPath: liveZellij.clipboard_config_path });
         }
@@ -73,7 +145,7 @@ async function narutoRun(parsed) {
         agents: roster.agent_count,
         concurrency: activeSlots,
         targetActiveSlots: activeSlots,
-        visualLaneCount: roster.agent_count,
+        visualLaneCount: zellijVisiblePanes,
         desiredWorkItemCount: parsed.workItems,
         maxAgentCount: MAX_NARUTO_AGENT_COUNT,
         narutoMode: true,
@@ -109,6 +181,20 @@ async function narutoRun(parsed) {
         target_active_slots: result.target_active_slots ?? activeSlots,
         concurrency_capped: clones > (result.target_active_slots ?? activeSlots),
         system: { cores: safe.cores, free_gb: safe.free_gb, safe_concurrency: safe.cap, heavy_backend: safe.heavy },
+        work_graph: {
+            total_work_items: workGraph.total_work_items,
+            mixed_work_kinds: workGraph.mixed_work_kinds,
+            write_allowed_count: workGraph.write_allowed_count,
+            ok: workGraph.ok
+        },
+        role_distribution: roleDistribution,
+        concurrency_governor: governor,
+        active_pool: {
+            ok: activePool.ok,
+            max_observed_active_workers: activePool.max_observed_active_workers,
+            refill_events: activePool.refill_events,
+            completed_count: activePool.completed_count
+        },
         local_worker: localWorkerSummary,
         proof: result.proof?.status || 'missing',
         run: result,
@@ -120,9 +206,10 @@ async function narutoRun(parsed) {
         console.log('Mission: ' + result.mission_id);
         console.log('Clones: ' + summary.clones + ' / max ' + MAX_NARUTO_AGENT_COUNT + ', running ' + summary.target_active_slots + ' at a time' + (summary.concurrency_capped ? ` (throttled to host capacity: ${safe.cores} cores, ${safe.free_gb} GB free)` : ''));
         console.log('Backend: ' + result.backend);
+        console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
         console.log('Proof: ' + summary.proof);
         if (summary.zellij?.ok && summary.zellij.capability?.status === 'ok')
-            console.log('Zellij: prepared ' + summary.clones + ' native clone lane(s) in ' + summary.zellij.session_name);
+            console.log('Zellij: prepared ' + zellijVisiblePanes + ' visible active clone lane(s) in ' + summary.zellij.session_name + '; dashboard tracks ' + Math.max(0, activeSlots - zellijVisiblePanes) + ' headless active worker(s)');
         else if (summary.zellij?.ok)
             console.log('Zellij: optional live panes unavailable (' + ((summary.zellij.warnings || []).join('; ') || summary.zellij.capability?.status || 'unknown') + ')');
     });
@@ -148,6 +235,9 @@ async function narutoStatus(parsed) {
     const { dir } = await loadMission(root, id);
     const proof = await readJson(path.join(dir, 'agents', 'agent-proof-evidence.json'), null);
     const scheduler = await readJson(path.join(dir, 'agents', 'agent-scheduler-state.json'), null);
+    const roleDistribution = await readJson(path.join(dir, 'agents', 'naruto-role-distribution.json'), null);
+    const workGraph = await readJson(path.join(dir, 'agents', 'naruto-work-graph.json'), null);
+    const governor = await readJson(path.join(dir, 'agents', 'naruto-concurrency-governor.json'), null);
     const summary = {
         schema: NARUTO_RESULT_SCHEMA,
         ok: proof !== null,
@@ -156,13 +246,22 @@ async function narutoStatus(parsed) {
         proof: proof?.status || 'missing',
         target_active_slots: scheduler?.target_active_slots ?? null,
         max_active_slots: scheduler?.max_active_slots ?? null,
-        completed: scheduler?.completed_count ?? null
+        completed: scheduler?.completed_count ?? null,
+        role_distribution: roleDistribution,
+        work_graph: workGraph ? {
+            total_work_items: workGraph.total_work_items,
+            mixed_work_kinds: workGraph.mixed_work_kinds,
+            write_allowed_count: workGraph.write_allowed_count
+        } : null,
+        concurrency_governor: governor
     };
     return emit(parsed, summary, () => {
         console.log('🍥 Naruto mission: ' + id);
         console.log('Proof: ' + summary.proof);
         if (summary.target_active_slots !== null)
             console.log('Active clones: ' + summary.target_active_slots + ' / max ' + summary.max_active_slots);
+        if (roleDistribution?.entries)
+            console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
     });
 }
 async function narutoHelp(parsed) {
@@ -186,6 +285,8 @@ async function narutoHelp(parsed) {
     });
 }
 function parseNarutoArgs(args = []) {
+    if (hasFlag(args, '--help') || hasFlag(args, '-h'))
+        args = ['help', ...args.filter((arg) => arg !== '--help' && arg !== '-h')];
     const first = args[0] && !String(args[0]).startsWith('--') ? String(args[0]) : '';
     const actions = new Set(['run', 'status', 'help']);
     const action = (actions.has(first) ? first : 'run');
@@ -213,6 +314,16 @@ function parseNarutoArgs(args = []) {
     const prompt = positionalArgs(rest, valueFlags).join(' ').trim() || 'Naruto shadow clone swarm run';
     return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach };
 }
+async function writeNarutoArtifacts(ledgerRoot, artifacts) {
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-work-graph.json'), artifacts.workGraph);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-role-distribution.json'), artifacts.roleDistribution);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-concurrency-governor.json'), artifacts.governor);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-active-pool.json'), artifacts.activePool);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-verification-dag.json'), artifacts.verificationDag);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-gpt-final-pack.json'), artifacts.gptFinalPack);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-zellij-dashboard.json'), artifacts.zellijDashboard);
+    await writeJsonAtomic(path.join(ledgerRoot, 'prompt-placeholder-guard.json'), artifacts.placeholderGuard);
+}
 function clampClones(value) {
     if (!Number.isFinite(value) || value < 1)
         return DEFAULT_NARUTO_CLONES;

package/dist/core/commands/run-command.js

@@ -290,7 +290,7 @@ async function runSks(root, commandArgs) {
         cwd: root,
         timeoutMs: 180_000,
         maxOutputBytes: 512 * 1024,
-        env: { SKS_SKIP_NPM_FRESHNESS_CHECK: '1', CI: 'true' },
+        env: { SKS_SKIP_NPM_FRESHNESS_CHECK: '1', SKS_LOCAL_LLM_TOGGLE_ONLY: '1', CI: 'true' },
     });
 }
 function routeExecutionResult(route, command, result, options = {}) {

package/dist/core/doctor/doctor-readiness-matrix.js

@@ -54,6 +54,14 @@ export function buildDoctorReadinessMatrix(input = {}) {
         warnings.add('codex_app_fast_selector_repaired_restart_app_if_needed');
     if (input.codex_lb?.ok === false)
         warnings.add(`codex_lb_${input.codex_lb?.circuit?.state || 'blocked'}`);
+    const localModel = input.local_model || {};
+    const localStatus = String(localModel.status || (localModel.enabled ? 'enabled_unverified' : 'disabled'));
+    if (localModel.enabled === true && localStatus === 'enabled_unverified')
+        warnings.add('local_llm_enabled_unverified');
+    if (localModel.enabled === true && localStatus === 'degraded')
+        warnings.add('local_llm_degraded');
+    if (localModel.enabled === true && localStatus === 'blocked')
+        warnings.add('local_llm_blocked_worker_tier_disabled');
     const localCollaborationPolicy = resolveLocalCollaborationPolicy({ mode: input.local_collaboration?.mode || null });
     const gptFinalAvailable = input.local_collaboration?.gpt_final_arbiter_available === undefined
         ? codexBinOk
@@ -101,12 +109,23 @@ export function buildDoctorReadinessMatrix(input = {}) {
         codex_app_required_for_cli: false,
         local_collaboration: {
             mode: localCollaborationPolicy.mode,
-            local_backend: input.local_collaboration?.local_backend || input.local_model?.provider || 'ollama',
-            local_model: input.local_collaboration?.local_model || input.local_model?.model || null,
+            local_backend: input.local_collaboration?.local_backend || localModel.provider || 'ollama',
+            local_model: input.local_collaboration?.local_model || localModel.model || null,
             final_arbiter: gptFinalAvailable ? 'GPT available' : 'missing',
             final_apply_allowed: localCollaborationPolicy.gpt_final_required ? gptFinalAvailable : localCollaborationPolicy.mode === 'disabled',
             blockers: localCollaborationPolicy.gpt_final_required && !gptFinalAvailable ? ['gpt_final_arbiter_unavailable'] : localCollaborationPolicy.blockers
         },
+        local_llm: {
+            enabled: localModel.enabled === true,
+            status: localStatus,
+            provider: localModel.provider || 'ollama',
+            model: localModel.model || null,
+            endpoint: localModel.endpoint || localModel.base_url || null,
+            last_smoke: localModel.last_smoke || null,
+            final_arbiter: 'GPT required',
+            worker_tier_enabled: localModel.enabled === true && localStatus === 'verified',
+            blockers: normalizeList(localModel.blockers)
+        },
         ready: blockers.size === 0 && cliReady,
         primary_blocker: [...blockers][0] || null,
         blockers: [...blockers],

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '2.0.4';
+export const PACKAGE_VERSION = '2.0.5';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

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

@@ -2,13 +2,18 @@ import { resolveOllamaWorkerConfig } from '../agents/ollama-worker-config.js';
 export async function resolveLocalLlmConfig(input = {}) {
     const config = await resolveOllamaWorkerConfig(input);
     return {
-        schema: 'sks.local-llm-config.v1',
+        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
     };
 }

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