infinicode 2.3.5 → 2.4.0

package/dist/commands/robopark.js

@@ -0,0 +1,450 @@
+/**
+ * robopark — the RoboPark fleet control CLI.
+ *
+ * A thin operator layer that rides the infinicode mesh instead of SSH-ing around:
+ *
+ *   robopark setup --role scheduler --hub http://100.x:47913 --start
+ *   robopark fleet                 # live table of every node the hub can see
+ *   robopark run panda-a /status   # run a command on one node
+ *   robopark apply                 # push shared config (providers/policy) to the fleet
+ *   robopark dashboard --open      # open the web control UI
+ *
+ * `setup` writes this device's role + mesh config (the nine manual steps,
+ * automated). The other verbs talk to a running node's HTTP API (default the
+ * local node at 127.0.0.1:<port>), so the CLI never needs its own transport —
+ * it reuses the mesh the node already stood up.
+ */
+import chalk from 'chalk';
+import { spawn } from 'node:child_process';
+import { saveRole } from '../kernel/federation/role-context.js';
+import { serve } from './serve.js';
+const DEFAULT_PORT = 47913;
+function nodeUrl(config, urlOpt) {
+    if (urlOpt)
+        return urlOpt.replace(/\/+$/, '');
+    const fed = (config.get('federation') ?? {});
+    return `http://127.0.0.1:${fed.port ?? DEFAULT_PORT}`;
+}
+function authToken(config, tokenOpt) {
+    const fed = (config.get('federation') ?? {});
+    return tokenOpt ?? fed.token;
+}
+function headers(token) {
+    const h = { 'content-type': 'application/json' };
+    if (token)
+        h['authorization'] = `Bearer ${token}`;
+    return h;
+}
+async function getStatus(url, token) {
+    const res = await fetch(`${url}/fed/status`, { headers: headers(token), signal: AbortSignal.timeout(6000) });
+    if (res.status === 401)
+        throw new Error('unauthorized — this node requires a token (pass --token <secret>)');
+    if (!res.ok)
+        throw new Error(`node returned ${res.status}`);
+    return (await res.json());
+}
+function unreachable(url, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+        chalk.red(`  ✗ no mesh node reachable at ${url}`),
+        chalk.dim(`    ${msg}`),
+        chalk.dim('    start one with  infinicode serve --dashboard   or   robopark setup --start'),
+    ].join('\n');
+}
+// ── loadbar / formatting helpers ───────────────────────────────────────────────
+function bar(pct, width = 10) {
+    const v = Math.max(0, Math.min(100, Math.round(pct)));
+    const filled = Math.round((v / 100) * width);
+    const glyph = '█'.repeat(filled) + '░'.repeat(width - filled);
+    const color = v >= 80 ? chalk.red : v >= 50 ? chalk.yellow : chalk.green;
+    return color(glyph);
+}
+function pad(s, n) {
+    const len = [...s].length;
+    return len >= n ? s : s + ' '.repeat(n - len);
+}
+/** Pad the visible text to `width`, THEN colorize — so ANSI codes never count
+ *  toward column width (the bug you get from padding an already-colored string). */
+function cell(text, width, color) {
+    const p = pad(text, width);
+    return color ? color(p) : p;
+}
+function renderFleet(snap) {
+    const nodes = snap.nodes ?? [];
+    const lines = [];
+    const up = nodes.filter(n => n.connected).length;
+    const runs = (snap.runs ?? []).filter(r => r.status === 'running').length;
+    lines.push('');
+    lines.push(chalk.bold('  RoboPark fleet') + chalk.dim(`   ${up}/${nodes.length} up · ${runs} active run${runs === 1 ? '' : 's'}`));
+    lines.push(chalk.dim('  ' + '─'.repeat(72)));
+    if (!nodes.length) {
+        lines.push(chalk.dim('  no nodes reporting yet — bring peers online with `infinicode serve`.'));
+        return lines.join('\n');
+    }
+    const W = { name: 22, role: 11, state: 8, load: 16, site: 12 };
+    lines.push('  ' +
+        chalk.dim(pad('NODE', W.name) + pad('ROLE', W.role) + pad('STATE', W.state) + pad('LOAD', W.load) + pad('SITE', W.site) + 'VER'));
+    nodes.sort((a, b) => Number(b.connected) - Number(a.connected));
+    for (const n of nodes) {
+        const isSelf = snap.self && snap.self.nodeId === n.nodeId;
+        const name = n.displayName + (isSelf ? ' ‹this›' : '');
+        const state = cell(n.connected ? '● up' : '○ down', W.state, n.connected ? chalk.green : chalk.dim);
+        // LOAD: colored bar (fixed 10 visible glyphs) + percent, hand-padded so the
+        // bar's ANSI codes don't skew the column.
+        let load;
+        if (n.connected) {
+            const pct = `${Math.round(n.load ?? 0)}%`;
+            const visible = 10 + 1 + pct.length; // bar + space + "NN%"
+            load = `${bar(n.load ?? 0)} ${pct}` + ' '.repeat(Math.max(0, W.load - visible));
+        }
+        else {
+            load = cell('—', W.load, chalk.dim);
+        }
+        lines.push('  ' +
+            cell(name, W.name, isSelf ? chalk.bold.cyan : chalk.bold) +
+            cell(n.role, W.role, chalk.yellow) +
+            state +
+            load +
+            cell(n.site ?? '-', W.site, n.site ? undefined : chalk.dim) +
+            chalk.dim('v' + (n.version ?? '?')));
+    }
+    return lines.join('\n');
+}
+const ROLE_PRESETS = {
+    scheduler: { mesh: 'hub', blurb: 'on-site hub (LiveKit Server 1) — bridges tailnet ↔ LAN, serves the dashboard', dashboard: true, lan: true, tailscale: true },
+    robot: { mesh: 'satellite', blurb: 'a robot Pi — accept-only, LAN-discovered, never dials out', dashboard: false, lan: true, tailscale: false },
+    laptop: { mesh: 'peer', blurb: 'your control station — drives the fleet over the mesh', dashboard: false, lan: false, tailscale: true },
+    relay: { mesh: 'relay', blurb: 'a relay hop between two networks', dashboard: false, lan: true, tailscale: true },
+};
+// Power users can pass raw mesh roles too; fold them onto the matching preset.
+const MESH_ALIASES = { hub: 'scheduler', satellite: 'robot', peer: 'laptop' };
+function resolveRole(input) {
+    if (!input)
+        return null;
+    const key = input.toLowerCase();
+    const label = MESH_ALIASES[key] ?? key;
+    const preset = ROLE_PRESETS[label];
+    return preset ? { label, preset } : null;
+}
+/** Interactive fallback — the streamlined "just run `robopark setup`" path. */
+async function setupWizard(opts) {
+    const inquirer = (await import('inquirer')).default;
+    const a = (await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'role',
+            message: 'What is this device?',
+            choices: [
+                { name: 'scheduler  — the on-site hub (LiveKit Server 1)', value: 'scheduler' },
+                { name: 'robot      — a talking-robot Raspberry Pi', value: 'robot' },
+                { name: 'laptop     — your control station (drives the fleet)', value: 'laptop' },
+            ],
+            default: opts.robot ? 'robot' : opts.laptop ? 'laptop' : 'scheduler',
+        },
+        { type: 'input', name: 'name', message: 'Name for this device:', default: opts.name },
+        { type: 'input', name: 'site', message: 'Site / location (optional):', default: opts.site ?? '' },
+        {
+            type: 'input',
+            name: 'hub',
+            message: 'Hub URL to join (blank if this IS the scheduler):',
+            default: opts.hub ?? '',
+            when: (ans) => ans.role !== 'scheduler',
+        },
+        {
+            type: 'input',
+            name: 'gateway',
+            message: 'InfiniBot gateway ws:// URL (optional — surfaces the fleet in InfiniBot):',
+            default: opts.gateway ?? '',
+            when: (ans) => ans.role === 'scheduler',
+        },
+        { type: 'input', name: 'token', message: 'Shared token every device presents (optional but recommended):', default: opts.token ?? '' },
+        { type: 'confirm', name: 'start', message: 'Start the node now?', default: true },
+    ]));
+    return {
+        ...opts,
+        role: a.role,
+        name: a.name || opts.name,
+        site: a.site || undefined,
+        hub: a.hub || opts.hub,
+        gateway: a.gateway || opts.gateway,
+        token: a.token || opts.token,
+        start: a.start,
+    };
+}
+async function roboparkSetup(config, opts) {
+    // Shorthand flags → --role.
+    const roleInput = opts.role ?? (opts.scheduler ? 'scheduler' : opts.robot ? 'robot' : opts.laptop ? 'laptop' : undefined);
+    // No role given? Run the guided wizard in a TTY (unless --yes); otherwise error.
+    if (!roleInput && !opts.yes) {
+        if (process.stdin.isTTY) {
+            opts = await setupWizard(opts);
+        }
+        else {
+            console.log(chalk.red('  robopark setup: pass --scheduler | --robot | --laptop (or --role <role>)'));
+            return;
+        }
+    }
+    const resolved = resolveRole(opts.role ?? roleInput ?? 'laptop');
+    if (!resolved) {
+        console.log(chalk.red(`  unknown role "${opts.role}". Use: scheduler | robot | laptop | relay`));
+        return;
+    }
+    const { label, preset } = resolved;
+    const meshRole = preset.mesh;
+    // Preset defaults, overridable by explicit flags.
+    const dashboard = opts.dashboard ?? preset.dashboard;
+    const lan = opts.lan ?? preset.lan;
+    const tailscale = opts.tailscale ?? (preset.tailscale && !opts.hub); // seed URL replaces discovery
+    const port = opts.port ? parseInt(opts.port, 10) : DEFAULT_PORT;
+    const prev = (config.get('federation') ?? {});
+    const fed = {
+        ...prev,
+        enabled: true,
+        role: meshRole,
+        port,
+        displayName: opts.name ?? prev.displayName,
+        token: opts.token ?? prev.token,
+        seeds: opts.hub ? Array.from(new Set([...(prev.seeds ?? []), opts.hub])) : prev.seeds,
+        lan,
+    };
+    config.set('federation', fed);
+    // Persist the device's role/site brief — injected into every task run here.
+    const roleCtx = saveRole({
+        role: opts.name ?? label,
+        site: opts.site,
+        architecture: opts.architecture,
+    });
+    console.log(chalk.bold('\n  robopark setup'));
+    console.log(chalk.dim('  ' + '─'.repeat(52)));
+    console.log(`  device: ${chalk.yellow(label)} ${chalk.dim('→ mesh role ' + meshRole)}`);
+    console.log(chalk.dim(`          ${preset.blurb}`));
+    console.log(`  name:   ${chalk.cyan(opts.name ?? '(hostname)')}${opts.site ? chalk.dim('  @ ' + opts.site) : ''}`);
+    console.log(`  listen: ${chalk.cyan('0.0.0.0:' + port)}`);
+    if (opts.hub)
+        console.log(`  hub:    ${chalk.cyan(opts.hub)}`);
+    if (fed.token)
+        console.log(`  auth:   ${chalk.green('token set')}`);
+    if (lan)
+        console.log(`  lan:    ${chalk.green('auto-discovery on')}`);
+    if (tailscale)
+        console.log(`  tailnet:${chalk.green(' discovery on')}${opts.tag ? chalk.dim(' · tag ' + opts.tag) : ''}`);
+    if (dashboard)
+        console.log(`  ui:     ${chalk.green('dashboard on')}`);
+    console.log();
+    const serveOpts = {
+        role: meshRole,
+        name: opts.name,
+        port: String(port),
+        token: fed.token,
+        seed: opts.hub ? [opts.hub] : undefined,
+        tailscale,
+        lan,
+        tag: opts.tag,
+        dashboard,
+        gateway: opts.gateway,
+        gatewayToken: opts.gatewayToken,
+    };
+    if (opts.start) {
+        console.log(chalk.dim('  starting node…\n'));
+        await serve(config, serveOpts);
+        return;
+    }
+    const startCmd = [
+        'infinicode serve',
+        `--role ${meshRole}`,
+        dashboard ? '--dashboard' : '',
+        lan ? '--lan' : '',
+        tailscale ? '--tailscale' : '',
+        opts.tag ? `--tag ${opts.tag}` : '',
+        opts.hub ? `--seed ${opts.hub}` : '',
+        fed.token ? `--token ${fed.token}` : '',
+        opts.gateway ? `--gateway ${opts.gateway}` : '',
+    ]
+        .filter(Boolean)
+        .join(' ');
+    console.log(chalk.dim('  saved. start it now with:  ') + chalk.cyan('robopark setup --' + label + ' --start'));
+    console.log(chalk.dim('  or run the node directly:   ') + chalk.cyan(startCmd));
+    console.log();
+}
+async function roboparkFleet(config, opts) {
+    const url = nodeUrl(config, opts.url);
+    const token = authToken(config, opts.token);
+    const once = async () => {
+        let snap;
+        try {
+            snap = await getStatus(url, token);
+        }
+        catch (err) {
+            console.log(unreachable(url, err));
+            return false;
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(snap, null, 2));
+        }
+        else {
+            if (opts.watch)
+                process.stdout.write('\x1b[2J\x1b[H');
+            console.log(renderFleet(snap));
+            if (opts.watch)
+                console.log(chalk.dim(`\n  updated ${new Date().toLocaleTimeString()} · Ctrl-C to stop`));
+        }
+        return true;
+    };
+    if (!opts.watch) {
+        await once();
+        return;
+    }
+    const ok = await once();
+    if (!ok)
+        return; // don't spin on an unreachable node
+    const timer = setInterval(() => void once(), 2000);
+    await new Promise(resolve => {
+        process.on('SIGINT', () => {
+            clearInterval(timer);
+            resolve();
+        });
+    });
+}
+async function roboparkRun(config, node, command, opts) {
+    const url = nodeUrl(config, opts.url);
+    const token = authToken(config, opts.token);
+    const cmd = command.join(' ').trim();
+    if (!cmd) {
+        console.log(chalk.red('  nothing to run — usage: robopark run <node> <command…>'));
+        return;
+    }
+    // Local node keywords bypass the /node dispatch wrapper.
+    const local = ['.', 'self', 'local', 'here'].includes(node.toLowerCase());
+    const input = local ? (cmd.startsWith('/') ? cmd : `/${cmd}`) : `/node ${node} ${cmd}`;
+    try {
+        const res = await fetch(`${url}/fed/command`, {
+            method: 'POST',
+            headers: headers(token),
+            body: JSON.stringify({ input }),
+            signal: AbortSignal.timeout(120_000),
+        });
+        const body = (await res.json().catch(() => ({ ok: false, text: `HTTP ${res.status}` })));
+        const text = body.text ?? JSON.stringify(body);
+        console.log(body.ok === false ? chalk.yellow(text) : text);
+    }
+    catch (err) {
+        console.log(unreachable(url, err));
+    }
+}
+async function roboparkApply(config, opts) {
+    const url = nodeUrl(config, opts.url);
+    const token = authToken(config, opts.token);
+    try {
+        const res = await fetch(`${url}/fed/apply`, {
+            method: 'POST',
+            headers: headers(token),
+            body: '{}',
+            signal: AbortSignal.timeout(15_000),
+        });
+        const body = (await res.json().catch(() => ({ ok: false, text: `HTTP ${res.status}` })));
+        console.log((body.ok === false ? chalk.yellow : chalk.green)('  ' + (body.text ?? 'applied')));
+    }
+    catch (err) {
+        console.log(unreachable(url, err));
+    }
+}
+function openBrowser(url) {
+    const platform = process.platform;
+    const cmd = platform === 'win32' ? 'cmd' : platform === 'darwin' ? 'open' : 'xdg-open';
+    const args = platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    try {
+        spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
+    }
+    catch {
+        /* fall back to just printing */
+    }
+}
+async function roboparkDashboard(config, opts) {
+    const base = nodeUrl(config, opts.url);
+    const token = authToken(config, opts.token);
+    const link = `${base}/${token ? `?token=${encodeURIComponent(token)}` : ''}`;
+    // Confirm the node is actually serving the dashboard before pointing there.
+    try {
+        const res = await fetch(link, { headers: headers(token), signal: AbortSignal.timeout(5000) });
+        if (res.status === 404) {
+            console.log(chalk.yellow(`  ⚠ node at ${base} is up but the dashboard is off.`));
+            console.log(chalk.dim('    restart it with  infinicode serve --dashboard'));
+            return;
+        }
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+    }
+    catch (err) {
+        console.log(unreachable(base, err));
+        return;
+    }
+    console.log(chalk.bold('\n  RoboPark control dashboard'));
+    console.log('  ' + chalk.cyan(link) + '\n');
+    if (opts.open)
+        openBrowser(link);
+}
+// ── wiring ─────────────────────────────────────────────────────────────────────
+/** Attach the robopark verbs to a Commander command (the `robopark` program in
+ *  the standalone bin, or the `infinicode robopark` group). */
+export function attachRoboparkSubcommands(cmd, config) {
+    cmd
+        .command('setup')
+        .description('Set up this device in one pass. Run bare for a guided wizard, or pass a role to skip it.')
+        .option('--scheduler', 'this device is the on-site hub (LiveKit Server 1)')
+        .option('--robot', 'this device is a talking-robot Raspberry Pi')
+        .option('--laptop', 'this device is your control station')
+        .option('--role <role>', 'explicit role: scheduler | robot | laptop | relay (or raw mesh role hub/peer/satellite)')
+        .option('--site <site>', 'physical location for fleet grouping, e.g. "Tel Aviv"')
+        .option('--name <name>', 'friendly device name (defaults to hostname)')
+        .option('--hub <url>', 'hub base URL to join, e.g. http://100.x.y.z:47913 (robots/laptops)')
+        .option('--gateway <url>', 'InfiniBot gateway ws:// URL to surface the fleet in InfiniBot (scheduler)')
+        .option('--gateway-token <token>', 'auth token for the InfiniBot gateway')
+        .option('--token <token>', 'shared bearer token every device must present')
+        .option('--port <port>', 'mesh listen port (default 47913)')
+        .option('--tag <tag>', 'only discover peers carrying this tag (e.g. tag:robopark)')
+        .option('--architecture <text>', "one-line brief of this device's job in the wider system")
+        .option('--lan', 'force zero-config LAN auto-discovery (on by default for scheduler/robot)')
+        .option('--tailscale', 'force Tailscale peer discovery (on by default for scheduler/laptop)')
+        .option('--dashboard', 'force the web control UI (on by default for scheduler)')
+        .option('--start', 'launch the node now instead of just writing config')
+        .option('--yes', 'skip the guided wizard even with no role (non-interactive)')
+        .action(async (opts) => {
+        await roboparkSetup(config, opts);
+    });
+    cmd
+        .command('fleet')
+        .alias('status')
+        .description('Show every node the local (or a given) mesh node can see')
+        .option('--url <url>', 'node HTTP base to query (default the local node)')
+        .option('--token <token>', 'bearer token if the node requires auth')
+        .option('--watch', 'refresh the table every 2s until Ctrl-C')
+        .option('--json', 'print the raw status snapshot as JSON')
+        .action(async (opts) => {
+        await roboparkFleet(config, opts);
+    });
+    cmd
+        .command('run <node> <command...>')
+        .description('Run a slash-command on a node (use "." for the local node), e.g. robopark run panda-a /status')
+        .option('--url <url>', 'node HTTP base to send through (default the local node)')
+        .option('--token <token>', 'bearer token if the node requires auth')
+        .action(async (node, command, opts) => {
+        await roboparkRun(config, node, command, opts);
+    });
+    cmd
+        .command('apply')
+        .description('Publish this hub\'s shared config (providers, keys, policy) to every satellite')
+        .option('--url <url>', 'node HTTP base to apply through (default the local node)')
+        .option('--token <token>', 'bearer token if the node requires auth')
+        .action(async (opts) => {
+        await roboparkApply(config, opts);
+    });
+    cmd
+        .command('dashboard')
+        .description('Print (and optionally open) the web control dashboard URL')
+        .option('--url <url>', 'node HTTP base (default the local node)')
+        .option('--token <token>', 'bearer token if the node requires auth')
+        .option('--open', 'open the dashboard in the default browser')
+        .action(async (opts) => {
+        await roboparkDashboard(config, opts);
+    });
+}

package/dist/commands/run.js

@@ -18,12 +18,12 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
 import { ASCII_VIDEO_FPS, ASCII_VIDEO_FRAMES } from '../ascii-video-animation.js';
 import { getProviderPreset } from '../kernel/free-providers.js';
 import { buildKernelFromConfig } from '../kernel/setup.js';
-import { SilentLogger, Federation, loadOrCreateIdentity, KernelGateway } from '../kernel/index.js';
+import { SilentLogger, FileLogger, Federation, loadOrCreateIdentity, KernelGateway, phaseBenchmarkFloor } from '../kernel/index.js';
 import { openAICompatBaseURL } from '../kernel/provider-url.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PROMPT_ANIMATION_MAX_FRAMES = Math.min(ASCII_VIDEO_FRAMES.length, ASCII_VIDEO_FPS * 3);
@@ -150,7 +150,11 @@ function modelEntry(m) {
     // Only set a limit when we have a real context value (> the 8192 default) —
     // a wrong-small limit would make opencode compact large models too early.
     if (m.contextLength && m.contextLength > 8192) {
-        entry.limit = { context: m.contextLength, output: Math.min(16384, Math.max(2048, Math.floor(m.contextLength / 16))) };
+        // Generous output headroom so a large single-file generation completes in one
+        // turn instead of truncating at the cap and stalling ("continue"). Frontier
+        // models support 16–32k output; a too-high ask that a model rejects is caught
+        // by the gateway's swap-on-error, so we bias toward completing big writes.
+        entry.limit = { context: m.contextLength, output: Math.min(32768, Math.max(4096, Math.floor(m.contextLength / 8))) };
     }
     return entry;
 }
@@ -442,6 +446,30 @@ function buildGatewayTuiConfig(gatewayUrl, providers) {
         },
     };
 }
+/**
+ * Pick the strongest coding-capable model across the FULL fetched catalog (not
+ * just health-verified providers). Groq health-checks fastest, so ranking over
+ * only-healthy providers at startup hands the default to Groq/Llama before a
+ * frontier provider (NVIDIA/HF/Chutes) finishes verifying. Ranking the whole
+ * catalog by benchmark lets GLM/Kimi/DeepSeek/Qwen3 win; the gateway swaps on
+ * failure anyway, so choosing a not-yet-verified provider is safe.
+ */
+function pickStrongestModel(kernel, modelsByProvider) {
+    let best = null;
+    let bestBench = -1;
+    for (const [providerId, models] of Object.entries(modelsByProvider)) {
+        for (const m of models) {
+            if (!m.capabilities?.includes('coding'))
+                continue;
+            const b = kernel.router.benchmarkFor(m);
+            if (b > bestBench) {
+                bestBench = b;
+                best = { providerId, modelId: m.id };
+            }
+        }
+    }
+    return best;
+}
 export async function runAgent(_masterUrl, _model, _useTui, config) {
     const masterUrl = await resolveConfiguredMasterUrl(config);
     const masterReachable = await isOllamaReachable(masterUrl);
@@ -457,11 +485,13 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
     // (/nodes, /build, /activity, …) have a local node to talk to. Reuses a
     // running `infinicode serve` if one is up, else starts an in-process node.
     const mesh = await startLocalMeshNode(config, sessionKernel);
-    if (mesh) {
-        process.env.INFINICODE_MESH_URL = mesh.url;
-        if (mesh.token)
-            process.env.INFINICODE_MESH_TOKEN = mesh.token;
-    }
+    // Always give the in-TUI mesh commands a target: the node we started, or the
+    // default local port (a separate `infinicode serve` may be there / come up).
+    const fedCfg = config.get('federation') ?? {};
+    process.env.INFINICODE_MESH_URL = mesh?.url ?? `http://127.0.0.1:${fedCfg.port ?? 47913}`;
+    const meshToken = mesh?.token ?? fedCfg.token;
+    if (meshToken)
+        process.env.INFINICODE_MESH_TOKEN = meshToken;
     // One kernel pass: load every provider's full model catalog (in parallel) and
     // route the default model under the policy.
     const routeSpinner = ora('loading model catalog & routing...').start();
@@ -471,21 +501,52 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
     // single provider, so interactive chat gains full kernel parity: auto-routing,
     // escalate-on-error, provider rotation, health/quota, live telemetry.
     const gwProviders = buildGatewayProviders(config, masterUrl, masterReachable, defaultModel, modelsByProvider);
+    // Durable trace of routing/swap/truncation/continuation decisions — the gateway's
+    // console belongs to the TUI, so without this a mid-task death is invisible.
+    const gatewayLogFile = join(dirname(config.path), 'gateway.log');
     let gateway;
     if (!process.env.INFINICODE_NO_GATEWAY && gwProviders.length > 0) {
         try {
-            gateway = new KernelGateway({ kernel: sessionKernel, providers: gwProviders, policyName, logger: new SilentLogger() });
+            gateway = new KernelGateway({
+                kernel: sessionKernel,
+                providers: gwProviders,
+                policyName,
+                logger: new FileLogger(gatewayLogFile),
+                // Bias interactive coding toward capable models (soft floor, not a pin).
+                minBenchmark: phaseBenchmarkFloor(['coding', 'frontend']),
+            });
             await gateway.start();
+            console.log(chalk.green(`  ⚡ kernel gateway on ${gateway.url}`) + chalk.dim(`  · log: ${gatewayLogFile}`));
         }
-        catch {
-            gateway = undefined; // fall back to direct-provider config below
+        catch (err) {
+            // Surface WHY the kernel gateway couldn't start — without it there's no
+            // routing/reliability, so a silent fallback to direct-Llama is exactly the
+            // "died / still using llama" symptom. Make it loud.
+            console.log(chalk.yellow(`\n  ⚠ kernel gateway failed to start — falling back to direct routing (no auto-swap/reliability).`));
+            console.log(chalk.dim(`    reason: ${err instanceof Error ? err.message : String(err)}`));
+            gateway?.stop().catch(() => undefined);
+            gateway = undefined;
         }
     }
     let providers;
     let modelRef;
     if (gateway) {
         providers = buildGatewayTuiConfig(gateway.url, gwProviders);
-        modelRef = 'infinicode/auto'; // default to kernel auto-routing
+        // Default to the CONCRETE strongest model (not "auto") so the footer shows a
+        // real, capable model and the session stays consistent — but pick it from the
+        // FULL catalog by benchmark so it's a frontier model, not fast-but-mid Groq/
+        // Llama. Gateway still swaps on failure; "auto" stays selectable in the palette.
+        const best = pickStrongestModel(sessionKernel, modelsByProvider) ?? routed;
+        if (best) {
+            const key = `${best.providerId}/${best.modelId}`;
+            const gwModels = providers['infinicode'].models;
+            if (!gwModels[key])
+                gwModels[key] = modelEntry({ id: key, name: key });
+            modelRef = `infinicode/${key}`;
+        }
+        else {
+            modelRef = 'infinicode/auto';
+        }
     }
     else {
         // Fallback: talk to providers directly (no kernel in the loop).
@@ -511,15 +572,15 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
     const routingInfo = gateway
         ? `KERNEL ${policy} ${providerCount}P ${pinnedCount}pins`
         : `AUTO ${policy} ${providerCount}P ${pinnedCount}pins`;
-    // Runtime TUI plugin that adds the mesh slash-commands (/nodes, /build, …)
-    // to the `/` palette. Shipped in the package at .opencode/plugins; loaded via
-    // a file:// URL so it resolves regardless of the TUI's cwd. Only injected when
-    // a local mesh node is available (else the commands would have nothing to hit).
-    const pluginPaths = [];
-    if (mesh) {
-        const pluginFile = join(resolve(__dirname, '..', '..'), '.opencode', 'plugins', 'mesh-commands.tsx');
-        if (existsSync(pluginFile))
-            pluginPaths.push(pathToFileURL(pluginFile).href);
+    // TUI plugins (theme, animated logo, routing display, AND the mesh slash-command
+    // palette) load ONLY from a `tui` config file — NOT from OPENCODE_CONFIG_CONTENT
+    // (that's the main/server config; a TUI plugin there never has its `tui` export
+    // invoked, so its /commands never register). Point the TUI at the package's
+    // tui.json via OPENCODE_TUI_CONFIG so all three plugins load regardless of cwd.
+    // Its plugin paths are relative and resolve next to tui.json (../plugins/*.tsx).
+    const tuiConfigFile = join(resolve(__dirname, '..', '..'), '.opencode', 'tui.json');
+    if (existsSync(tuiConfigFile) && !process.env.OPENCODE_TUI_CONFIG) {
+        process.env.OPENCODE_TUI_CONFIG = tuiConfigFile;
     }
     process.env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
         $schema: 'https://opencode.ai/config.json',
@@ -527,7 +588,6 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
         model: modelRef,
         small_model: modelRef,
         enabled_providers: Object.keys(providers),
-        ...(pluginPaths.length > 0 ? { plugin: pluginPaths } : {}),
         agent: {
             build: {
                 model: modelRef,

package/dist/commands/serve.d.ts

@@ -17,5 +17,6 @@ export interface ServeOptions {
     gateway?: string;
     gatewayToken?: string;
     gatewayPassword?: string;
+    dashboard?: boolean;
 }
 export declare function serve(config: Conf<InfinicodeConfig>, opts: ServeOptions): Promise<void>;