infinicode 2.3.4 → 2.3.6

package/.opencode/plugins/home-logo-animation.tsx

@@ -109,7 +109,7 @@ function AnimatedLogo(props: { renderer?: any }) {
   );
 }
 
-export const tui = async (api: any) => {
+const tui = async (api: any) => {
   api.slots.register({
     slots: {
       home_logo() {
@@ -118,3 +118,7 @@ export const tui = async (api: any) => {
     },
   });
 };
+
+// The TUI plugin loader reads `mod.default` (strict mode) and requires an object
+// with a tui() function — a bare `export const tui` is silently skipped.
+export default { id: "infinicode-home-logo", tui };

package/.opencode/plugins/mesh-commands.tsx

@@ -16,7 +16,6 @@
  * /follow, /dispatch, /goal, /mission, /role) open a prompt first.
  */
 import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui"
-import { createBindingLookup } from "@opentui/keymap/extras"
 
 type CommandResult = { ok?: boolean; text?: string; data?: unknown }
 
@@ -112,8 +111,10 @@ const SPECS: Spec[] = [
 
 const tui: TuiPlugin = async (api, options) => {
   if (options?.enabled === false) return
-  const keys = createBindingLookup({})
 
+  // No keybindings — these are palette-only slash commands. Empty bindings avoids
+  // any dependency on the keymap-extras runtime module (which may not resolve for
+  // an externally-loaded plugin) so registration can never fail to load.
   api.keymap.registerLayer({
     commands: SPECS.map((s) => ({
       name: s.name,
@@ -127,7 +128,7 @@ const tui: TuiPlugin = async (api, options) => {
         else runNow(api, s.title, cmd)
       },
     })),
-    bindings: keys.gather("mesh.global", SPECS.map((s) => s.name)),
+    bindings: [],
   })
 }
 

package/.opencode/plugins/routing-mode-display.tsx

@@ -85,7 +85,7 @@ function buildRoutingBadge(cfg: InfinicodeConfig | null, tuiModel?: string): Rou
 
 // ── Plugin ──────────────────────────────────────────────────────────────────
 
-export const tui = async (api: any) => {
+const tui = async (api: any) => {
   const [cfg] = createSignal(loadConfig());
 
   const getTuiModel = (): string | undefined => {
@@ -132,4 +132,8 @@ export const tui = async (api: any) => {
       },
     },
   });
-};
+};
+
+// The TUI plugin loader reads `mod.default` (strict mode) and requires an object
+// with a tui() function — a bare `export const tui` is silently skipped.
+export default { id: "infinicode-routing-mode", tui };

package/.opencode/tui.json

@@ -3,6 +3,7 @@
   "theme": "infinibot-gold",
   "plugin": [
     "./plugins/home-logo-animation.tsx",
-    "./plugins/routing-mode-display.tsx"
+    "./plugins/routing-mode-display.tsx",
+    "./plugins/mesh-commands.tsx"
   ]
 }

package/dist/cli.js

@@ -14,9 +14,10 @@ import { providersList, providersAdd, providersRemove, providersTest } from './c
 import { consoleRepl, consoleRun } from './commands/console.js';
 import { serve } from './commands/serve.js';
 import { mcpCommand } from './commands/mcp.js';
+import { meshInstall, meshUninstall } from './commands/mesh-install.js';
 import { installTui } from './commands/install-tui.js';
 import { DEFAULT_CONFIG } from './kernel/config-schema.js';
-const VERSION = '2.3.4';
+const VERSION = '2.3.6';
 const config = new Conf({
     projectName: 'infinicode',
     defaults: DEFAULT_CONFIG,
@@ -298,6 +299,29 @@ program
     .action(async (opts) => {
     await serve(config, opts);
 });
+// ── infinicode: mesh — one-command MCP registration (no hand-edited JSON) ──
+const meshCmd = program
+    .command('mesh')
+    .description('Join this device to the agent mesh by auto-registering the MCP server into your coding host');
+meshCmd
+    .command('install', { isDefault: true })
+    .description('Register the infinicode MCP server into Claude Code (and/or OpenCode) — no manual file edits')
+    .option('--host <host>', 'target host: claude | opencode | all', 'claude')
+    .option('--token <token>', 'shared bearer token every device must present (recommended off-LAN)')
+    .option('--name <name>', 'friendly node name for this device')
+    .option('--tailscale', 'discover peers over Tailscale instead of / as well as the LAN')
+    .option('--no-lan', 'disable zero-config LAN auto-discovery')
+    .option('--print', 'dry run — show what would be written without changing anything')
+    .action(async (opts) => {
+    await meshInstall(opts);
+});
+meshCmd
+    .command('uninstall')
+    .description('Remove the infinicode MCP server from your coding host')
+    .option('--host <host>', 'target host: claude | opencode | all', 'claude')
+    .action(async (opts) => {
+    await meshUninstall(opts);
+});
 // ── infinicode: install the TUI binary into this install ───────────────────
 program
     .command('install-tui')

package/dist/commands/mesh-install.d.ts

@@ -0,0 +1,10 @@
+export interface MeshInstallOptions {
+    host?: string;
+    token?: string;
+    name?: string;
+    tailscale?: boolean;
+    lan?: boolean;
+    print?: boolean;
+}
+export declare function meshInstall(opts: MeshInstallOptions): Promise<void>;
+export declare function meshUninstall(opts: MeshInstallOptions): Promise<void>;

package/dist/commands/mesh-install.js

@@ -0,0 +1,160 @@
+/**
+ * infinicode mesh install — register the infinicode MCP server into a coding
+ * host's config automatically, so the user never hand-edits a JSON file.
+ *
+ *   infinicode mesh install                 → add to Claude Code (~/.claude.json)
+ *   infinicode mesh install --host all      → Claude Code + OpenCode
+ *   infinicode mesh install --token secret   → gated mesh
+ *   infinicode mesh uninstall                → remove it again
+ *
+ * After it runs, the user just restarts their coding host and the mesh tools
+ * (list_nodes / spawn_agent / send_message …) are available. On another laptop
+ * with the same one command, the two nodes auto-discover over the LAN.
+ */
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findExecutable } from '../kernel/agents/backends/detect.js';
+/** How a host should spawn the infinicode MCP node. Resolves a global binary
+ *  if present, else falls back to `node <this package's cli.js>`. */
+function resolveLaunch() {
+    const onPath = findExecutable('infinicode');
+    if (onPath)
+        return { command: 'infinicode', baseArgs: [] };
+    const cliJs = join(dirname(fileURLToPath(import.meta.url)), '..', 'cli.js');
+    return { command: process.execPath, baseArgs: [cliJs] };
+}
+/** The `infinicode mcp …` argv the host should run. */
+function meshArgs(opts) {
+    const args = ['mcp'];
+    if (opts.lan !== false)
+        args.push('--lan');
+    if (opts.tailscale)
+        args.push('--tailscale');
+    if (opts.token)
+        args.push('--token', opts.token);
+    if (opts.name)
+        args.push('--name', opts.name);
+    return args;
+}
+function readJson(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** Back up a config once before the first infinicode edit, then write pretty JSON. */
+function writeJson(path, data) {
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    if (existsSync(path)) {
+        const bak = `${path}.infinicode.bak`;
+        if (!existsSync(bak))
+            copyFileSync(path, bak);
+    }
+    writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
+}
+const CLAUDE_CONFIG = () => join(homedir(), '.claude.json');
+const OPENCODE_CONFIG = () => join(homedir(), '.config', 'opencode', 'opencode.json');
+/** Claude Code: mcpServers.infinicode = { command, args }. */
+function installClaude(opts) {
+    const path = CLAUDE_CONFIG();
+    const cfg = readJson(path);
+    const servers = cfg.mcpServers ?? {};
+    const existed = 'infinicode' in servers;
+    const { command, baseArgs } = resolveLaunch();
+    const entry = { command, args: [...baseArgs, ...meshArgs(opts)] };
+    if (!opts.print) {
+        cfg.mcpServers = { ...servers, infinicode: entry };
+        writeJson(path, cfg);
+    }
+    return { path, entry, existed };
+}
+/** OpenCode: mcp.infinicode = { type:'local', command:[...], enabled:true }. */
+function installOpencode(opts) {
+    const path = OPENCODE_CONFIG();
+    const cfg = readJson(path);
+    const mcp = cfg.mcp ?? {};
+    const existed = 'infinicode' in mcp;
+    const { command, baseArgs } = resolveLaunch();
+    const entry = { type: 'local', command: [command, ...baseArgs, ...meshArgs(opts)], enabled: true };
+    if (!opts.print) {
+        cfg.mcp = { ...mcp, infinicode: entry };
+        writeJson(path, cfg);
+    }
+    return { path, entry, existed };
+}
+function removeFrom(path, key) {
+    if (!existsSync(path))
+        return false;
+    const cfg = readJson(path);
+    const bag = cfg[key];
+    if (!bag || !('infinicode' in bag))
+        return false;
+    delete bag.infinicode;
+    cfg[key] = bag;
+    writeJson(path, cfg);
+    return true;
+}
+function selectedHosts(host) {
+    const h = (host ?? 'claude').toLowerCase();
+    if (h === 'all')
+        return ['claude', 'opencode'];
+    if (h === 'opencode')
+        return ['opencode'];
+    if (h === 'claude' || h === 'claude-code')
+        return ['claude'];
+    return ['claude'];
+}
+export async function meshInstall(opts) {
+    const hosts = selectedHosts(opts.host);
+    console.log(chalk.bold('\n🕸  infinicode mesh — MCP registration\n'));
+    for (const host of hosts) {
+        const res = host === 'claude' ? installClaude(opts) : installOpencode(opts);
+        const label = host === 'claude' ? 'Claude Code' : 'OpenCode';
+        const verb = opts.print ? 'would write' : res.existed ? 'updated' : 'added';
+        console.log(`  ${chalk.green('✓')} ${chalk.cyan(label)} — ${verb} ${chalk.dim(res.path)}`);
+        console.log(chalk.dim(`      ${JSON.stringify(res.entry)}`));
+    }
+    // Warn if the target CLI backend isn't installed on THIS machine — a worker
+    // node can only run agents for CLIs it actually has.
+    const present = ['claude', 'codex', 'opencode'].filter(b => findExecutable(b));
+    console.log();
+    if (present.length) {
+        console.log(`  ${chalk.green('•')} coding CLIs detected here (can execute agents): ${chalk.bold(present.join(', '))}`);
+    }
+    else {
+        console.log(`  ${chalk.yellow('•')} no coding CLI (claude/codex/opencode) found on PATH — this device can drive the mesh but can't execute agents until one is installed.`);
+    }
+    if (opts.print) {
+        console.log(chalk.dim('\n  (dry run — nothing was written)\n'));
+        return;
+    }
+    console.log(chalk.bold('\n  Next:'));
+    console.log(`    1. Run the SAME command on the other laptop.`);
+    console.log(`    2. Restart your coding host (Claude Code) on both.`);
+    console.log(`    3. Ask it: ${chalk.italic('"list_nodes"')} then ${chalk.italic('"spawn_agent on <laptop> with agent claude to …"')}`);
+    if (!opts.token) {
+        console.log(chalk.dim(`\n  Tip: on an untrusted network, re-run with --token <secret> on every device.`));
+    }
+    console.log();
+}
+export async function meshUninstall(opts) {
+    const hosts = selectedHosts(opts.host);
+    console.log(chalk.bold('\n🕸  infinicode mesh — removing MCP registration\n'));
+    for (const host of hosts) {
+        const path = host === 'claude' ? CLAUDE_CONFIG() : OPENCODE_CONFIG();
+        const key = host === 'claude' ? 'mcpServers' : 'mcp';
+        const removed = removeFrom(path, key);
+        const label = host === 'claude' ? 'Claude Code' : 'OpenCode';
+        console.log(`  ${removed ? chalk.green('✓ removed from') : chalk.dim('· not present in')} ${chalk.cyan(label)} ${chalk.dim(path)}`);
+    }
+    console.log(chalk.dim('\n  Restart your coding host to apply.\n'));
+}

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 } 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;
 }
@@ -257,8 +261,11 @@ async function pickDefaultModel(config, masterReachable) {
  * in parallel (so all models are exposed, incl. large ones like GLM-5.2 on HF
  * and Nemotron-Ultra on NVIDIA), then route the default model under the policy.
  */
-async function prepareRouting(config, policyName) {
-    const kernel = buildKernelFromConfig(config, { logger: new SilentLogger() });
+async function prepareRouting(config, policyName, sharedKernel) {
+    // Reuse the caller's session kernel when provided (so the gateway routes
+    // against the same warmed-up provider pool) — only destroy a kernel we own.
+    const kernel = sharedKernel ?? buildKernelFromConfig(config, { logger: new SilentLogger() });
+    const ownsKernel = !sharedKernel;
     const modelsByProvider = {};
     try {
         // Let background token-verified health checks run first.
@@ -297,7 +304,8 @@ async function prepareRouting(config, policyName) {
         return { routed: null, modelsByProvider };
     }
     finally {
-        kernel.destroy();
+        if (ownsKernel)
+            kernel.destroy();
     }
 }
 /** Ensure the routed model exists in the TUI's injected provider config. */
@@ -337,7 +345,7 @@ async function meshAlive(url, token) {
  * otherwise start an in-process node for the session. Best-effort: on any
  * failure the TUI still launches, just without the live mesh palette.
  */
-async function startLocalMeshNode(config) {
+async function startLocalMeshNode(config, kernel) {
     if (process.env.INFINICODE_NO_MESH)
         return null;
     const fed = config.get('federation') ?? {};
@@ -348,7 +356,6 @@ async function startLocalMeshNode(config) {
         // Reuse an already-running node (don't double-bind the port).
         if (await meshAlive(url, token))
             return { url, token, stop: async () => { } };
-        const kernel = buildKernelFromConfig(config, { logger: new SilentLogger() });
         const role = (fed.role ?? 'peer');
         const identity = loadOrCreateIdentity({ role, displayName: fed.displayName });
         const version = runPkgVersion();
@@ -375,15 +382,94 @@ async function startLocalMeshNode(config) {
             federation.startLanDiscovery(undefined, fed.lanPort);
         for (const s of fed.seeds ?? [])
             await federation.connect(s).catch(() => undefined);
+        // The kernel is owned by runAgent — the mesh only stops the federation.
         return {
             url, token,
-            stop: async () => { await federation.stop(); kernel.destroy(); },
+            stop: async () => { await federation.stop(); },
         };
     }
     catch {
         return null;
     }
 }
+/** Build the gateway's provider table (baseURL/apiKey/models) from config. */
+function buildGatewayProviders(config, masterUrl, masterReachable, defaultModel, modelsByProvider) {
+    const out = [];
+    const catalog = (id, fallback) => {
+        const fetched = modelsByProvider[id];
+        return fetched && fetched.length ? fetched : fallback;
+    };
+    const shape = (models) => models.map(m => ({ id: m.id, name: m.name, contextLength: m.contextLength }));
+    if (masterReachable) {
+        out.push({
+            id: 'ollama',
+            baseURL: `${masterUrl}/v1`,
+            models: shape(catalog('ollama', [{ id: defaultModel, name: defaultModel, contextLength: 8192 }])),
+        });
+    }
+    for (const cfg of config.get('cloudProviders') ?? []) {
+        if (!cfg.enabled || !cfg.apiKey)
+            continue;
+        const preset = getProviderPreset(cfg.id);
+        const fallback = (preset?.knownModels ?? []).map(m => ({ id: m.id, name: m.name, contextLength: m.contextLength }));
+        const models = shape(catalog(cfg.id, fallback));
+        if (cfg.id === 'gemini') {
+            // Google's OpenAI-compatibility endpoint keeps the relay uniform.
+            out.push({ id: 'gemini', baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai', apiKey: cfg.apiKey, models });
+        }
+        else {
+            const headers = cfg.headerName && cfg.headerName !== 'Authorization' ? { [cfg.headerName]: cfg.apiKey } : undefined;
+            out.push({ id: cfg.id, baseURL: openAICompatBaseURL(cfg.baseURL), apiKey: cfg.apiKey, headers, models });
+        }
+    }
+    return out;
+}
+/**
+ * Build the TUI's provider config as a SINGLE `infinicode` provider pointing at
+ * the local kernel gateway. Real API keys stay server-side (the TUI only gets a
+ * dummy token); every model in the pool is exposed as `providerId/modelId`, plus
+ * an `auto` entry that lets the kernel router pick per request.
+ */
+function buildGatewayTuiConfig(gatewayUrl, providers) {
+    const models = { auto: { name: 'AUTO — kernel routes best model' } };
+    for (const p of providers) {
+        for (const m of p.models) {
+            models[`${p.id}/${m.id}`] = modelEntry({ id: `${p.id}/${m.id}`, name: m.name ?? m.id, contextLength: m.contextLength });
+        }
+    }
+    return {
+        infinicode: {
+            npm: '@ai-sdk/openai-compatible',
+            name: 'infinicode (kernel)',
+            options: { baseURL: gatewayUrl, apiKey: 'infinicode-gateway' },
+            models,
+        },
+    };
+}
+/**
+ * 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);
@@ -391,48 +477,110 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
     const cloudProviders = config.get('cloudProviders') ?? [];
     const enabledCloud = cloudProviders.filter(p => p.enabled);
     const policyName = config.get('policy') ?? 'balanced';
+    // Session kernel — lives for the whole TUI session. It is the routing/recovery
+    // brain the gateway and the mesh node both share, so every chat turn the TUI
+    // makes flows through the same warmed-up provider pool + event bus.
+    const sessionKernel = buildKernelFromConfig(config, { logger: new SilentLogger() });
     // Make this TUI session a mesh participant so the in-TUI slash commands
     // (/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);
-    if (mesh) {
-        process.env.INFINICODE_MESH_URL = mesh.url;
-        if (mesh.token)
-            process.env.INFINICODE_MESH_TOKEN = mesh.token;
-    }
+    const mesh = await startLocalMeshNode(config, sessionKernel);
+    // 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();
-    const { routed, modelsByProvider } = await prepareRouting(config, policyName);
+    const { routed, modelsByProvider } = await prepareRouting(config, policyName, sessionKernel);
     routeSpinner.stop();
-    const providers = buildProviderConfig(masterUrl, defaultModel, cloudProviders, masterReachable, modelsByProvider);
-    let defaultProvider;
-    let pickedModel;
-    if (routed && providers[routed.providerId]) {
-        defaultProvider = routed.providerId;
-        pickedModel = routed.modelId;
-        ensureModelInjected(providers, routed.providerId, routed.modelId);
+    // Stand up the OpenAI-compatible kernel gateway. The TUI points at THIS as its
+    // 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 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 (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);
+        // 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 {
-        const fb = await pickDefaultModel(config, masterReachable);
-        defaultProvider = fb.provider;
-        pickedModel = fb.model;
+        // Fallback: talk to providers directly (no kernel in the loop).
+        providers = buildProviderConfig(masterUrl, defaultModel, cloudProviders, masterReachable, modelsByProvider);
+        let defaultProvider;
+        let pickedModel;
+        if (routed && providers[routed.providerId]) {
+            defaultProvider = routed.providerId;
+            pickedModel = routed.modelId;
+            ensureModelInjected(providers, routed.providerId, routed.modelId);
+        }
+        else {
+            const fb = await pickDefaultModel(config, masterReachable);
+            defaultProvider = fb.provider;
+            pickedModel = fb.model;
+        }
+        modelRef = `${defaultProvider}/${pickedModel}`;
     }
-    const modelRef = `${defaultProvider}/${pickedModel}`;
-    const providerCount = Object.keys(providers).length;
+    const providerCount = gateway ? gwProviders.length : Object.keys(providers).length;
     const modelCount = Object.values(providers).reduce((n, p) => n + Object.keys(p.models ?? {}).length, 0);
     const policy = config.get('policy') ?? 'local-first';
     const pinnedCount = Object.keys(config.get('workerModels') ?? {}).length;
-    const routingInfo = `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);
+    const routingInfo = gateway
+        ? `KERNEL ${policy} ${providerCount}P ${pinnedCount}pins`
+        : `AUTO ${policy} ${providerCount}P ${pinnedCount}pins`;
+    // 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',
@@ -440,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,
@@ -455,6 +602,9 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
         },
     });
     console.log(chalk.dim(`\ninfinicode — launching TUI with ${chalk.cyan(String(providerCount))} provider(s), ${chalk.cyan(String(modelCount))} model(s)`));
+    if (gateway) {
+        console.log(chalk.dim(`  kernel gateway: ${chalk.green(gateway.url)} ${chalk.dim('(auto-routing + escalate-on-error)')}`));
+    }
     console.log(chalk.dim(`  default model: ${chalk.cyan(modelRef)}`));
     console.log(chalk.dim(`  policy: ${chalk.cyan(config.get('policy') ?? 'local-first')}`));
     if (enabledCloud.length > 0) {
@@ -479,6 +629,11 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
         console.log(chalk.cyan('  infinicode install-tui --url <url>') + chalk.dim(' # or download from a hosted binary'));
         process.exit(1);
     }
+    const cleanup = async () => {
+        await gateway?.stop().catch(() => undefined);
+        await mesh?.stop().catch(() => undefined);
+        sessionKernel.destroy();
+    };
     const { execa } = await import('execa');
     try {
         await execa(tuiBinary, [], {
@@ -487,12 +642,12 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
         });
     }
     catch (e) {
-        await mesh?.stop().catch(() => undefined);
+        await cleanup();
         const err = e;
         if (err.exitCode) {
             process.exit(err.exitCode);
         }
         throw e;
     }
-    await mesh?.stop().catch(() => undefined);
+    await cleanup();
 }