infinicode 2.3.2 → 2.3.4

package/dist/kernel/command-system.js

@@ -8,6 +8,61 @@ function pickMission(kernel, arg, status) {
     const pool = status ? missions.filter(m => m.status === status) : missions;
     return pool[pool.length - 1];
 }
+const NO_MESH = 'Not part of a mesh. Start one with `infinicode serve` (or `infinicode mcp`).';
+/** The command needs the mesh — return the federation or an error result. */
+function needMesh(ctx) {
+    return ctx.federation ?? err(NO_MESH);
+}
+/**
+ * Resolve a node by display name (case-insensitive), nodeId, or nodeId prefix.
+ * "self"/"me"/"this" resolve to this node. Returns undefined if no unique match.
+ */
+function resolveNode(fed, query) {
+    const nodes = fed.nodeStatuses();
+    const self = nodes[0]; // nodeStatuses() lists self first
+    const q = query.trim().toLowerCase();
+    if (q === 'self' || q === 'me' || q === 'this')
+        return self;
+    const exact = nodes.find(n => n.displayName.toLowerCase() === q || n.nodeId.toLowerCase() === q);
+    if (exact)
+        return exact;
+    const prefix = nodes.filter(n => n.nodeId.toLowerCase().startsWith(q) || n.displayName.toLowerCase().startsWith(q));
+    return prefix.length === 1 ? prefix[0] : undefined;
+}
+/** ISO HH:MM:SS from an epoch-ms timestamp. */
+function clock(ts) {
+    return new Date(ts).toISOString().slice(11, 19);
+}
+/** "3s ago" / "2m ago" from an epoch-ms timestamp. */
+function ago(ts) {
+    const s = Math.max(0, Math.round((Date.now() - ts) / 1000));
+    if (s < 60)
+        return `${s}s ago`;
+    if (s < 3600)
+        return `${Math.round(s / 60)}m ago`;
+    return `${Math.round(s / 3600)}h ago`;
+}
+/** One-line rendering of a mesh node status. */
+function nodeLine(n, self = false) {
+    const dot = n.connected || self ? '●' : '○';
+    const load = typeof n.load === 'number' ? `${String(Math.round(n.load)).padStart(3)}%` : '  ?%';
+    const tag = self ? ' (this node)' : '';
+    return `${dot} ${n.displayName.padEnd(16)} ${n.role.padEnd(9)} v${(n.version ?? '?').padEnd(8)} load ${load}  ${ago(n.lastSeenAt)}${tag}`;
+}
+/** Compact one-line summary of an activity stream frame. */
+function frameLine(entry) {
+    const { f } = entry;
+    const kinds = { ev: 'event', hw: 'telem', hb: 'beat', nd: 'nodes', rt: 'route', log: 'log' };
+    const d = f.d;
+    let detail = '';
+    if (f.t === 'ev' && d)
+        detail = `${d.k ?? ''}${d.desc ? ' ' + d.desc : d.run ? ' ' + d.run : ''}`.trim();
+    else if (f.t === 'rt' && d)
+        detail = `${d.model ?? d.node ?? ''}`;
+    else if (f.t === 'log' && d)
+        detail = String(d.msg ?? d.line ?? '');
+    return `${clock(f.ts)} ${f.n.slice(0, 8).padEnd(8)} ${kinds[f.t].padEnd(6)} ${detail}`.trimEnd();
+}
 export const DEFAULT_COMMANDS = [
     {
         name: 'help',
@@ -174,29 +229,278 @@ export const DEFAULT_COMMANDS = [
     {
         name: 'goal',
         aliases: ['g'],
-        description: 'Start and run a new mission from a goal',
+        description: 'Plan a goal into phases and run it (each phase gets its own model tier)',
         usage: '/goal <text>',
         async run({ kernel, args }) {
             const goal = args.join(' ').trim();
             if (!goal)
                 return err('Usage: /goal <text>');
-            const mission = await kernel.execute({
-                description: goal,
-                goal,
-                tasks: [{ description: goal, capabilities: ['reasoning', 'coding'], input: { prompt: goal } }],
-            });
+            // autoPlan → the MissionPlanner decomposes the goal into phases, each
+            // routed to an appropriate model tier by its capabilities.
+            const mission = await kernel.execute({ description: goal, goal, autoPlan: true });
             const done = mission.tasks.filter(t => t.status === 'COMPLETED').length;
+            const phases = mission.objectives
+                .map(o => `${o.phase ?? 'phase'}${o.minBenchmark ? ` ≥${o.minBenchmark}` : ''}`)
+                .join(' → ');
             const preview = mission.tasks
-                .map(t => t.output?.content?.slice(0, 400))
+                .map(t => t.output?.content?.slice(0, 300))
                 .filter(Boolean)
                 .join('\n---\n');
             return {
                 ok: mission.status === 'COMPLETED',
-                text: `Mission ${mission.id} ${mission.status} (${done}/${mission.tasks.length})${preview ? '\n' + preview : ''}`,
+                text: `Mission ${mission.id} ${mission.status} (${done}/${mission.tasks.length})` +
+                    `${phases ? `\nphases: ${phases}` : ''}${preview ? '\n' + preview : ''}`,
                 data: { missionId: mission.id },
             };
         },
     },
+    {
+        name: 'mission',
+        aliases: ['mi'],
+        description: 'Detailed view of one mission (tasks + outputs)',
+        usage: '/mission [missionId|latest]',
+        run({ kernel, args }) {
+            const m = pickMission(kernel, args[0] ?? 'latest');
+            if (!m)
+                return err('No mission found. Start one with /goal <text>.');
+            const done = m.tasks.filter(t => t.status === 'COMPLETED').length;
+            const head = `${m.id} ${m.status} — ${m.name} (${done}/${m.tasks.length} done)`;
+            const tasks = m.tasks.map((t, i) => {
+                const out = t.output?.content?.replace(/\s+/g, ' ').slice(0, 120);
+                const e = t.error ? ` !${t.error.replace(/\s+/g, ' ').slice(0, 80)}` : '';
+                return `  ${String(i + 1).padStart(2)}. [${t.status.padEnd(9)}] ${t.description.slice(0, 60)}${out ? ' → ' + out : ''}${e}`;
+            });
+            return ok(`${head}\n${tasks.join('\n')}`);
+        },
+    },
+    {
+        name: 'nodes',
+        aliases: ['mesh', 'fleet'],
+        description: 'List mesh nodes: role, version, load, last seen',
+        run(ctx) {
+            const fed = needMesh(ctx);
+            if ('ok' in fed)
+                return fed;
+            const nodes = fed.nodeStatuses();
+            if (!nodes.length)
+                return ok('No nodes.');
+            const lines = nodes.map((n, i) => nodeLine(n, i === 0));
+            const connected = nodes.filter((n, i) => i === 0 || n.connected).length;
+            return ok(`${connected}/${nodes.length} node(s) online\n${lines.join('\n')}`);
+        },
+    },
+    {
+        name: 'node',
+        description: 'Inspect a node, run a command on it, or send it a task',
+        usage: '/node <name> [/command | task text]',
+        async run(ctx) {
+            const fed = needMesh(ctx);
+            if ('ok' in fed)
+                return fed;
+            const { kernel, args } = ctx;
+            const name = args[0];
+            if (!name)
+                return err('Usage: /node <name> [/command | task text]');
+            const node = resolveNode(fed, name);
+            if (!node)
+                return err(`No node matching "${name}". Try /nodes.`);
+            const isSelf = node.nodeId === fed.identity.nodeId;
+            const rest = args.slice(1).join(' ').trim();
+            // No payload → show the node's detail card.
+            if (!rest) {
+                const role = isSelf ? fed.getRole() : await fed.getRoleOf(node.nodeId).catch(() => null);
+                const caps = node.capabilities?.length ? [...new Set(node.capabilities)].join(', ') : '—';
+                const lines = [
+                    nodeLine(node, isSelf),
+                    `  id:      ${node.nodeId}`,
+                    `  role:    ${node.role}${role?.role ? ` · agent "${role.role}"` : ''}`,
+                    role?.architecture ? `  arch:    ${role.architecture}` : '',
+                    `  caps:    ${caps}`,
+                    `  cmds:    ${node.commands?.length ?? 0} exposed`,
+                ].filter(Boolean);
+                return ok(lines.join('\n'));
+            }
+            // A slash-command → run it on that node.
+            if (rest.startsWith('/')) {
+                const data = isSelf ? await kernel.command(rest) : await fed.runCommandOn(node.nodeId, rest);
+                const text = data && typeof data === 'object' && 'text' in data
+                    ? String(data.text)
+                    : typeof data === 'string'
+                        ? data
+                        : JSON.stringify(data);
+                return ok(`[${node.displayName}] ${rest}\n${text}`);
+            }
+            // Otherwise → dispatch it as a task to that node.
+            if (isSelf) {
+                const mission = await kernel.execute({
+                    description: rest,
+                    goal: rest,
+                    tasks: [{ description: rest, capabilities: ['reasoning', 'coding'], input: { prompt: rest } }],
+                });
+                const preview = mission.tasks.map(t => t.output?.content?.slice(0, 400)).filter(Boolean).join('\n---\n');
+                return ok(`[${node.displayName}] ${mission.status}\n${preview || '(no output)'}`);
+            }
+            const res = await fed.dispatch({ description: rest, capabilities: ['reasoning', 'coding'], prompt: rest }, { preferNodeId: node.nodeId }, { wait: true, timeoutMs: 180_000 });
+            if (!res)
+                return err(`Dispatch to ${node.displayName} failed (node unreachable or not capable).`);
+            const body = res.record.outputs?.map(o => o.content ?? o.error ?? `[${o.status}]`).join('\n---\n');
+            return ok(`[${node.displayName}] run ${res.runId} ${res.record.status}\n${body || '(no output)'}`);
+        },
+    },
+    {
+        name: 'dispatch',
+        aliases: ['d'],
+        description: 'Send a task to the best-fit node (compute-routed)',
+        usage: '/dispatch <task text>',
+        async run(ctx) {
+            const fed = needMesh(ctx);
+            if ('ok' in fed)
+                return fed;
+            const text = ctx.args.join(' ').trim();
+            if (!text)
+                return err('Usage: /dispatch <task text>');
+            const res = await fed.dispatch({ description: text, capabilities: ['reasoning', 'coding'], prompt: text }, {}, { wait: true, timeoutMs: 180_000 });
+            if (!res)
+                return err('No capable node available to take this task.');
+            const body = res.record.outputs?.map(o => o.content ?? o.error ?? `[${o.status}]`).join('\n---\n');
+            return ok(`dispatched to ${res.peerId} — run ${res.runId} ${res.record.status}\n${body || '(no output)'}`);
+        },
+    },
+    {
+        name: 'build',
+        aliases: ['b'],
+        description: 'Dispatch a PHASED build (auto-planned) to a node — non-blocking',
+        usage: '/build <node> <goal>',
+        async run(ctx) {
+            const fed = needMesh(ctx);
+            if ('ok' in fed)
+                return fed;
+            const name = ctx.args[0];
+            const goal = ctx.args.slice(1).join(' ').trim();
+            if (!name || !goal)
+                return err('Usage: /build <node> <goal>');
+            const node = resolveNode(fed, name);
+            if (!node)
+                return err(`No node matching "${name}". Try /nodes.`);
+            // Non-blocking: the node decomposes the goal into phases and runs them; we
+            // return a runId immediately and monitor via /activity + /running + /follow.
+            const res = await fed.dispatch({ description: goal.slice(0, 80), capabilities: ['architecture', 'coding', 'reasoning'], prompt: goal, autoPlan: true }, { preferNodeId: node.nodeId }, { wait: false });
+            if (!res)
+                return err(`Dispatch to ${node.displayName} failed (node unreachable or not capable).`);
+            return ok(`▶ phased build dispatched to ${node.displayName} — run ${res.runId}\n` +
+                `  monitor live:  /activity\n  in-flight:     /running\n  result:        /follow ${res.runId}`);
+        },
+    },
+    {
+        name: 'follow',
+        aliases: ['f'],
+        description: 'Check a dispatched run\'s status + output',
+        usage: '/follow <runId>',
+        async run(ctx) {
+            const fed = needMesh(ctx);
+            if ('ok' in fed)
+                return fed;
+            const runId = ctx.args[0];
+            if (!runId)
+                return err('Usage: /follow <runId>');
+            const followed = await fed.followRun(runId);
+            if (!followed)
+                return err(`No run ${runId} (unknown or the holding node is gone).`);
+            const r = followed.record;
+            const body = r.outputs?.map(o => o.content ?? o.error ?? `[${o.status}]`).join('\n---\n');
+            return ok(`run ${r.runId} ${r.status}${r.error ? ' — ' + r.error : ''}\n${body || '(no output yet)'}`);
+        },
+    },
+    {
+        name: 'running',
+        aliases: ['ps'],
+        description: 'What is running now: missions, workers, mesh runs',
+        run(ctx) {
+            const { kernel, federation } = ctx;
+            const missions = kernel.listMissions().filter(m => m.status === 'RUNNING' || m.status === 'VERIFYING');
+            const workers = kernel.workerRuntime.getActive();
+            const sections = [];
+            sections.push(missions.length
+                ? `Missions (${missions.length}):\n` +
+                    missions.map(m => `  ${m.id} ${m.status} — ${m.name} (${m.tasks.filter(t => t.status === 'RUNNING').length} task(s) running)`).join('\n')
+                : 'Missions: none running');
+            sections.push(workers.length
+                ? `Workers (${workers.length}):\n` + workers.map(w => `  ${w.type}:${w.status}`).join('\n')
+                : 'Workers: none active');
+            if (federation) {
+                const runs = federation.localRuns().filter(r => r.status === 'running');
+                const out = federation.outboundRuns();
+                sections.push(runs.length
+                    ? `Mesh runs here (${runs.length}):\n` + runs.map(r => `  ${r.runId} — ${r.description.slice(0, 60)} (${ago(r.startedAt)})`).join('\n')
+                    : 'Mesh runs here: none');
+                if (out.length)
+                    sections.push(`Dispatched out (${out.length}):\n` + out.map(o => `  ${o.runId} → ${o.peerId}`).join('\n'));
+            }
+            return ok(sections.join('\n'));
+        },
+    },
+    {
+        name: 'activity',
+        aliases: ['act', 'feed'],
+        description: 'Recent activity across the mesh (or local events)',
+        usage: '/activity [count]',
+        run(ctx) {
+            const n = Math.max(1, Math.min(200, parseInt(ctx.args[0] ?? '20', 10) || 20));
+            if (ctx.federation) {
+                const frames = ctx.federation.recentFrames(n);
+                if (!frames.length)
+                    return ok('No mesh activity yet.');
+                return ok(frames.map(frameLine).join('\n'));
+            }
+            // Stand-alone: fall back to the local event stream.
+            const hist = ctx.kernel.getEventHistory().slice(-n);
+            if (!hist.length)
+                return ok('No activity yet.');
+            return ok(hist
+                .map(e => `${clock(e.timestamp)} ${e.type}${e.missionId ? ' ' + e.missionId : ''}${e.taskId ? '/' + e.taskId : ''}`)
+                .join('\n'));
+        },
+    },
+    {
+        name: 'whoami',
+        aliases: ['me', 'id'],
+        description: 'This node: identity, role, and agent context',
+        run(ctx) {
+            if (!ctx.federation)
+                return ok('Stand-alone kernel (not in a mesh). Run `infinicode serve` to join one.');
+            const id = ctx.federation.identity;
+            const role = ctx.federation.getRole();
+            const peers = ctx.federation.peers().length;
+            const lines = [
+                `${id.displayName} (${id.role})`,
+                `  id:    ${id.nodeId}`,
+                `  peers: ${peers} connected`,
+                role?.role ? `  agent: "${role.role}"` : '',
+                role?.architecture ? `  arch:  ${role.architecture}` : '',
+            ].filter(Boolean);
+            return ok(lines.join('\n'));
+        },
+    },
+    {
+        name: 'role',
+        description: 'Show or set this node\'s persistent agent role/architecture',
+        usage: '/role [name] [architecture…]',
+        run(ctx) {
+            const fed = needMesh(ctx);
+            if ('ok' in fed)
+                return fed;
+            if (!ctx.args.length) {
+                const role = fed.getRole();
+                if (!role?.role)
+                    return ok('No role set. Set one with /role <name> [architecture…].');
+                return ok(`role: "${role.role}"${role.architecture ? `\narch: ${role.architecture}` : ''}`);
+            }
+            const name = ctx.args[0];
+            const architecture = ctx.args.slice(1).join(' ') || undefined;
+            const saved = fed.setRole({ role: name, architecture });
+            return ok(`role set → "${saved.role}"${saved.architecture ? `\narch: ${saved.architecture}` : ''}`);
+        },
+    },
 ];
 export class KernelCommandRegistry {
     kernel;
@@ -220,9 +524,10 @@ export class KernelCommandRegistry {
         return this.commands.get(key) ?? this.commands.get(this.aliases.get(key) ?? '');
     }
     async execute(input) {
+        const federation = this.kernel.federation;
         const trimmed = (input ?? '').trim().replace(/^\//, '').trim();
         if (!trimmed)
-            return this.resolve('help').run({ kernel: this.kernel, args: [], raw: input });
+            return this.resolve('help').run({ kernel: this.kernel, federation, args: [], raw: input });
         const parts = trimmed.split(/\s+/);
         const name = parts[0];
         const args = parts.slice(1);
@@ -230,7 +535,7 @@ export class KernelCommandRegistry {
         if (!cmd)
             return err(`Unknown command: /${name}. Try /help.`);
         try {
-            return await cmd.run({ kernel: this.kernel, args, raw: input });
+            return await cmd.run({ kernel: this.kernel, federation, args, raw: input });
         }
         catch (e) {
             return err(`/${name} failed: ${e instanceof Error ? e.message : String(e)}`);

package/dist/kernel/config-schema.d.ts

@@ -8,6 +8,12 @@ import type { WorkerType } from '../kernel/types.js';
 export interface CloudProviderConfig {
     id: string;
     name: string;
+    /**
+     * Provider kind. 'local' registers the provider as a local (offline-eligible)
+     * endpoint — the router applies its localBonus and 'offline' mode includes it,
+     * and no API key is required. Defaults to 'cloud' when omitted.
+     */
+    type?: 'local' | 'cloud';
     baseURL: string;
     apiKey?: string;
     headerName?: string;
@@ -50,6 +56,11 @@ export interface InfinicodeConfig {
     policy?: string;
     workerModels?: Partial<Record<WorkerType, WorkerModelPref>>;
     cloudProviders?: CloudProviderConfig[];
+    /**
+     * Local OpenAI-compatible servers (LM Studio, vLLM, SGLang, llama.cpp).
+     * Registered with type 'local'; no API key required.
+     */
+    localProviders?: CloudProviderConfig[];
     federation?: FederationConfig;
 }
 export declare const DEFAULT_CONFIG: InfinicodeConfig;

package/dist/kernel/config-schema.js

@@ -7,6 +7,7 @@ export const DEFAULT_CONFIG = {
     policy: 'balanced',
     workerModels: {},
     cloudProviders: [],
+    localProviders: [],
 };
 export const WORKER_TYPES_ORDER = [
     'coding',

package/dist/kernel/federation/event-bridge.js

@@ -2,8 +2,10 @@ import { frame } from './protocol.js';
 /** Events that should render instantly (map animation triggers). */
 const IMMEDIATE = new Set([
     'MISSION_STARTED', 'MISSION_COMPLETED', 'MISSION_FAILED',
+    'PLAN_CREATED', 'OBJECTIVE_STARTED', 'OBJECTIVE_COMPLETED',
     'TASK_STARTED', 'TASK_COMPLETED', 'TASK_FAILED',
-    'WORKER_SPAWNED', 'WORKER_EXITED', 'ROUTING_DECISION', 'RECOVERY', 'NOTIFICATION',
+    'WORKER_SPAWNED', 'WORKER_EXITED', 'ROUTING_DECISION',
+    'MODEL_CHANGED', 'PROVIDER_CHANGED', 'RECOVERY', 'NOTIFICATION',
 ]);
 /** High-frequency, low-value chatter to coalesce. */
 const COALESCE = new Set(['LOG', 'PROVIDER_HEALTH']);

package/dist/kernel/federation/federation.d.ts

@@ -23,6 +23,9 @@ export interface DispatchTask {
     prompt: string;
     role?: string;
     context?: Record<string, unknown>;
+    /** When true, the receiving node auto-plans the goal into phases (a phased
+     *  build) instead of running it as one atomic task. */
+    autoPlan?: boolean;
 }
 export interface FederationOptions {
     version: string;
@@ -100,6 +103,13 @@ export declare class Federation {
         runId: string;
         record: RunRecord;
     } | null>;
+    /** Runs received + executing on THIS node (async handoff), newest last. */
+    localRuns(): RunRecord[];
+    /** Runs WE dispatched to peers → { runId, peerId } for monitoring. */
+    outboundRuns(): Array<{
+        runId: string;
+        peerId: string;
+    }>;
     /** Query a dispatched run's current record (from whichever peer holds it). */
     followRun(runId: string): Promise<{
         record: RunRecord;

package/dist/kernel/federation/federation.js

@@ -61,6 +61,7 @@ export class Federation {
             logger,
             getManifest: () => buildManifest(identity, this.deps.describe()),
             getNodes: () => this.nodeStatuses(),
+            runCommand: (input) => this.deps.kernel.command(input),
             onRpc: (env, remote) => this.onRpc(env, remote),
         });
         await this.server.start();
@@ -174,15 +175,26 @@ export class Federation {
         const localRole = loadRole();
         const preamble = rolePreamble(localRole);
         const prompt = preamble ? `${preamble}\n\n${task.prompt}` : task.prompt;
-        const mission = await this.deps.kernel.execute({
-            description: task.description,
-            goal: task.description,
-            tasks: [{
-                    description: task.description,
-                    capabilities: task.capabilities.length ? task.capabilities : ['reasoning'],
-                    input: { prompt, context: { role: task.role ?? localRole?.role, architecture: localRole?.architecture, ...task.context } },
-                }],
-        });
+        // Auto-planned dispatch → the remote kernel decomposes the goal into phases
+        // (architecture → implementation → verification …), each routed to its own
+        // model tier. The phase/task events stream back to the dispatcher for
+        // monitoring. Otherwise run it as a single atomic task.
+        const mission = task.autoPlan
+            ? await this.deps.kernel.execute({
+                description: task.description,
+                goal: task.prompt || task.description,
+                autoPlan: true,
+                metadata: { role: task.role ?? localRole?.role, architecture: localRole?.architecture, ...task.context },
+            })
+            : await this.deps.kernel.execute({
+                description: task.description,
+                goal: task.description,
+                tasks: [{
+                        description: task.description,
+                        capabilities: task.capabilities.length ? task.capabilities : ['reasoning'],
+                        input: { prompt, context: { role: task.role ?? localRole?.role, architecture: localRole?.architecture, ...task.context } },
+                    }],
+            });
         return {
             missionId: mission.id,
             status: mission.status,
@@ -238,6 +250,14 @@ export class Federation {
         }
         return { peerId: target.nodeId, runId, record };
     }
+    /** Runs received + executing on THIS node (async handoff), newest last. */
+    localRuns() {
+        return [...this.runs.values()];
+    }
+    /** Runs WE dispatched to peers → { runId, peerId } for monitoring. */
+    outboundRuns() {
+        return [...this.dispatchedRuns.entries()].map(([runId, peerId]) => ({ runId, peerId }));
+    }
     /** Query a dispatched run's current record (from whichever peer holds it). */
     async followRun(runId) {
         const local = this.runs.get(runId);

package/dist/kernel/federation/transport-http.d.ts

@@ -9,6 +9,9 @@ export interface MeshServerOptions {
     getManifest: () => NodeManifest;
     /** Optional: full mesh view (self + peers) for the GET /fed/nodes probe. */
     getNodes?: () => unknown;
+    /** Optional: run a kernel slash-command on this node (POST /fed/command).
+     *  Powers the in-TUI mesh command palette. */
+    runCommand?: (input: string) => Promise<unknown>;
     onRpc: RpcHandler;
     logger: Logger;
 }

package/dist/kernel/federation/transport-http.js

@@ -78,6 +78,31 @@ export class MeshServer {
             this.openStream(req, res);
             return;
         }
+        if (req.method === 'POST' && url.startsWith('/fed/command')) {
+            if (!this.opts.runCommand) {
+                res.writeHead(404).end('no command handler');
+                return;
+            }
+            this.readBody(req)
+                .then(async (body) => {
+                let input = '';
+                try {
+                    input = JSON.parse(body).input ?? '';
+                }
+                catch {
+                    res.writeHead(400).end('bad json');
+                    return;
+                }
+                const result = await this.opts.runCommand(input);
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify(result ?? { ok: false, text: 'no result' }));
+            })
+                .catch(err => {
+                this.opts.logger.warn(`[federation] command error: ${err instanceof Error ? err.message : String(err)}`);
+                res.writeHead(500).end('command failed');
+            });
+            return;
+        }
         if (req.method === 'POST' && url.startsWith('/fed/rpc')) {
             this.readBody(req)
                 .then(async (body) => {

package/dist/kernel/free-providers.d.ts

@@ -9,6 +9,11 @@ import type { ProviderModel, WorkerType } from './types.js';
 export interface FreeProviderPreset {
     id: string;
     name: string;
+    /**
+     * Provider kind. 'local' presets register as local (offline-eligible)
+     * providers and require no API key. Defaults to 'cloud' when omitted.
+     */
+    type?: 'local' | 'cloud';
     baseURL: string;
     headerName?: string;
     /** Where to get the API key. */
@@ -24,5 +29,23 @@ export interface FreeProviderPreset {
     notes?: string;
 }
 export declare const FREE_PROVIDERS: FreeProviderPreset[];
+/**
+ * Local OpenAI-compatible servers the wizard can register. These speak the same
+ * /v1/chat/completions + /v1/models API as the cloud providers but run on the
+ * user's machine, so they need NO API key and register with type 'local' (which
+ * makes the router apply its localBonus and include them in 'offline' mode).
+ *
+ * knownModels are intentionally empty: every one of these servers exposes the
+ * currently loaded model(s) dynamically via /v1/models, so there is no fixed
+ * catalog to hard-code. Unreachable servers are marked unhealthy by the health
+ * check and simply skipped by the router.
+ */
+export declare const LOCAL_PROVIDERS: FreeProviderPreset[];
 export declare function getProviderPreset(id: string): FreeProviderPreset | undefined;
+/**
+ * Build ready-to-register config entries for every built-in local provider.
+ * Used to register LM Studio / vLLM / SGLang / llama.cpp out of the box when the
+ * user has not customized `config.localProviders`.
+ */
+export declare function localProviderConfigs(): CloudProviderConfig[];
 export declare function toCloudProviderConfig(preset: FreeProviderPreset, apiKey: string): CloudProviderConfig;

package/dist/kernel/free-providers.js

@@ -147,8 +147,80 @@ export const FREE_PROVIDERS = [
         notes: 'Google Generative Language API. Free tier (15 RPM / 1500 RPD on Flash). Long context.',
     },
 ];
+/**
+ * Local OpenAI-compatible servers the wizard can register. These speak the same
+ * /v1/chat/completions + /v1/models API as the cloud providers but run on the
+ * user's machine, so they need NO API key and register with type 'local' (which
+ * makes the router apply its localBonus and include them in 'offline' mode).
+ *
+ * knownModels are intentionally empty: every one of these servers exposes the
+ * currently loaded model(s) dynamically via /v1/models, so there is no fixed
+ * catalog to hard-code. Unreachable servers are marked unhealthy by the health
+ * check and simply skipped by the router.
+ */
+export const LOCAL_PROVIDERS = [
+    {
+        id: 'lmstudio',
+        name: 'LM Studio',
+        type: 'local',
+        baseURL: 'http://localhost:1234/v1',
+        keyUrl: 'https://lmstudio.ai',
+        free: true,
+        recommended: {},
+        knownModels: [],
+        notes: 'LM Studio local server. Start it from the "Developer" tab. No API key required.',
+    },
+    {
+        id: 'vllm',
+        name: 'vLLM',
+        type: 'local',
+        baseURL: 'http://localhost:8000/v1',
+        keyUrl: 'https://docs.vllm.ai',
+        free: true,
+        recommended: {},
+        knownModels: [],
+        notes: 'vLLM OpenAI-compatible server (`vllm serve <model>`). No API key required.',
+    },
+    {
+        id: 'sglang',
+        name: 'SGLang',
+        type: 'local',
+        baseURL: 'http://localhost:30000/v1',
+        keyUrl: 'https://docs.sglang.ai',
+        free: true,
+        recommended: {},
+        knownModels: [],
+        notes: 'SGLang OpenAI-compatible server (`python -m sglang.launch_server`). No API key required.',
+    },
+    {
+        id: 'llamacpp',
+        name: 'llama.cpp',
+        type: 'local',
+        baseURL: 'http://localhost:8080/v1',
+        keyUrl: 'https://github.com/ggml-org/llama.cpp',
+        free: true,
+        recommended: {},
+        knownModels: [],
+        notes: 'llama.cpp server (`llama-server`). No API key required.',
+    },
+];
 export function getProviderPreset(id) {
-    return FREE_PROVIDERS.find(p => p.id === id);
+    return FREE_PROVIDERS.find(p => p.id === id) ?? LOCAL_PROVIDERS.find(p => p.id === id);
+}
+/**
+ * Build ready-to-register config entries for every built-in local provider.
+ * Used to register LM Studio / vLLM / SGLang / llama.cpp out of the box when the
+ * user has not customized `config.localProviders`.
+ */
+export function localProviderConfigs() {
+    return LOCAL_PROVIDERS.map((preset) => ({
+        id: preset.id,
+        name: preset.name,
+        type: 'local',
+        baseURL: preset.baseURL,
+        headerName: preset.headerName,
+        enabled: true,
+    }));
 }
 export function toCloudProviderConfig(preset, apiKey) {
     return {