infinicode 2.3.5 → 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.5';
+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, 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/kernel/agents/backends/cli-backend.d.ts

@@ -0,0 +1,37 @@
+import type { AgentBackend, BackendId, BackendRunContext, BackendRunResult, BackendTask } from './types.js';
+/** Accumulator threaded through per-line parsing. */
+export interface CliParsed {
+    sessionId?: string;
+    content?: string;
+    isError?: boolean;
+}
+export interface CliBackendSpec {
+    id: BackendId;
+    displayName: string;
+    /** Binary name looked up on PATH (overridable via `binEnv`). */
+    bin: string;
+    /** argv for a fresh run. `prompt` already includes any role preamble. */
+    runArgs(prompt: string, task: BackendTask): string[];
+    /** argv to continue an existing session with a new message. */
+    resumeArgs?(sessionId: string, message: string, task: BackendTask): string[];
+    /** Parse one output line (or the whole raw output, as a fallback) into `acc`. */
+    parseLine(line: string, acc: CliParsed): void;
+    /** Extra process env. */
+    env?: NodeJS.ProcessEnv;
+    /** Env var overriding the binary path (e.g. INFINICODE_CLAUDE_BIN). */
+    binEnv?: string;
+    /** Env var of extra whitespace-split args appended to every invocation. */
+    extraArgsEnv?: string;
+}
+export declare class CliAgentBackend implements AgentBackend {
+    private spec;
+    readonly id: BackendId;
+    readonly displayName: string;
+    constructor(spec: CliBackendSpec);
+    private resolveBin;
+    available(): boolean;
+    private extraArgs;
+    run(task: BackendTask, ctx: BackendRunContext): Promise<BackendRunResult>;
+    send(sessionId: string, message: string, ctx: BackendRunContext): Promise<BackendRunResult>;
+    private exec;
+}

package/dist/kernel/agents/backends/cli-backend.js

@@ -0,0 +1,132 @@
+/**
+ * OpenKernel — Generic CLI agent backend
+ *
+ * Runs a third-party coding CLI (Claude Code / Codex / OpenCode) as the executor
+ * for a dispatched mesh task. Spawns the process, streams every stdout/stderr
+ * line up the mesh as a frame, and parses the CLI's output into a session id +
+ * final text so the run can be followed and (later) messaged again.
+ *
+ * A `CliBackendSpec` captures the per-CLI differences (binary, argv, parsing);
+ * everything else — spawning, streaming, cancellation — is shared here.
+ */
+import { spawn } from 'node:child_process';
+import { findExecutable } from './detect.js';
+export class CliAgentBackend {
+    spec;
+    id;
+    displayName;
+    constructor(spec) {
+        this.spec = spec;
+        this.id = spec.id;
+        this.displayName = spec.displayName;
+    }
+    resolveBin() {
+        const override = this.spec.binEnv ? process.env[this.spec.binEnv] : undefined;
+        if (override)
+            return override;
+        return findExecutable(this.spec.bin);
+    }
+    available() {
+        return this.resolveBin() !== null;
+    }
+    extraArgs() {
+        const raw = this.spec.extraArgsEnv ? process.env[this.spec.extraArgsEnv] : undefined;
+        return raw ? raw.split(/\s+/).filter(Boolean) : [];
+    }
+    async run(task, ctx) {
+        const prompt = task.prompt && ctx.rolePreamble ? `${ctx.rolePreamble}\n\n${task.prompt}` : task.prompt;
+        const argv = task.sessionId && this.spec.resumeArgs
+            ? this.spec.resumeArgs(task.sessionId, prompt, task)
+            : this.spec.runArgs(prompt, task);
+        return this.exec([...argv, ...this.extraArgs()], ctx);
+    }
+    async send(sessionId, message, ctx) {
+        const msg = ctx.rolePreamble ? `${ctx.rolePreamble}\n\n${message}` : message;
+        const task = { prompt: msg, sessionId };
+        const argv = this.spec.resumeArgs
+            ? this.spec.resumeArgs(sessionId, msg, task)
+            : this.spec.runArgs(msg, task);
+        return this.exec([...argv, ...this.extraArgs()], ctx);
+    }
+    exec(argv, ctx) {
+        return new Promise(resolve => {
+            const bin = this.resolveBin();
+            if (!bin) {
+                resolve({ status: 'failed', error: `${this.spec.bin} not found on PATH` });
+                return;
+            }
+            const child = spawn(bin, argv, {
+                cwd: ctx.cwd ?? process.cwd(),
+                env: { ...process.env, ...this.spec.env },
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            const acc = {};
+            let stdoutBuf = '';
+            let rawAll = '';
+            let stderrTail = '';
+            let settled = false;
+            const onAbort = () => {
+                try {
+                    child.kill();
+                }
+                catch { /* already gone */ }
+            };
+            ctx.signal?.addEventListener('abort', onAbort, { once: true });
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                ctx.signal?.removeEventListener('abort', onAbort);
+                resolve(result);
+            };
+            child.stdout.setEncoding('utf8');
+            child.stdout.on('data', (chunk) => {
+                rawAll += chunk;
+                stdoutBuf += chunk;
+                let nl;
+                while ((nl = stdoutBuf.indexOf('\n')) >= 0) {
+                    const line = stdoutBuf.slice(0, nl).replace(/\r$/, '');
+                    stdoutBuf = stdoutBuf.slice(nl + 1);
+                    if (!line.trim())
+                        continue;
+                    try {
+                        this.spec.parseLine(line, acc);
+                    }
+                    catch { /* tolerant parsing */ }
+                    ctx.onFrame({ kind: 'log', text: line });
+                }
+            });
+            child.stderr.setEncoding('utf8');
+            child.stderr.on('data', (chunk) => {
+                stderrTail = (stderrTail + chunk).slice(-2000);
+                const trimmed = chunk.replace(/\s+$/, '');
+                if (trimmed)
+                    ctx.onFrame({ kind: 'log', text: trimmed });
+            });
+            child.on('error', err => finish({ status: 'failed', error: err.message }));
+            child.on('close', code => {
+                // Flush a trailing partial line.
+                if (stdoutBuf.trim()) {
+                    try {
+                        this.spec.parseLine(stdoutBuf.trim(), acc);
+                    }
+                    catch { /* ignore */ }
+                }
+                // Fallback for CLIs that pretty-print one multi-line JSON object.
+                if (!acc.content && !acc.sessionId && rawAll.trim()) {
+                    try {
+                        this.spec.parseLine(rawAll.trim(), acc);
+                    }
+                    catch { /* ignore */ }
+                }
+                const ok = !acc.isError && (code === 0 || !!acc.content);
+                finish({
+                    status: ok ? 'completed' : 'failed',
+                    sessionId: acc.sessionId,
+                    content: acc.content,
+                    error: ok ? undefined : (stderrTail.trim() || acc.content || `${this.spec.bin} exited with code ${code}`),
+                });
+            });
+        });
+    }
+}

package/dist/kernel/agents/backends/detect.d.ts

@@ -0,0 +1,5 @@
+/** Absolute path to `bin` on PATH, or null if not found. */
+export declare function findExecutable(bin: string): string | null;
+export declare function hasExecutable(bin: string): boolean;
+/** Test hook — forget cached lookups. */
+export declare function clearExecutableCache(): void;