infinicode 2.3.6 → 2.5.0

package/dist/commands/serve.js

@@ -11,10 +11,25 @@
  */
 import chalk from 'chalk';
 import { readFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { buildKernelFromConfig, registerCloudProviders } from '../kernel/setup.js';
-import { Federation, MoltfedConnector, loadOrCreateIdentity } from '../kernel/index.js';
+import { Federation, MoltfedConnector, loadOrCreateIdentity, loadRole } from '../kernel/index.js';
+import { runMaintenanceTask, loadLastMaintenanceTask } from './maintain.js';
+/** ws(s):// gateway URL -> http(s):// base, for the plain-HTTP command poll
+ *  (the WS RPC channel is fire-and-forget, no request/response tracking —
+ *  simpler to poll a raw route than extend that channel to support it). */
+function httpBaseFromWsUrl(wsUrl) {
+    try {
+        const u = new URL(wsUrl);
+        u.protocol = u.protocol === 'wss:' ? 'https:' : 'http:';
+        return u.origin;
+    }
+    catch {
+        return null;
+    }
+}
 function pkgVersion() {
     try {
         const here = dirname(fileURLToPath(import.meta.url));
@@ -24,12 +39,56 @@ function pkgVersion() {
         return '0.0.0';
     }
 }
+/** Read-only kernel commands — the only ones an unauthenticated, network-exposed
+ *  node will run. Control commands require a token (see commandGate below). */
+const READ_ONLY_COMMANDS = new Set([
+    '/status', '/nodes', '/activity', '/running', '/agents',
+    '/health', '/help', '/who', '/role', '/hardware', '/peers',
+]);
+function isLoopback(host) {
+    return host === '127.0.0.1' || host === 'localhost' || host === '::1';
+}
 export async function serve(config, opts) {
     const fed = config.get('federation') ?? {};
     const role = (opts.hub ? 'hub' : opts.role ?? fed.role ?? 'peer');
     const port = opts.port ? parseInt(opts.port, 10) : fed.port ?? 47913;
     const seeds = [...(fed.seeds ?? []), ...(opts.seed ?? [])];
-    const token = opts.token ?? fed.token;
+    const bindHost = opts.host ?? fed.host ?? '0.0.0.0';
+    let token = opts.token ?? fed.token;
+    // Secure-by-default: a control dashboard exposed on a routable interface with
+    // no token is a wide-open remote. If the operator asked for the dashboard but
+    // set no token, mint a session token so the surface isn't unauthenticated.
+    if (opts.dashboard && !token && !isLoopback(bindHost)) {
+        token = randomBytes(9).toString('base64url');
+        console.log(chalk.yellow(`  ⚠ dashboard exposed on ${bindHost} without --token — generated a session token.`));
+        console.log(chalk.yellow(`    peers must now connect with  --token ${token}`));
+    }
+    // Keep a network-exposed, tokenless node read-only: it will answer status/map
+    // queries but refuse control commands until a token is set. Loopback-only or
+    // token-protected nodes are trusted and run everything.
+    const trusted = Boolean(token) || isLoopback(bindHost);
+    const commandGate = (input) => {
+        if (trusted)
+            return { ok: true };
+        const name = input.trim().split(/\s+/)[0]?.toLowerCase() ?? '';
+        if (READ_ONLY_COMMANDS.has(name))
+            return { ok: true };
+        return {
+            ok: false,
+            reason: 'this node is network-exposed without a token — only read-only commands are allowed. Restart with --token <secret> to enable control commands.',
+        };
+    };
+    // Optional TLS material for an HTTPS dashboard/mesh.
+    let tls;
+    if (opts.tlsCert && opts.tlsKey) {
+        try {
+            tls = { cert: readFileSync(opts.tlsCert), key: readFileSync(opts.tlsKey) };
+        }
+        catch (err) {
+            console.log(chalk.red(`  ✗ could not read TLS cert/key: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    }
     const kernel = buildKernelFromConfig(config);
     const identity = loadOrCreateIdentity({ role, displayName: opts.name ?? fed.displayName });
     // Manifest inputs are read live from the kernel so the map shows real caps.
@@ -61,7 +120,26 @@ export async function serve(config, opts) {
             config.set('defaultModel', cfg.defaultModel);
         console.log(chalk.green(`  ✓ sourced shared config from hub (rev ${cfg.revision}) — ${live} provider(s) live`));
     };
-    const federation = new 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 = () => ({
+        cloudProviders: config.get('cloudProviders'),
+        policy: config.get('policy'),
+        defaultModel: config.get('defaultModel'),
+    });
+    // Dashboard "Apply config to fleet" / POST /fed/apply → re-publish shared
+    // config to every connected satellite right now (cross-process nudge: the
+    // serve daemon holds the mesh; the CLI can't reach satellites directly).
+    let federation;
+    const onApply = () => {
+        if (role === 'satellite') {
+            return { ok: false, text: 'this node is a satellite — it sources config from its hub, it does not publish.' };
+        }
+        const cfg = federation.publishConfig(sharedFromConf());
+        const n = federation.peers().filter(p => p.role === 'satellite').length;
+        return { ok: true, text: `published config rev ${cfg.revision} to the fleet (${n} satellite peer${n === 1 ? '' : 's'})` };
+    };
+    federation = new Federation({
         kernel,
         identity,
         describe,
@@ -75,17 +153,17 @@ export async function serve(config, opts) {
             autoUpdate: opts.autoUpdate ?? fed.autoUpdate,
             applyConfig,
             autoPullConfig: role === 'satellite',
+            dashboard: opts.dashboard,
+            onApply,
+            commandGate,
+            tls,
+            schedulerUrl: opts.schedulerUrl ?? fed.schedulerUrl,
+            schedulerToken: opts.schedulerToken,
+            schedulerReadOnly: !trusted,
         },
     });
     // 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 = () => ({
-        cloudProviders: config.get('cloudProviders'),
-        policy: config.get('policy'),
-        defaultModel: config.get('defaultModel'),
-    });
     if (role !== 'satellite') {
         federation.publishConfig(sharedFromConf());
         for (const key of ['cloudProviders', 'policy', 'defaultModel']) {
@@ -101,6 +179,18 @@ export async function serve(config, opts) {
         console.log(`  auth:   ${chalk.green('token required')}`);
     console.log();
     await federation.start();
+    // Control dashboard link — prefer a reachable host over the 0.0.0.0 wildcard.
+    if (opts.dashboard) {
+        const uiHost = isLoopback(bindHost) || bindHost === '0.0.0.0' ? 'localhost' : bindHost;
+        const scheme = tls ? 'https' : 'http';
+        const url = `${scheme}://${uiHost}:${port}/${token ? `?token=${token}` : ''}`;
+        console.log(chalk.bold(`  dashboard: ${chalk.cyan(url)}`));
+        if (opts.schedulerUrl)
+            console.log(chalk.dim(`    scheduler linked: ${opts.schedulerUrl} (sessions + telemetry tabs live)`));
+        if (!token)
+            console.log(chalk.dim('    (no token — anyone who can reach this port can control the fleet; add --token to lock it)'));
+        console.log();
+    }
     // Connect to seeds. Satellites auto-source shared config from any hub/relay
     // they connect to (handled inside federation.connect()).
     for (const url of seeds) {
@@ -119,7 +209,13 @@ export async function serve(config, opts) {
         console.log(chalk.green(`  ✓ LAN auto-discovery on (udp broadcast) — peers on this subnet connect automatically`));
     }
     // Optional: log this node into an InfiniBot gateway so it renders live on the
-    // neural-mesh map + hardware panels (no InfiniBot changes needed).
+    // fleet map + hardware panels via the infinibot-plugin-infinicode plugin.
+    // NOTE: these method names target that plugin's registered gateway methods,
+    // NOT InfiniBot's core nodes.status/hardware.snapshot/agent.event — those
+    // are claimed for InfiniBot's own paired-device list and internal satellite
+    // protocol respectively, and agent.event doesn't exist on the core gateway
+    // at all. Without the plugin installed on the target gateway, these pushes
+    // are harmless no-ops (unknown method).
     let connector;
     if (opts.gateway) {
         connector = new MoltfedConnector({
@@ -131,12 +227,75 @@ export async function serve(config, opts) {
             getNodeStatuses: () => federation.nodeStatuses(),
             getHardware: () => federation.latestHardware(),
             subscribeFrames: (cb) => federation.onFrames(cb),
+            methodNodes: 'infinicode.push.status',
+            methodHardware: 'infinicode.push.hardware',
+            methodAgent: 'infinicode.push.event',
         });
         connector.start();
         console.log(chalk.green(`  ✓ linking to InfiniBot gateway ${opts.gateway}`));
     }
+    // Optional: poll for on-demand commands queued from the InfiniBot Fleet
+    // view (e.g. "run maintenance now"). Plain HTTP GET against the plugin's
+    // own route — separate from the WS push channel above, which has no
+    // request/response tracking. No-op (empty list) until the operator
+    // actually queues something, so this is cheap to leave running.
+    let commandPoll;
+    const httpBase = opts.gateway ? httpBaseFromWsUrl(opts.gateway) : null;
+    if (httpBase) {
+        const pollUrl = `${httpBase}/plugins/infinicode/commands?nodeId=${encodeURIComponent(identity.nodeId)}`;
+        commandPoll = setInterval(() => {
+            void (async () => {
+                let commands;
+                try {
+                    const res = await fetch(pollUrl, { signal: AbortSignal.timeout(5000) });
+                    if (!res.ok)
+                        return;
+                    const body = await res.json();
+                    commands = body.commands ?? [];
+                }
+                catch {
+                    return; // gateway/plugin unreachable this cycle — try again next tick
+                }
+                if (!commands.length)
+                    return;
+                // The trigger carries no task content by design — replay ONLY the
+                // task this device already ran locally (cron/CLI), never anything
+                // network-supplied. See loadLastMaintenanceTask.
+                const cached = loadLastMaintenanceTask();
+                for (const cmd of commands) {
+                    if (cmd.kind !== 'run-last-maintenance')
+                        continue;
+                    if (!cached) {
+                        console.log(chalk.yellow('  ⚠ "run now" received but no maintenance task has ever run on this device — run `infinicode maintain "..."` once first'));
+                        connector?.request('infinicode.push.report', {
+                            nodeId: identity.nodeId,
+                            role: loadRole()?.role ?? identity.nodeId,
+                            site: loadRole()?.site,
+                            taskName: 'run-now (no task configured)',
+                            startedAt: Date.now(),
+                            finishedAt: Date.now(),
+                            durationMs: 0,
+                            ok: false,
+                            summary: 'no maintenance task has run on this device yet — run `infinicode maintain "..."` once to establish one',
+                        });
+                        continue;
+                    }
+                    console.log(chalk.cyan(`  ▸ re-running last maintenance task: ${cached.taskName ?? cached.taskPrompt.slice(0, 60)}`));
+                    const report = await runMaintenanceTask(kernel, cached.taskPrompt, {
+                        nodeId: identity.nodeId,
+                        role: loadRole(),
+                        taskName: cached.taskName,
+                    });
+                    connector?.request('infinicode.push.report', report);
+                    console.log(report.ok ? chalk.green('    ✓ done') : chalk.red('    ✗ failed'));
+                }
+            })();
+        }, 10_000);
+    }
     const shutdown = async () => {
         console.log(chalk.dim('\n  stopping mesh…'));
+        if (commandPoll)
+            clearInterval(commandPoll);
         connector?.stop();
         await federation.stop();
         kernel.destroy();

package/dist/kernel/agents/backends/cli-backend.d.ts

@@ -29,6 +29,10 @@ export declare class CliAgentBackend implements AgentBackend {
     readonly displayName: string;
     constructor(spec: CliBackendSpec);
     private resolveBin;
+    /** A directly-spawnable target — on Windows unwraps the npm shim to the real
+     *  executable so `spawn` (array args, no shell) works and multi-line prompts
+     *  survive intact. */
+    private resolveSpawn;
     available(): boolean;
     private extraArgs;
     run(task: BackendTask, ctx: BackendRunContext): Promise<BackendRunResult>;

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

@@ -10,7 +10,7 @@
  * everything else — spawning, streaming, cancellation — is shared here.
  */
 import { spawn } from 'node:child_process';
-import { findExecutable } from './detect.js';
+import { findExecutable, resolveSpawnTarget } from './detect.js';
 export class CliAgentBackend {
     spec;
     id;
@@ -26,6 +26,13 @@ export class CliAgentBackend {
             return override;
         return findExecutable(this.spec.bin);
     }
+    /** A directly-spawnable target — on Windows unwraps the npm shim to the real
+     *  executable so `spawn` (array args, no shell) works and multi-line prompts
+     *  survive intact. */
+    resolveSpawn() {
+        const override = this.spec.binEnv ? process.env[this.spec.binEnv] : undefined;
+        return resolveSpawnTarget(this.spec.bin, override);
+    }
     available() {
         return this.resolveBin() !== null;
     }
@@ -38,7 +45,7 @@ export class CliAgentBackend {
         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);
+        return this.exec([...argv, ...(task.args ?? []), ...this.extraArgs()], ctx);
     }
     async send(sessionId, message, ctx) {
         const msg = ctx.rolePreamble ? `${ctx.rolePreamble}\n\n${message}` : message;
@@ -50,15 +57,16 @@ export class CliAgentBackend {
     }
     exec(argv, ctx) {
         return new Promise(resolve => {
-            const bin = this.resolveBin();
-            if (!bin) {
+            const target = this.resolveSpawn();
+            if (!target) {
                 resolve({ status: 'failed', error: `${this.spec.bin} not found on PATH` });
                 return;
             }
-            const child = spawn(bin, argv, {
+            const child = spawn(target.command, [...target.prefixArgs, ...argv], {
                 cwd: ctx.cwd ?? process.cwd(),
                 env: { ...process.env, ...this.spec.env },
                 stdio: ['ignore', 'pipe', 'pipe'],
+                windowsHide: true,
             });
             const acc = {};
             let stdoutBuf = '';

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

@@ -3,3 +3,15 @@ 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;
+/** A directly-spawnable target: a command plus fixed leading args (e.g. node + a .js). */
+export interface SpawnTarget {
+    command: string;
+    prefixArgs: string[];
+}
+/**
+ * Resolve `bin` (or an explicit `override` path) to a directly-spawnable target.
+ * Non-Windows and real `.exe`/`.com` hits pass through untouched; Windows npm
+ * shims are unwrapped to the executable they delegate to. Returns null when
+ * nothing is found.
+ */
+export declare function resolveSpawnTarget(bin: string, override?: string): SpawnTarget | null;

package/dist/kernel/agents/backends/detect.js

@@ -5,8 +5,8 @@
  * can advertise availability without spawning `--version`. Results are cached —
  * a device's installed CLIs don't change mid-process.
  */
-import { existsSync } from 'node:fs';
-import { join, delimiter } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, delimiter, dirname } from 'node:path';
 const cache = new Map();
 /** Absolute path to `bin` on PATH, or null if not found. */
 export function findExecutable(bin) {
@@ -38,3 +38,103 @@ export function hasExecutable(bin) {
 export function clearExecutableCache() {
     cache.clear();
 }
+function substVars(token, dir) {
+    // sh launcher uses $basedir; cmd shim uses %dp0% / %~dp0%. Both = shim dir.
+    let t = token
+        .replace(/\$\{basedir\}|\$basedir/g, dir)
+        .replace(/%~?dp0%\\?|%dp0%\\?/gi, dir + '\\');
+    if (process.platform === 'win32')
+        t = t.replace(/\//g, '\\').replace(/\\{2,}/g, '\\');
+    return t;
+}
+function tokenizeShellish(s) {
+    const out = [];
+    let cur = '';
+    let quoted = false;
+    let has = false;
+    for (const ch of s) {
+        if (ch === '"') {
+            quoted = !quoted;
+            has = true;
+            continue;
+        }
+        if (!quoted && /\s/.test(ch)) {
+            if (has) {
+                out.push(cur);
+                cur = '';
+                has = false;
+            }
+            continue;
+        }
+        cur += ch;
+        has = true;
+    }
+    if (has)
+        out.push(cur);
+    return out;
+}
+function mapCommand(token) {
+    // A bare `node` / `node.exe` invocation → the running interpreter, which is
+    // guaranteed present and avoids a second PATH lookup.
+    const base = token.replace(/\\/g, '/').split('/').pop()?.toLowerCase();
+    if (base === 'node' || base === 'node.exe')
+        return process.execPath;
+    return token;
+}
+/**
+ * Read an npm shim and extract the real executable it invokes.
+ * Handles the `#!/bin/sh` launcher (`exec "<prog>" [args] "$@"`) and the simple
+ * `.cmd` form (`"<prog>" [args] %*`). Returns a SpawnTarget or null.
+ */
+function unwrapNpmShim(shimPath) {
+    let text;
+    try {
+        text = readFileSync(shimPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const dir = dirname(shimPath);
+    // sh launcher: the operative line is `exec <prog> [fixed args] "$@"`.
+    const sh = text.match(/^\s*exec\s+(.*?)\s+"\$@"\s*$/m);
+    if (sh) {
+        const toks = tokenizeShellish(sh[1]).map(t => substVars(t, dir)).filter(Boolean);
+        if (toks.length) {
+            const [cmd, ...rest] = toks;
+            return { command: mapCommand(cmd), prefixArgs: rest };
+        }
+    }
+    // .cmd shim: the last line ending in `%*` carries the quoted target + args.
+    for (const line of text.split(/\r?\n/).reverse()) {
+        if (!/%\*/.test(line))
+            continue;
+        const quoted = [...line.matchAll(/"([^"]*)"/g)]
+            .map(m => substVars(m[1], dir))
+            .filter(t => t && !t.includes('%'));
+        if (quoted.length) {
+            const [cmd, ...rest] = quoted;
+            return { command: mapCommand(cmd), prefixArgs: rest };
+        }
+    }
+    return null;
+}
+/**
+ * Resolve `bin` (or an explicit `override` path) to a directly-spawnable target.
+ * Non-Windows and real `.exe`/`.com` hits pass through untouched; Windows npm
+ * shims are unwrapped to the executable they delegate to. Returns null when
+ * nothing is found.
+ */
+export function resolveSpawnTarget(bin, override) {
+    const hit = override || findExecutable(bin);
+    if (!hit)
+        return null;
+    if (process.platform !== 'win32')
+        return { command: hit, prefixArgs: [] };
+    const lower = hit.toLowerCase();
+    if (lower.endsWith('.exe') || lower.endsWith('.com'))
+        return { command: hit, prefixArgs: [] };
+    const unwrapped = unwrapNpmShim(hit);
+    if (unwrapped && existsSync(unwrapped.command))
+        return unwrapped;
+    return { command: hit, prefixArgs: [] };
+}

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

@@ -0,0 +1,67 @@
+/**
+ * OpenKernel — Coder profiles
+ *
+ * A *profile* is a named, reusable coder configuration: which backend CLI to
+ * run (claude / codex / opencode / gemini), which model, and any extra args/env.
+ * Profiles are what the rotation engine (see `rotation.ts`) chooses between, so
+ * the orchestrator can say "run this on the `deep` profile" or "rotate across
+ * the cheap tier" without hard-coding a backend + model at every call site.
+ *
+ * Profiles carry lightweight cost/speed/quality metadata so a policy tier
+ * (free-first / fastest / highest-quality / …) can order them, plus `tags` a
+ * task-type router can match against.
+ *
+ * Config lives under `coder` in the node config; anything omitted falls back to
+ * the built-in defaults below so the mesh works out of the box.
+ */
+import type { BackendId } from './types.js';
+/** A named coder configuration the rotation engine can select. */
+export interface CoderProfile {
+    /** Stable name, e.g. "deep", "cheap". Filled in by the loader from the map key. */
+    name: string;
+    /** Which CLI backend runs it. */
+    backend: BackendId;
+    /** Model id in that backend's native format (e.g. "opus", "gpt-5-codex"). */
+    model?: string;
+    /** Extra CLI args appended for this profile (via the backend's ARGS env). */
+    args?: string[];
+    /** Extra process env for this profile. */
+    env?: Record<string, string>;
+    /** Relative $ per task — lower is cheaper. Used by cost policies. */
+    cost?: number;
+    /** Relative throughput — higher is faster. Used by the `fastest` policy. */
+    speed?: number;
+    /** Relative capability — higher is stronger. Used by `highest-quality`. */
+    quality?: number;
+    /** Task-type tags this profile is a good fit for (matched by the router). */
+    tags?: string[];
+}
+export type RotationStrategy = 'auto' | 'tasktype' | 'policy' | 'roundrobin' | 'fallback';
+export type CoderPolicy = 'free-first' | 'cheapest' | 'fastest' | 'highest-quality' | 'balanced';
+/** The `coder` config block. Everything is optional; defaults fill the gaps. */
+export interface CoderConfig {
+    profiles: Record<string, CoderProfile>;
+    /** Default ordered profile names used by roundrobin/fallback. */
+    rotation: string[];
+    /** Default strategy when a caller doesn't specify one. */
+    strategy: RotationStrategy;
+    /** Default policy when strategy resolves to policy ordering. */
+    policy: CoderPolicy;
+    /** Task-type → ordered profile names (task-type routing). */
+    routes: Record<string, string[]>;
+    /** Fallback profile when nothing else matches. */
+    defaultProfile: string;
+}
+/**
+ * Built-in profiles — one per backend plus a couple of tiers. Models are the
+ * common ids; override in config for your accounts. `cost`/`speed`/`quality`
+ * are relative (1–10) and only used to order policy tiers.
+ */
+export declare const DEFAULT_PROFILES: Record<string, CoderProfile>;
+/**
+ * Merge a raw `coder` config object (from node config) over the built-in
+ * defaults, filling `name` from the map key. Safe to call with `undefined`.
+ */
+export declare function loadCoderConfig(raw?: Partial<CoderConfig> & {
+    profiles?: Record<string, Partial<CoderProfile>>;
+}): CoderConfig;

package/dist/kernel/agents/backends/profiles.js

@@ -0,0 +1,48 @@
+/**
+ * Built-in profiles — one per backend plus a couple of tiers. Models are the
+ * common ids; override in config for your accounts. `cost`/`speed`/`quality`
+ * are relative (1–10) and only used to order policy tiers.
+ */
+export const DEFAULT_PROFILES = {
+    deep: { name: 'deep', backend: 'claude', model: 'opus', cost: 9, speed: 4, quality: 10, tags: ['refactor', 'architecture', 'debug', 'hard'] },
+    fast: { name: 'fast', backend: 'claude', model: 'sonnet', cost: 5, speed: 7, quality: 8, tags: ['edit', 'feature', 'test'] },
+    precise: { name: 'precise', backend: 'codex', model: 'gpt-5-codex', cost: 6, speed: 6, quality: 8, tags: ['precision', 'polyglot', 'fix'] },
+    cheap: { name: 'cheap', backend: 'gemini', model: 'gemini-2.5-flash', cost: 1, speed: 9, quality: 6, tags: ['bulk', 'docs', 'boilerplate', 'cheap'] },
+    oss: { name: 'oss', backend: 'opencode', cost: 2, speed: 6, quality: 6, tags: ['fallback', 'oss'] },
+};
+/** Default rotation across all four backends (balances cost + capability). */
+const DEFAULT_ROTATION = ['fast', 'precise', 'cheap', 'oss', 'deep'];
+/** Sensible task-type routes → ordered profiles (head is primary, rest fallback). */
+const DEFAULT_ROUTES = {
+    refactor: ['deep', 'precise', 'fast'],
+    architecture: ['deep', 'fast'],
+    debug: ['deep', 'precise', 'fast'],
+    feature: ['fast', 'precise', 'deep'],
+    edit: ['fast', 'cheap', 'precise'],
+    test: ['fast', 'precise'],
+    docs: ['cheap', 'fast'],
+    bulk: ['cheap', 'oss', 'fast'],
+    boilerplate: ['cheap', 'oss'],
+    fix: ['precise', 'fast', 'deep'],
+};
+/**
+ * Merge a raw `coder` config object (from node config) over the built-in
+ * defaults, filling `name` from the map key. Safe to call with `undefined`.
+ */
+export function loadCoderConfig(raw) {
+    const profiles = {};
+    const merged = { ...DEFAULT_PROFILES, ...(raw?.profiles ?? {}) };
+    for (const [key, p] of Object.entries(merged)) {
+        if (!p?.backend)
+            continue; // a profile must name a backend
+        profiles[key] = { ...(DEFAULT_PROFILES[key] ?? {}), ...p, name: key, backend: p.backend };
+    }
+    return {
+        profiles,
+        rotation: (raw?.rotation ?? DEFAULT_ROTATION).filter(n => profiles[n]),
+        strategy: raw?.strategy ?? 'auto',
+        policy: raw?.policy ?? 'balanced',
+        routes: { ...DEFAULT_ROUTES, ...(raw?.routes ?? {}) },
+        defaultProfile: raw?.defaultProfile && profiles[raw.defaultProfile] ? raw.defaultProfile : (profiles['fast'] ? 'fast' : Object.keys(profiles)[0]),
+    };
+}

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

@@ -15,6 +15,7 @@ import { type CliBackendSpec } from './cli-backend.js';
 declare const CLAUDE_SPEC: CliBackendSpec;
 declare const OPENCODE_SPEC: CliBackendSpec;
 declare const CODEX_SPEC: CliBackendSpec;
+declare const GEMINI_SPEC: CliBackendSpec;
 export declare class AgentBackendRegistry {
     private map;
     register(backend: AgentBackend): this;
@@ -27,4 +28,4 @@ export declare class AgentBackendRegistry {
 }
 /** Registry seeded with the built-in CLI backends (availability checked lazily). */
 export declare function createDefaultBackendRegistry(): AgentBackendRegistry;
-export { CLAUDE_SPEC, OPENCODE_SPEC, CODEX_SPEC };
+export { CLAUDE_SPEC, OPENCODE_SPEC, CODEX_SPEC, GEMINI_SPEC };

package/dist/kernel/agents/backends/registry.js

@@ -9,15 +9,17 @@ const CLAUDE_SPEC = {
     bin: 'claude',
     binEnv: 'INFINICODE_CLAUDE_BIN',
     extraArgsEnv: 'INFINICODE_CLAUDE_ARGS',
-    runArgs: prompt => [
+    runArgs: (prompt, task) => [
         '-p', prompt,
+        ...(task.model ? ['--model', task.model] : []),
         '--output-format', 'stream-json',
         '--verbose',
         '--dangerously-skip-permissions',
     ],
-    resumeArgs: (sessionId, message) => [
+    resumeArgs: (sessionId, message, task) => [
         '--resume', sessionId,
         '-p', message,
+        ...(task.model ? ['--model', task.model] : []),
         '--output-format', 'stream-json',
         '--verbose',
         '--dangerously-skip-permissions',
@@ -84,7 +86,7 @@ const CODEX_SPEC = {
     bin: 'codex',
     binEnv: 'INFINICODE_CODEX_BIN',
     extraArgsEnv: 'INFINICODE_CODEX_ARGS',
-    runArgs: prompt => ['exec', prompt],
+    runArgs: (prompt, task) => ['exec', ...(task.model ? ['--model', task.model] : []), prompt],
     resumeArgs: (sessionId, message) => ['exec', 'resume', sessionId, message],
     parseLine: (line, acc) => {
         const obj = tryJson(line);
@@ -105,6 +107,37 @@ const CODEX_SPEC = {
         acc.content = acc.content ? `${acc.content}\n${line}` : line;
     },
 };
+// ── Gemini ───────────────────────────────────────────────────────────────────
+// `gemini -p "<prompt>"` = non-interactive. `-y` (yolo) auto-approves tool
+// actions. Output is plain text by default, so parse defensively: JSON when a
+// tool version emits it, otherwise accumulate the printed answer.
+const GEMINI_SPEC = {
+    id: 'gemini',
+    displayName: 'Gemini CLI',
+    bin: 'gemini',
+    binEnv: 'INFINICODE_GEMINI_BIN',
+    extraArgsEnv: 'INFINICODE_GEMINI_ARGS',
+    runArgs: (prompt, task) => [
+        ...(task.model ? ['-m', task.model] : []),
+        '-y',
+        '-p', prompt,
+    ],
+    parseLine: (line, acc) => {
+        const obj = tryJson(line);
+        if (obj) {
+            const sid = extractSessionId(obj);
+            if (sid)
+                acc.sessionId ??= sid;
+            const t = extractText(obj);
+            if (t)
+                acc.content = t;
+            if (obj.error || obj.is_error === true)
+                acc.isError = true;
+            return;
+        }
+        acc.content = acc.content ? `${acc.content}\n${line}` : line;
+    },
+};
 export class AgentBackendRegistry {
     map = new Map();
     register(backend) {
@@ -135,6 +168,7 @@ export function createDefaultBackendRegistry() {
     return new AgentBackendRegistry()
         .register(new CliAgentBackend(CLAUDE_SPEC))
         .register(new CliAgentBackend(OPENCODE_SPEC))
-        .register(new CliAgentBackend(CODEX_SPEC));
+        .register(new CliAgentBackend(CODEX_SPEC))
+        .register(new CliAgentBackend(GEMINI_SPEC));
 }
-export { CLAUDE_SPEC, OPENCODE_SPEC, CODEX_SPEC };
+export { CLAUDE_SPEC, OPENCODE_SPEC, CODEX_SPEC, GEMINI_SPEC };