infinicode 2.3.2 → 2.3.3

package/dist/cli.js

@@ -16,7 +16,7 @@ import { serve } from './commands/serve.js';
 import { mcpCommand } from './commands/mcp.js';
 import { installTui } from './commands/install-tui.js';
 import { DEFAULT_CONFIG } from './kernel/config-schema.js';
-const VERSION = '2.3.2';
+const VERSION = '2.3.3';
 const config = new Conf({
     projectName: 'infinicode',
     defaults: DEFAULT_CONFIG,
@@ -291,6 +291,7 @@ program
     .option('--lan', 'auto-discover + connect peers on the same LAN via UDP broadcast (no seed/Tailscale needed)')
     .option('--lan-port <port>', 'UDP discovery port for --lan (default 47915)')
     .option('--tag <tag>', 'only discover peers carrying this tag (Tailscale ACL tag or LAN beacon tag)')
+    .option('--console', 'interactive slash-command console on the node (/nodes, /build, /activity …); on by default in a TTY')
     .option('--gateway <url>', 'link to an InfiniBot gateway (ws://host:18789) — appear on its neural-mesh map')
     .option('--gateway-token <token>', 'auth token for the InfiniBot gateway')
     .option('--gateway-password <password>', 'auth password for the InfiniBot gateway')

package/dist/commands/mcp.js

@@ -72,6 +72,8 @@ export async function mcpCommand(config, opts) {
         logger: stderrLogger,
         options: { version, port, token, autoUpdate: fed.autoUpdate, applyConfig, autoPullConfig: role === 'satellite' },
     });
+    // Let the kernel's slash-command surface reach the mesh (/nodes, /node, …).
+    kernel.attachFederation(federation);
     // Hub/peer/relay: publish local providers + policy for satellites to source.
     const sharedFromConf = () => ({
         cloudProviders: config.get('cloudProviders'),

package/dist/commands/serve.d.ts

@@ -13,6 +13,7 @@ export interface ServeOptions {
     tag?: string;
     lan?: boolean;
     lanPort?: string;
+    console?: boolean;
     gateway?: string;
     gatewayToken?: string;
     gatewayPassword?: string;

package/dist/commands/serve.js

@@ -77,6 +77,8 @@ export async function serve(config, opts) {
             autoPullConfig: role === 'satellite',
         },
     });
+    // Let the kernel's slash-command surface reach the mesh (/nodes, /node, …).
+    kernel.attachFederation(federation);
     // Hub/peer/relay: publish this machine's providers + policy so satellites can
     // auto-source them. Re-publish when the local config changes (live).
     const sharedFromConf = () => ({
@@ -133,7 +135,6 @@ export async function serve(config, opts) {
         connector.start();
         console.log(chalk.green(`  ✓ linking to InfiniBot gateway ${opts.gateway}`));
     }
-    console.log(chalk.dim(`\n  mesh online — Ctrl-C to stop. Peers: ${federation.peers().length}\n`));
     const shutdown = async () => {
         console.log(chalk.dim('\n  stopping mesh…'));
         connector?.stop();
@@ -143,6 +144,40 @@ export async function serve(config, opts) {
     };
     process.on('SIGINT', () => void shutdown());
     process.on('SIGTERM', () => void shutdown());
+    // Interactive slash-command console on the live mesh node: type /nodes,
+    // /build <node> <goal>, /activity, /running, /follow <id>, etc. Enabled with
+    // --console (or automatically when stdin is a TTY).
+    if (opts.console ?? process.stdin.isTTY) {
+        const { createInterface } = await import('node:readline');
+        console.log(chalk.dim(`\n  mesh online — slash-command console ready. Type /help or /nodes. Ctrl-C to stop. Peers: ${federation.peers().length}\n`));
+        const rl = createInterface({ input: process.stdin, output: process.stdout, prompt: chalk.cyan('mesh> ') });
+        rl.prompt();
+        rl.on('line', async (line) => {
+            const input = line.trim();
+            if (!input) {
+                rl.prompt();
+                return;
+            }
+            if (input === 'exit' || input === 'quit') {
+                await shutdown();
+                return;
+            }
+            rl.pause();
+            try {
+                const result = await kernel.command(input.startsWith('/') ? input : '/' + input);
+                console.log((result.ok ? chalk.reset : chalk.yellow)(result.text));
+            }
+            catch (err) {
+                console.log(chalk.red(err instanceof Error ? err.message : String(err)));
+            }
+            rl.resume();
+            rl.prompt();
+        });
+        rl.on('close', () => void shutdown());
+    }
+    else {
+        console.log(chalk.dim(`\n  mesh online — Ctrl-C to stop. Peers: ${federation.peers().length}\n`));
+    }
     // Keep the process alive.
     await new Promise(() => { });
 }

package/dist/kernel/capability-map.d.ts

@@ -0,0 +1,18 @@
+/**
+ * OpenKernel — Capability Normalization
+ *
+ * Harness-friendly capability passing. A phase (from a harness like InfiniBot,
+ * or from the LLM planner) can name what it needs in natural terms — "backend",
+ * "ui", "testing", "devops" — and this maps them onto the kernel's canonical
+ * capability vocabulary so the router/worker-matcher understand them. Unknown
+ * terms fall back to a fuzzy canonical match, then to `reasoning`.
+ */
+import type { Capability } from './types.js';
+/** The kernel's canonical capability vocabulary (mirrors the Capability union). */
+export declare const CANONICAL_CAPABILITIES: Capability[];
+/**
+ * Normalize natural capability names to canonical capabilities. Accepts canonical
+ * names as-is, maps known synonyms, fuzzy-matches by substring, and guarantees a
+ * non-empty result (falls back to `['reasoning']`).
+ */
+export declare function normalizeCapabilities(input?: string[]): Capability[];

package/dist/kernel/capability-map.js

@@ -0,0 +1,84 @@
+/** The kernel's canonical capability vocabulary (mirrors the Capability union). */
+export const CANONICAL_CAPABILITIES = [
+    'coding', 'browser', 'vision', 'terminal', 'planning', 'reasoning', 'filesystem',
+    'search', 'crawl', 'ocr', 'review', 'summarize', 'citations', 'translation',
+    'documentation', 'architecture', 'verification', 'frontend', 'design',
+    'accessibility', 'dataviz', 'animation',
+];
+/** Natural-language / domain terms → canonical capabilities. */
+const SYNONYMS = {
+    // engineering domains
+    backend: ['coding', 'terminal', 'filesystem', 'reasoning'],
+    'back-end': ['coding', 'terminal', 'filesystem', 'reasoning'],
+    server: ['coding', 'terminal', 'filesystem'],
+    api: ['coding', 'reasoning'],
+    ui: ['frontend', 'design'],
+    ux: ['frontend', 'design', 'accessibility'],
+    'front-end': ['frontend', 'design'],
+    web: ['frontend', 'coding'],
+    fullstack: ['coding', 'frontend', 'filesystem'],
+    'full-stack': ['coding', 'frontend', 'filesystem'],
+    mobile: ['frontend', 'coding'],
+    // testing / quality
+    test: ['verification', 'review'],
+    tests: ['verification', 'review'],
+    testing: ['verification', 'review'],
+    qa: ['verification', 'review'],
+    security: ['review', 'reasoning'],
+    audit: ['review', 'reasoning'],
+    // planning / design
+    architect: ['architecture', 'planning', 'reasoning'],
+    plan: ['planning', 'reasoning'],
+    spec: ['planning', 'documentation'],
+    // data / research
+    research: ['search', 'crawl', 'summarize'],
+    data: ['dataviz', 'reasoning'],
+    db: ['coding', 'filesystem'],
+    database: ['coding', 'filesystem'],
+    ml: ['reasoning', 'coding'],
+    ai: ['reasoning', 'coding'],
+    // ops / misc
+    refactor: ['coding', 'review'],
+    debug: ['coding', 'reasoning', 'terminal'],
+    deploy: ['terminal', 'filesystem'],
+    devops: ['terminal', 'filesystem', 'coding'],
+    infra: ['terminal', 'filesystem'],
+    docs: ['documentation', 'summarize'],
+    translate: ['translation'],
+    a11y: ['accessibility'],
+    chart: ['dataviz'],
+    charts: ['dataviz'],
+    animate: ['animation'],
+    scrape: ['crawl', 'search'],
+};
+/**
+ * Normalize natural capability names to canonical capabilities. Accepts canonical
+ * names as-is, maps known synonyms, fuzzy-matches by substring, and guarantees a
+ * non-empty result (falls back to `['reasoning']`).
+ */
+export function normalizeCapabilities(input) {
+    const out = new Set();
+    const canon = new Set(CANONICAL_CAPABILITIES);
+    for (const raw of input ?? []) {
+        const key = String(raw).trim().toLowerCase();
+        if (!key)
+            continue;
+        if (canon.has(key)) {
+            out.add(key);
+            continue;
+        }
+        const mapped = SYNONYMS[key];
+        if (mapped) {
+            for (const c of mapped)
+                out.add(c);
+            continue;
+        }
+        // fuzzy: the term contains (or is contained by) a canonical token
+        const hit = CANONICAL_CAPABILITIES.find(c => key.includes(c) || c.includes(key));
+        if (hit)
+            out.add(hit);
+    }
+    if (out.size === 0)
+        out.add('reasoning');
+    return [...out];
+}

package/dist/kernel/checkpoint-engine.js

@@ -28,6 +28,13 @@ export class CheckpointEngine {
         // cap per-mission checkpoint files to prevent disk exhaustion
         this.pruneMission(mission.id);
         const id = nanoid(12);
+        // Persist the mission's recent event log + working memory so a resumed or
+        // crash-recovered long-running mission keeps its activity trail and context.
+        const logs = this.eventBus
+            .getHistory()
+            .filter(e => e.missionId === mission.id)
+            .slice(-200);
+        const memory = mission.metadata ? structuredClone(mission.metadata) : undefined;
         const checkpoint = {
             id,
             missionId: mission.id,
@@ -35,6 +42,8 @@ export class CheckpointEngine {
             workerStates,
             timestamp: Date.now(),
             reason,
+            logs,
+            memory,
         };
         const file = join(this.dir, `${mission.id}_${id}.json`);
         writeFileSync(file, JSON.stringify(checkpoint, null, 2), 'utf-8');

package/dist/kernel/command-system.d.ts

@@ -12,8 +12,11 @@
  */
 import type { Kernel } from './kernel.js';
 import type { CommandResult } from './types.js';
+import type { Federation } from './federation/federation.js';
 export interface CommandContext {
     kernel: Kernel;
+    /** The mesh node, when the kernel is running under `serve`/`mcp`. */
+    federation?: Federation;
     args: string[];
     raw: string;
 }

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']);