infinicode 2.3.1 → 2.3.3

package/dist/kernel/planner.js

@@ -0,0 +1,174 @@
+import { CANONICAL_CAPABILITIES, normalizeCapabilities } from './capability-map.js';
+export class MissionPlanner {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async plan(goal, opts = {}) {
+        const llm = await this.planWithLlm(goal, opts).catch(err => {
+            this.deps.logger.warn(`[planner] LLM planning failed: ${err instanceof Error ? err.message : String(err)}`);
+            return null;
+        });
+        if (llm && llm.length) {
+            this.deps.logger.info(`[planner] LLM decomposed goal into ${llm.length} phase(s): ${llm.map(p => p.name).join(' → ')}`);
+            return llm;
+        }
+        const heuristic = this.heuristicPhases(goal);
+        this.deps.logger.info(`[planner] heuristic plan: ${heuristic.map(p => p.name).join(' → ')}`);
+        return heuristic;
+    }
+    async planWithLlm(goal, opts) {
+        const providers = (await this.deps.providerManager.getHealthyProviders()).map(p => p.info);
+        const models = await this.deps.providerManager.getAvailableModels();
+        if (providers.length === 0 || models.length === 0)
+            return null;
+        // Route the planning call to a capable reasoning model.
+        const decision = await this.deps.router.route({
+            capabilities: ['planning', 'reasoning'],
+            preferences: { reasoning: 85 },
+            policy: opts.policy ?? { name: 'balanced', routing: { mode: 'balanced' } },
+            availableProviders: providers,
+            availableModels: models,
+            minBenchmark: 82,
+        });
+        if (!decision)
+            return null;
+        const provider = this.deps.providerManager.get(decision.providerId);
+        if (!provider)
+            return null;
+        const maxPhases = opts.maxPhases ?? 6;
+        const request = {
+            model: decision.modelId,
+            systemPrompt: 'You are a senior software project planner for an execution kernel. Break the goal into 2–' +
+                `${maxPhases} sequential PHASES. Reply with ONLY minified JSON, no prose, of the form: ` +
+                '{"phases":[{"name":"...","description":"...","capabilities":["..."],"dependsOn":["<earlier phase name>"],"acceptanceCriteria":["..."]}]}. ' +
+                'Order phases so later ones dependsOn earlier ones. Prefer capability names from this list where they fit: ' +
+                CANONICAL_CAPABILITIES.join(', ') +
+                '. You may also use natural terms like backend, ui, tests, devops. Keep it concise and buildable.',
+            prompt: `Goal: ${goal}${opts.description ? `\nContext: ${opts.description}` : ''}\n\nPhased plan (JSON):`,
+            maxTokens: 1200,
+            temperature: 0.2,
+        };
+        const result = await provider.complete(request);
+        const parsed = this.parsePhases(result.content);
+        if (!parsed || parsed.length === 0)
+            return null;
+        return parsed.slice(0, maxPhases);
+    }
+    /** Extract + validate a phase array from a model's (possibly noisy) response. */
+    parsePhases(text) {
+        const json = extractJson(text);
+        if (!json)
+            return null;
+        let raw;
+        try {
+            raw = JSON.parse(json);
+        }
+        catch {
+            return null;
+        }
+        const list = Array.isArray(raw)
+            ? raw
+            : Array.isArray(raw?.phases)
+                ? raw.phases
+                : null;
+        if (!list)
+            return null;
+        const phases = [];
+        const seen = new Set();
+        for (const item of list) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const p = item;
+            const name = String(p.name ?? p.phase ?? `phase-${phases.length + 1}`).trim().slice(0, 40);
+            if (!name || seen.has(name.toLowerCase()))
+                continue;
+            seen.add(name.toLowerCase());
+            const description = String(p.description ?? name).trim();
+            const capabilities = Array.isArray(p.capabilities) ? p.capabilities.map(String) : undefined;
+            const dependsOn = Array.isArray(p.dependsOn) ? p.dependsOn.map(String) : undefined;
+            const acceptanceCriteria = Array.isArray(p.acceptanceCriteria)
+                ? p.acceptanceCriteria.map(String)
+                : undefined;
+            phases.push({ name, description, capabilities, dependsOn, acceptanceCriteria });
+        }
+        return phases.length ? phases : null;
+    }
+    /**
+     * Deterministic fallback plan. Always yields buildable phases; adds a frontend
+     * phase for UI-shaped goals. Capabilities are natural — the scheduler
+     * normalizes them and derives each phase's model tier.
+     */
+    heuristicPhases(goal) {
+        const g = goal.toLowerCase();
+        const isUi = /\b(ui|ux|frontend|front-end|web|website|page|css|react|vue|svelte|design|dashboard|landing)\b/.test(g);
+        const phases = [
+            {
+                name: 'architecture',
+                description: `Plan the architecture, approach, and file/component breakdown for: ${goal}`,
+                capabilities: ['architecture', 'planning', 'reasoning'],
+                acceptanceCriteria: ['A concrete plan / component breakdown exists'],
+            },
+            {
+                name: 'implementation',
+                description: `Implement the core of: ${goal}`,
+                capabilities: ['coding', 'filesystem', 'terminal', 'reasoning'],
+                dependsOn: ['architecture'],
+                acceptanceCriteria: ['Core functionality is implemented'],
+            },
+        ];
+        if (isUi) {
+            phases.push({
+                name: 'frontend',
+                description: `Build the user interface for: ${goal}`,
+                capabilities: ['frontend', 'design', 'accessibility'],
+                dependsOn: ['architecture'],
+                acceptanceCriteria: ['A polished, responsive, accessible UI'],
+            });
+        }
+        phases.push({
+            name: 'verification',
+            description: `Test, review, and verify the implementation of: ${goal}`,
+            capabilities: ['verification', 'review', 'reasoning'],
+            dependsOn: isUi ? ['implementation', 'frontend'] : ['implementation'],
+            acceptanceCriteria: ['Builds, tests pass, and the goal is met'],
+        });
+        return phases;
+    }
+}
+/** Pull the first balanced JSON object/array out of a text blob. */
+function extractJson(text) {
+    const trimmed = text.trim().replace(/^```(?:json)?/i, '').replace(/```$/, '').trim();
+    const start = trimmed.search(/[[{]/);
+    if (start === -1)
+        return null;
+    const open = trimmed[start];
+    const close = open === '{' ? '}' : ']';
+    let depth = 0;
+    let inStr = false;
+    let esc = false;
+    for (let i = start; i < trimmed.length; i++) {
+        const ch = trimmed[i];
+        if (inStr) {
+            if (esc)
+                esc = false;
+            else if (ch === '\\')
+                esc = true;
+            else if (ch === '"')
+                inStr = false;
+            continue;
+        }
+        if (ch === '"')
+            inStr = true;
+        else if (ch === open)
+            depth++;
+        else if (ch === close) {
+            depth--;
+            if (depth === 0)
+                return trimmed.slice(start, i + 1);
+        }
+    }
+    return null;
+}
+// Re-export so harnesses can normalize capabilities the same way.
+export { normalizeCapabilities };

package/dist/kernel/recovery-manager.d.ts

@@ -27,6 +27,8 @@ export interface RecoveryContext {
     policy: Policy;
     currentProviderId?: string;
     currentModelId?: string;
+    /** How many times this task has failed verification — drives model escalation. */
+    verificationFailures?: number;
 }
 export declare class RecoveryManager {
     private deps;
@@ -34,5 +36,12 @@ export declare class RecoveryManager {
     classify(error: string): FailureType;
     decide(ctx: RecoveryContext): Promise<RecoveryDecision>;
     private findAlternateProvider;
+    /**
+     * Find a strictly MORE capable model than the one that just failed
+     * verification — the escalation ladder. Ranks across all healthy providers by
+     * benchmark and returns the best above the current model's tier, or null at
+     * the ceiling.
+     */
+    private findMoreCapableModel;
     private findAlternateWorker;
 }

package/dist/kernel/recovery-manager.js

@@ -33,6 +33,7 @@ export class RecoveryManager {
         let rotateToProviderId;
         let rotateToModelId;
         let newWorkerType;
+        let escalateToBenchmark;
         switch (failureType) {
             case '429':
             case 'provider-down': {
@@ -61,9 +62,22 @@ export class RecoveryManager {
                 break;
             }
             case 'hallucination':
-            case 'tool-failure':
             case 'verification-failure': {
-                if (belowLimit) {
+                // Quality failures usually mean the model isn't strong enough. After the
+                // first verification miss, climb the benchmark ladder to a MORE capable
+                // model before anything else; only swap worker type if we're at the top.
+                const vFails = ctx.verificationFailures ?? 0;
+                // Escalate after MULTIPLE verification misses — the first miss retries or
+                // swaps worker; the second climbs to a more capable model.
+                const better = vFails >= 2 ? await this.findMoreCapableModel(ctx) : null;
+                if (better) {
+                    action = 'escalate-model';
+                    reason = `${failureType}: escalate → ${better.providerId}/${better.modelId} (bench ${better.benchmarkScore})`;
+                    rotateToProviderId = better.providerId;
+                    rotateToModelId = better.modelId;
+                    escalateToBenchmark = better.benchmarkScore;
+                }
+                else if (belowLimit) {
                     const altType = this.findAlternateWorker(ctx);
                     if (altType) {
                         action = 'spawn-different-worker';
@@ -77,7 +91,26 @@ export class RecoveryManager {
                 }
                 else {
                     action = 'replan';
-                    reason = `${failureType}: attempts exhausted → replan`;
+                    reason = `${failureType}: attempts exhausted, at model ceiling → replan`;
+                }
+                break;
+            }
+            case 'tool-failure': {
+                if (belowLimit) {
+                    const altType = this.findAlternateWorker(ctx);
+                    if (altType) {
+                        action = 'spawn-different-worker';
+                        reason = `tool-failure: spawn ${altType} worker`;
+                        newWorkerType = altType;
+                    }
+                    else {
+                        action = 'retry';
+                        reason = `tool-failure: retry (attempt ${ctx.attempts}/${maxAttempts})`;
+                    }
+                }
+                else {
+                    action = 'replan';
+                    reason = 'tool-failure: attempts exhausted → replan';
                 }
                 break;
             }
@@ -102,6 +135,7 @@ export class RecoveryManager {
             rotateToProviderId,
             rotateToModelId,
             newWorkerType,
+            escalateToBenchmark,
         };
         this.deps.eventBus.emit({
             type: 'RECOVERY',
@@ -135,6 +169,33 @@ export class RecoveryManager {
             return null;
         return { providerId: ranked[0].providerId, modelId: ranked[0].modelId };
     }
+    /**
+     * Find a strictly MORE capable model than the one that just failed
+     * verification — the escalation ladder. Ranks across all healthy providers by
+     * benchmark and returns the best above the current model's tier, or null at
+     * the ceiling.
+     */
+    async findMoreCapableModel(ctx) {
+        const providers = (await this.deps.providerManager.getHealthyProviders()).map(p => p.info);
+        const models = await this.deps.providerManager.getAvailableModels();
+        if (providers.length === 0 || models.length === 0)
+            return null;
+        const escalated = this.deps.router.escalate({
+            capabilities: ctx.task.capabilities,
+            preferences: { reasoning: 85 },
+            policy: ctx.policy,
+            availableProviders: providers,
+            availableModels: models,
+            minBenchmark: ctx.task.minBenchmark,
+        }, ctx.currentProviderId, ctx.currentModelId);
+        if (!escalated)
+            return null;
+        return {
+            providerId: escalated.providerId,
+            modelId: escalated.modelId,
+            benchmarkScore: escalated.benchmarkScore,
+        };
+    }
     findAlternateWorker(ctx) {
         const current = this.deps.workerRuntime.getHandler(this.deps.workerRuntime.matchWorkerType(ctx.task.capabilities) ?? 'coding');
         if (!current)

package/dist/kernel/router.d.ts

@@ -12,7 +12,7 @@
  * Every policy auto-routes across all healthy providers. The single exception
  * is the `offline` mode, which is LOCKED to local providers.
  */
-import type { ProviderInfo, RoutingDecision, RoutingRequest } from './types.js';
+import type { ProviderInfo, ProviderModel, RoutingDecision, RoutingRequest } from './types.js';
 import type { Logger } from './types.js';
 export declare class CapabilityRouter {
     private logger;
@@ -22,6 +22,17 @@ export declare class CapabilityRouter {
         providerInfo: ProviderInfo;
         benchmarkScore: number;
     }>;
+    /** Public benchmark estimate for a model (0–100) — used by recovery/escalation. */
+    benchmarkFor(model: ProviderModel): number;
+    /**
+     * Pick a strictly MORE capable model than the current one for the same
+     * capabilities — the verification-failure escalation ladder. Ranks candidates
+     * whose benchmark exceeds the current model's, preferring the highest
+     * benchmark (tie-broken by overall score). Returns null at the ceiling.
+     */
+    escalate(request: RoutingRequest, currentProviderId?: string, currentModelId?: string): (RoutingDecision & {
+        benchmarkScore: number;
+    }) | null;
     private scoreCandidates;
     private capabilityScore;
     /**

package/dist/kernel/router.js

@@ -41,6 +41,34 @@ export class CapabilityRouter {
             benchmarkScore: c.benchmarkScore,
         }));
     }
+    /** Public benchmark estimate for a model (0–100) — used by recovery/escalation. */
+    benchmarkFor(model) {
+        return this.estimateBenchmark(model);
+    }
+    /**
+     * Pick a strictly MORE capable model than the current one for the same
+     * capabilities — the verification-failure escalation ladder. Ranks candidates
+     * whose benchmark exceeds the current model's, preferring the highest
+     * benchmark (tie-broken by overall score). Returns null at the ceiling.
+     */
+    escalate(request, currentProviderId, currentModelId) {
+        const current = request.availableModels.find(m => m.providerId === currentProviderId && m.id === currentModelId);
+        const currentBench = current ? this.estimateBenchmark(current) : (request.minBenchmark ?? 0);
+        const candidates = this.scoreCandidates(request)
+            .filter(c => !(c.providerId === currentProviderId && c.modelId === currentModelId))
+            .filter(c => c.benchmarkScore > currentBench + 1)
+            .sort((a, b) => b.benchmarkScore - a.benchmarkScore || b.score - a.score);
+        const top = candidates[0];
+        if (!top)
+            return null;
+        return {
+            providerId: top.providerId,
+            modelId: top.modelId,
+            score: top.score,
+            benchmarkScore: top.benchmarkScore,
+            reason: `escalate ↑bench ${currentBench}→${top.benchmarkScore}: ${top.reason}`,
+        };
+    }
     scoreCandidates(request) {
         const { capabilities, preferences, policy, availableProviders, availableModels } = request;
         const mode = (policy.routing?.mode ?? 'balanced');
@@ -86,6 +114,12 @@ export class CapabilityRouter {
             // Heavy penalty when the model can't fit the estimated request — keeps it
             // as a last resort but routes to a capable model when one exists.
             const capacityPenalty = needTokens > 0 && effectiveLimit < needTokens ? 6 : 0;
+            // Phase/escalation floor: models below the requested benchmark are pushed
+            // down (proportional, not hard-excluded) so demanding phases climb to a
+            // capable model and the escalation ladder can keep ascending.
+            const floorPenalty = request.minBenchmark && benchmark < request.minBenchmark
+                ? (request.minBenchmark - benchmark) / 5
+                : 0;
             const score = capScore * weights.capability +
                 benchScore * weights.benchmark +
                 reliability * weights.reliability +
@@ -96,7 +130,8 @@ export class CapabilityRouter {
                 preferredBonus +
                 fastApiBonus -
                 costPenalty -
-                capacityPenalty;
+                capacityPenalty -
+                floorPenalty;
             scored.push({
                 providerId: provider.id,
                 modelId: model.id,

package/dist/kernel/scheduler.d.ts

@@ -8,6 +8,13 @@ export declare class Scheduler {
         objectives: Objective[];
         tasks: Task[];
     };
+    /**
+     * Build one objective per phase. Capabilities are normalized (natural names
+     * allowed), each phase's tasks depend on ALL tasks of the phases it dependsOn
+     * (so phases run in order but tasks within a phase can parallelize), and each
+     * phase gets its own model benchmark floor → different models per phase.
+     */
+    private planPhases;
     createTask(missionId: string, objectiveId: string, description: string, capabilities: Capability[], dependencies: string[], input: TaskInput): Task;
     /**
      * Returns the next batch of tasks that are ready to execute:
@@ -28,3 +35,13 @@ export declare class Scheduler {
     reconcileObjectives(mission: Mission): void;
     private aggregateCapabilities;
 }
+/**
+ * Per-phase model benchmark floor (0–100). Demanding phases (architecture,
+ * verification, review, reasoning-heavy) demand a more capable model; lighter
+ * phases (docs, translation, plain search) leave the floor open so the router
+ * can pick a cheaper/faster model. This is what lets one large mission spread
+ * across models by aspect instead of one-shotting with a single model.
+ */
+export declare function phaseBenchmarkFloor(caps: Capability[]): number;
+/** Human-readable phase label from an objective's dominant capability. */
+export declare function phaseLabel(caps: Capability[]): string;

package/dist/kernel/scheduler.js

@@ -5,6 +5,7 @@
  * Supports: sequential, parallel, dependency graphs
  */
 import { nanoid } from 'nanoid';
+import { normalizeCapabilities } from './capability-map.js';
 export class Scheduler {
     eventBus;
     logger;
@@ -13,27 +14,81 @@ export class Scheduler {
         this.logger = logger;
     }
     planMission(missionId, input) {
+        // Phase-based plan (each phase → one objective, with cross-phase deps).
+        if (input.phases && input.phases.length > 0) {
+            return this.planPhases(missionId, input.phases);
+        }
         const taskInputs = input.tasks ?? [];
         const objectiveId = nanoid(10);
         const tasks = [];
         for (const ti of taskInputs) {
             tasks.push(this.createTask(missionId, objectiveId, ti.description, ti.capabilities, ti.dependencies ?? [], ti.input));
         }
+        const objCaps = this.aggregateCapabilities(tasks);
         const objective = {
             id: objectiveId,
             missionId,
             description: input.goal,
-            capabilities: this.aggregateCapabilities(tasks),
+            capabilities: objCaps,
             acceptanceCriteria: [],
             taskIds: tasks.map(t => t.id),
             status: tasks.length > 0 ? 'PENDING' : 'COMPLETED',
             createdAt: Date.now(),
+            phase: phaseLabel(objCaps),
+            minBenchmark: tasks.reduce((max, t) => Math.max(max, t.minBenchmark ?? 0), 0) || undefined,
         };
         this.logger.info(`Mission planned: ${missionId} with ${tasks.length} task(s) across 1 objective`);
         return { objectives: [objective], tasks };
     }
+    /**
+     * Build one objective per phase. Capabilities are normalized (natural names
+     * allowed), each phase's tasks depend on ALL tasks of the phases it dependsOn
+     * (so phases run in order but tasks within a phase can parallelize), and each
+     * phase gets its own model benchmark floor → different models per phase.
+     */
+    planPhases(missionId, phases) {
+        const objectives = [];
+        const tasks = [];
+        const phaseTaskIds = new Map(); // phase name (lower) → task ids
+        for (const phase of phases) {
+            const objectiveId = nanoid(10);
+            const phaseCaps = normalizeCapabilities(phase.capabilities);
+            const deps = (phase.dependsOn ?? []).flatMap(n => phaseTaskIds.get(n.trim().toLowerCase()) ?? []);
+            const taskInputs = phase.tasks && phase.tasks.length > 0
+                ? phase.tasks
+                : [{ description: phase.description, capabilities: phaseCaps, input: { prompt: phase.description } }];
+            const phaseTasks = taskInputs.map(ti => {
+                const tCaps = ti.capabilities && ti.capabilities.length > 0
+                    ? normalizeCapabilities(ti.capabilities)
+                    : phaseCaps;
+                const task = this.createTask(missionId, objectiveId, ti.description, tCaps, [...deps, ...(ti.dependencies ?? [])], ti.input ?? { prompt: ti.description });
+                // Explicit phase floor overrides the capability-derived one.
+                if (phase.minBenchmark)
+                    task.minBenchmark = phase.minBenchmark;
+                return task;
+            });
+            tasks.push(...phaseTasks);
+            phaseTaskIds.set(phase.name.trim().toLowerCase(), phaseTasks.map(t => t.id));
+            const derivedFloor = phaseTasks.reduce((max, t) => Math.max(max, t.minBenchmark ?? 0), 0);
+            objectives.push({
+                id: objectiveId,
+                missionId,
+                description: phase.description,
+                capabilities: phaseCaps,
+                acceptanceCriteria: phase.acceptanceCriteria ?? [],
+                taskIds: phaseTasks.map(t => t.id),
+                status: phaseTasks.length > 0 ? 'PENDING' : 'COMPLETED',
+                createdAt: Date.now(),
+                phase: phase.name,
+                minBenchmark: (phase.minBenchmark ?? derivedFloor) || undefined,
+            });
+        }
+        this.logger.info(`Mission planned: ${missionId} with ${tasks.length} task(s) across ${objectives.length} phase(s): ${phases.map(p => p.name).join(' → ')}`);
+        return { objectives, tasks };
+    }
     createTask(missionId, objectiveId, description, capabilities, dependencies, input) {
         const id = nanoid(10);
+        const floor = phaseBenchmarkFloor(capabilities);
         const task = {
             id,
             objectiveId,
@@ -46,6 +101,7 @@ export class Scheduler {
             attempts: 0,
             maxAttempts: 3,
             createdAt: Date.now(),
+            minBenchmark: floor > 0 ? floor : undefined,
         };
         this.eventBus.emit({ type: 'TASK_QUEUED', timestamp: Date.now(), missionId, objectiveId, taskId: id, data: { description } });
         return task;
@@ -145,3 +201,43 @@ export class Scheduler {
         return [...set];
     }
 }
+/**
+ * Per-phase model benchmark floor (0–100). Demanding phases (architecture,
+ * verification, review, reasoning-heavy) demand a more capable model; lighter
+ * phases (docs, translation, plain search) leave the floor open so the router
+ * can pick a cheaper/faster model. This is what lets one large mission spread
+ * across models by aspect instead of one-shotting with a single model.
+ */
+export function phaseBenchmarkFloor(caps) {
+    const has = (c) => caps.includes(c);
+    if (has('architecture') || has('planning'))
+        return 85;
+    if (has('verification') || has('review'))
+        return 84;
+    if (has('coding') || has('frontend'))
+        return 78;
+    if (has('vision') || has('ocr'))
+        return 74;
+    if (has('reasoning'))
+        return 80;
+    return 0; // search / crawl / summarize / documentation / translation → open
+}
+/** Human-readable phase label from an objective's dominant capability. */
+export function phaseLabel(caps) {
+    const has = (c) => caps.includes(c);
+    if (has('architecture') || has('planning'))
+        return 'architecture';
+    if (has('frontend'))
+        return 'frontend';
+    if (has('coding'))
+        return 'implementation';
+    if (has('verification') || has('review'))
+        return 'verification';
+    if (has('vision') || has('ocr'))
+        return 'vision';
+    if (has('search') || has('crawl'))
+        return 'research';
+    if (has('documentation') || has('translation'))
+        return 'documentation';
+    return 'general';
+}

package/dist/kernel/setup.d.ts

@@ -15,6 +15,15 @@ export type { InfinicodeConfig, CloudProviderConfig, WorkerModelPref } from './c
  * count of enabled providers registered.
  */
 export declare function registerCloudProviders(kernel: Kernel, cloudProviders: CloudProviderConfig[]): number;
+/**
+ * Register (or re-register) local OpenAI-compatible providers (LM Studio, vLLM,
+ * SGLang, llama.cpp) on a live kernel from config. Providers register with
+ * type 'local' and require NO API key — they are never skipped for a missing
+ * key the way cloud providers can be, and the local server does not need to be
+ * running (unreachable ones are marked unhealthy by the health check). Returns
+ * the count of enabled providers registered.
+ */
+export declare function registerLocalProviders(kernel: Kernel, localProviders: CloudProviderConfig[]): number;
 export declare function buildKernelFromConfig(config: Conf<InfinicodeConfig>, options?: {
     logger?: Logger;
 }): Kernel;

package/dist/kernel/setup.js

@@ -27,6 +27,35 @@ export function registerCloudProviders(kernel, cloudProviders) {
         const options = {
             id: cfg.id,
             name: cfg.name,
+            type: cfg.type,
+            baseURL: cfg.baseURL,
+            apiKey: cfg.apiKey,
+            headerName: cfg.headerName,
+            knownModels: preset?.knownModels ?? [],
+        };
+        kernel.registerProvider(cfg.id, new OpenAICompatibleProvider(options));
+        n++;
+    }
+    return n;
+}
+/**
+ * Register (or re-register) local OpenAI-compatible providers (LM Studio, vLLM,
+ * SGLang, llama.cpp) on a live kernel from config. Providers register with
+ * type 'local' and require NO API key — they are never skipped for a missing
+ * key the way cloud providers can be, and the local server does not need to be
+ * running (unreachable ones are marked unhealthy by the health check). Returns
+ * the count of enabled providers registered.
+ */
+export function registerLocalProviders(kernel, localProviders) {
+    let n = 0;
+    for (const cfg of localProviders) {
+        if (!cfg.enabled)
+            continue;
+        const preset = getProviderPreset(cfg.id);
+        const options = {
+            id: cfg.id,
+            name: cfg.name,
+            type: 'local',
             baseURL: cfg.baseURL,
             apiKey: cfg.apiKey,
             headerName: cfg.headerName,
@@ -52,6 +81,15 @@ export function buildKernelFromConfig(config, options) {
     kernel.registerProvider('ollama', new OllamaProvider(ollamaOptions));
     // Register cloud providers
     registerCloudProviders(kernel, config.get('cloudProviders') ?? []);
+    // Register local OpenAI-compatible providers (LM Studio, vLLM, SGLang,
+    // llama.cpp) the user has configured in `localProviders`. No API key is
+    // required; an unreachable server is marked unhealthy by the health check.
+    // Only configured ones are registered — this avoids probing dead localhost
+    // ports on every machine. The presets (`localProviderConfigs()` in
+    // free-providers.ts / the setup wizard) make enabling one a one-liner.
+    const localProviders = config.get('localProviders') ?? [];
+    if (localProviders.length > 0)
+        registerLocalProviders(kernel, localProviders);
     // Apply per-worker model pins — the worker runtime honors them when routing.
     const workerModels = config.get('workerModels') ?? {};
     if (workerModels && Object.keys(workerModels).length > 0) {