infinicode 2.3.6 → 2.4.0

package/dist/kernel/federation/federation.d.ts

@@ -11,13 +11,14 @@
  * (heartbeat / task.dispatch / command / config / update).
  */
 import type { Capability, KernelLike, Logger } from '../types.js';
-import type { HardwareSnapshot, NodeIdentity, NodeStatus, PeerInfo, SharedConfig, StreamFrame } from './types.js';
+import type { HardwareSnapshot, NodeIdentity, NodeManifest, NodeStatus, PeerInfo, SharedConfig, StreamFrame } from './types.js';
 import { ConfigSync } from './config-sync.js';
 import { AutoUpdate } from './auto-update.js';
 import { ComputeRouter, type ComputeNeed } from './compute-router.js';
 import { type ManifestInputs } from './node-identity.js';
 import { type AgentHandle, type RoleContext, type RunRecord } from './types.js';
 import { AgentBackendRegistry, type BackendId } from '../agents/index.js';
+import { loadCoderConfig, type CoderConfig } from '../agents/backends/profiles.js';
 export interface DispatchTask {
     description: string;
     capabilities: Capability[];
@@ -34,6 +35,14 @@ export interface DispatchTask {
     sessionId?: string;
     /** Model hint passed to a CLI backend (provider/model or a CLI-native id). */
     model?: string;
+    /** Named coder profile to run (e.g. "deep", "cheap"). */
+    profile?: string;
+    /** Rotation strategy: 'auto' | 'tasktype' | 'policy' | 'roundrobin' | 'fallback'. */
+    strategy?: string;
+    /** Policy tier: 'free-first' | 'cheapest' | 'fastest' | 'highest-quality' | 'balanced'. */
+    policy?: string;
+    /** Task-type key for routing (e.g. 'refactor', 'docs', 'bulk'). */
+    taskType?: string;
 }
 export interface FederationOptions {
     version: string;
@@ -51,6 +60,34 @@ export interface FederationOptions {
     autoPullConfig?: boolean;
     /** Satellite: how often to re-pull shared config (ms, default 30000; 0 disables). */
     configPullMs?: number;
+    /** Coder profiles + rotation config (from node config `coder`). Merged over
+     *  built-in defaults, so the mesh rotates across backends out of the box. */
+    coder?: Parameters<typeof loadCoderConfig>[0];
+    /** Serve the web control dashboard at GET / and /ui (off unless enabled). */
+    dashboard?: boolean;
+    /** Publish this node's shared config to the fleet (backs POST /fed/apply +
+     *  the dashboard's "Apply config to fleet" button). */
+    onApply?: () => Promise<unknown> | unknown;
+    /** Gate remote/dashboard slash-commands. Returns {ok:false,reason} to reject —
+     *  used to keep an unauthenticated, network-exposed node read-only. */
+    commandGate?: (input: string) => {
+        ok: boolean;
+        reason?: string;
+    };
+}
+/** Consolidated fleet view served at GET /fed/status. */
+export interface FleetStatus {
+    self: NodeManifest;
+    role: RoleContext | null;
+    nodes: NodeStatus[];
+    hardware?: HardwareSnapshot;
+    runs: RunRecord[];
+    agents: AgentHandle[];
+    activity: Array<{
+        peerId: string;
+        f: StreamFrame;
+    }>;
+    ts: number;
 }
 export interface FederationDeps {
     kernel: KernelLike;
@@ -83,6 +120,10 @@ export declare class Federation {
     readonly compute: ComputeRouter;
     /** Executors available on this node (native kernel + installed CLIs). */
     readonly backends: AgentBackendRegistry;
+    /** Resolved coder profiles + rotation policy for this node. */
+    readonly coderConfig: CoderConfig;
+    /** Per-node round-robin cursor for backend rotation. */
+    private readonly rotationState;
     /** Local subscribers to the merged mesh frame stream (for MCP stream_activity). */
     private frameSubs;
     /** Recent frames for catch-up. */
@@ -110,6 +151,20 @@ export declare class Federation {
      * is captured on the RunRecord so the run can be followed and later messaged.
      */
     private runViaBackend;
+    /** Stream one backend's frames up the mesh, tagged with the backend id. */
+    private backendFrameSink;
+    /** Run a single backend attempt. Never throws — a missing/unavailable backend
+     *  returns a failed result so a rotation chain can fall through to the next. */
+    private runBackendOnce;
+    /** Write a backend result onto the run record. */
+    private writeResult;
+    /**
+     * Resolve a rotation chain for the task and run it with fallback: try each
+     * profile's backend in order, streaming its activity; the first `completed`
+     * wins, otherwise fall through to the next. Composes task-type routing, policy
+     * tiers, round-robin and fallback (see agents/backends/rotation.ts).
+     */
+    private runViaBackendChain;
     /**
      * Hand a task to the best-fit connected peer (compute-routed) or a named one.
      * Non-blocking by default — returns a runId to follow. Pass wait to block
@@ -203,6 +258,8 @@ export declare class Federation {
     /** Neutral node-status list (self + peers) — feeds the mesh map. */
     nodeStatuses(): NodeStatus[];
     peers(): PeerInfo[];
+    /** Consolidated fleet view for the dashboard + `robopark fleet` (GET /fed/status). */
+    statusSnapshot(): FleetStatus;
     /** Latest local hardware snapshot (for the MOLTFED connector / panels). */
     latestHardware(): HardwareSnapshot | undefined;
     /** Subscribe to the merged mesh frame stream (local + peer frames). */

package/dist/kernel/federation/federation.js

@@ -1,4 +1,5 @@
 import { MeshServer, MeshClient } from './transport-http.js';
+import { DASHBOARD_HTML } from './dashboard-html.js';
 import { PeerMesh } from './peer-mesh.js';
 import { EventBridge } from './event-bridge.js';
 import { ConfigSync } from './config-sync.js';
@@ -12,6 +13,8 @@ import { discoverTailscalePeers } from './discovery.js';
 import { LanBeacon } from './lan-discovery.js';
 import { DEFAULT_MESH_PORT } from './types.js';
 import { createDefaultBackendRegistry } from '../agents/index.js';
+import { RotationState, selectChain } from '../agents/backends/rotation.js';
+import { loadCoderConfig } from '../agents/backends/profiles.js';
 export class Federation {
     deps;
     server;
@@ -33,6 +36,10 @@ export class Federation {
     compute = new ComputeRouter();
     /** Executors available on this node (native kernel + installed CLIs). */
     backends;
+    /** Resolved coder profiles + rotation policy for this node. */
+    coderConfig;
+    /** Per-node round-robin cursor for backend rotation. */
+    rotationState = new RotationState();
     /** Local subscribers to the merged mesh frame stream (for MCP stream_activity). */
     frameSubs = new Set();
     /** Recent frames for catch-up. */
@@ -45,6 +52,7 @@ export class Federation {
         this.deps = deps;
         this.client = new MeshClient({ token: deps.options.token });
         this.backends = deps.backends ?? createDefaultBackendRegistry();
+        this.coderConfig = loadCoderConfig(deps.options.coder);
         this.configSync = new ConfigSync({ logger: deps.logger, apply: deps.options.applyConfig });
         this.autoUpdate = new AutoUpdate({
             version: deps.options.version,
@@ -65,7 +73,11 @@ export class Federation {
             logger,
             getManifest: () => buildManifest(identity, this.describeWithBackends()),
             getNodes: () => this.nodeStatuses(),
+            getStatus: () => this.statusSnapshot(),
             runCommand: (input) => this.deps.kernel.command(input),
+            commandGate: options.commandGate,
+            onApply: options.onApply,
+            dashboardHtml: options.dashboard ? DASHBOARD_HTML : undefined,
             onRpc: (env, remote) => this.onRpc(env, remote),
         });
         await this.server.start();
@@ -81,9 +93,15 @@ export class Federation {
         });
         this.mesh.start();
         // Bridge local kernel events → mesh stream (coalesced, animation-friendly).
+        // Also record into frameHistory so this node's own activity shows up in the
+        // /fed/status snapshot the dashboard + `robopark fleet` poll — not just in
+        // the live SSE push to connected harnesses.
         this.bridge = new EventBridge({
             nodeId: identity.nodeId,
-            emit: f => this.server?.broadcast(f),
+            emit: f => {
+                this.server?.broadcast(f);
+                this.ingestFrame(identity.nodeId, f);
+            },
         });
         this.unsub = this.deps.kernel.subscribeAll(e => this.bridge?.handle(e));
         // Telemetry heartbeat → stream a HardwareSnapshot on a fixed cadence.
@@ -234,11 +252,17 @@ export class Federation {
         if (!rec)
             return;
         const nodeId = this.deps.identity.nodeId;
-        const backendId = task.agent && task.agent !== 'kernel' ? task.agent : null;
-        rec.agent = backendId ?? 'kernel';
+        // Rotation is requested when a profile/strategy/route/policy is given, or the
+        // caller asks for 'auto'. Otherwise a concrete agent is a single fixed backend.
+        const wantsRotation = !!(task.profile || task.strategy || task.taskType || task.policy || task.agent === 'auto');
+        const backendId = task.agent && task.agent !== 'kernel' && task.agent !== 'auto' ? task.agent : null;
+        rec.agent = wantsRotation ? 'rotate' : (backendId ?? 'kernel');
         this.server?.broadcast(frame('ev', nodeId, { k: 'RUN_STARTED', run: runId, desc: task.description, agent: rec.agent }));
         try {
-            if (backendId) {
+            if (wantsRotation) {
+                await this.runViaBackendChain(runId, task, rec);
+            }
+            else if (backendId) {
                 await this.runViaBackend(runId, backendId, task, rec);
             }
             else {
@@ -263,31 +287,82 @@ export class Federation {
      * is captured on the RunRecord so the run can be followed and later messaged.
      */
     async runViaBackend(runId, backendId, task, rec) {
+        const res = await this.runBackendOnce(runId, backendId, task, task.model);
+        this.writeResult(rec, runId, backendId, res);
+    }
+    /** Stream one backend's frames up the mesh, tagged with the backend id. */
+    backendFrameSink(runId, backendId) {
+        const nodeId = this.deps.identity.nodeId;
+        return (f) => {
+            if (f.kind === 'log' && f.text) {
+                this.server?.broadcast(frame('log', nodeId, { run: runId, agent: backendId, line: f.text }));
+            }
+            else {
+                this.server?.broadcast(frame('ev', nodeId, { k: 'AGENT_OUTPUT', run: runId, agent: backendId, kind: f.kind, text: f.text }));
+            }
+        };
+    }
+    /** Run a single backend attempt. Never throws — a missing/unavailable backend
+     *  returns a failed result so a rotation chain can fall through to the next. */
+    async runBackendOnce(runId, backendId, task, model, args) {
         const backend = this.backends.get(backendId);
         if (!backend || !backend.available()) {
-            throw new Error(`backend not available on this node: ${backendId}`);
+            return { status: 'failed', error: `backend not available on this node: ${backendId}` };
         }
-        const nodeId = this.deps.identity.nodeId;
-        const localRole = loadRole();
-        const preamble = rolePreamble(localRole);
-        const res = await backend.run({ prompt: task.prompt, capabilities: task.capabilities, model: task.model, sessionId: task.sessionId }, {
-            runId,
-            rolePreamble: preamble,
-            onFrame: f => {
-                if (f.kind === 'log' && f.text) {
-                    this.server?.broadcast(frame('log', nodeId, { run: runId, agent: backendId, line: f.text }));
-                }
-                else {
-                    this.server?.broadcast(frame('ev', nodeId, { k: 'AGENT_OUTPUT', run: runId, agent: backendId, kind: f.kind, text: f.text }));
-                }
-            },
-        });
+        const preamble = rolePreamble(loadRole());
+        try {
+            return await backend.run({ prompt: task.prompt, capabilities: task.capabilities, model: model ?? task.model, args, sessionId: task.sessionId }, { runId, rolePreamble: preamble, onFrame: this.backendFrameSink(runId, backendId) });
+        }
+        catch (err) {
+            return { status: 'failed', error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    /** Write a backend result onto the run record. */
+    writeResult(rec, runId, backendId, res) {
+        rec.agent = backendId;
         rec.status = res.status;
         rec.sessionId = res.sessionId;
         rec.missionId = res.sessionId ?? runId;
         rec.outputs = [{ status: res.status, content: res.content, error: res.error }];
-        if (res.status === 'failed' && res.error)
-            rec.error = res.error;
+        rec.error = res.status === 'failed' ? res.error : undefined;
+    }
+    /**
+     * Resolve a rotation chain for the task and run it with fallback: try each
+     * profile's backend in order, streaming its activity; the first `completed`
+     * wins, otherwise fall through to the next. Composes task-type routing, policy
+     * tiers, round-robin and fallback (see agents/backends/rotation.ts).
+     */
+    async runViaBackendChain(runId, task, rec) {
+        const nodeId = this.deps.identity.nodeId;
+        const req = {
+            strategy: task.strategy,
+            profile: task.profile,
+            model: task.model,
+            taskType: task.taskType,
+            policy: task.policy,
+            backend: task.agent && task.agent !== 'auto' && task.agent !== 'kernel' ? task.agent : undefined,
+        };
+        const chain = selectChain(this.coderConfig, req, this.rotationState);
+        let last = { status: 'failed', error: 'no backend available in rotation chain' };
+        for (let i = 0; i < chain.length; i++) {
+            const step = chain[i];
+            this.server?.broadcast(frame('ev', nodeId, {
+                k: 'ROTATION_ATTEMPT', run: runId, agent: step.backend, model: step.model,
+                profile: step.profileName, attempt: i + 1, of: chain.length,
+            }));
+            last = await this.runBackendOnce(runId, step.backend, task, step.model, step.args);
+            if (last.status === 'completed') {
+                this.writeResult(rec, runId, step.backend, last);
+                return;
+            }
+            if (i < chain.length - 1) {
+                this.server?.broadcast(frame('ev', nodeId, {
+                    k: 'ROTATION_FALLBACK', run: runId, from: step.backend,
+                    next: chain[i + 1].backend, reason: (last.error ?? '').slice(0, 200),
+                }));
+            }
+        }
+        this.writeResult(rec, runId, chain[chain.length - 1]?.backend ?? 'kernel', last);
     }
     // ── Outbound operations ──────────────────────────────────────────────────
     /**
@@ -585,13 +660,26 @@ export class Federation {
             version: d.version,
             capabilities: d.capabilities,
             commands: d.commands,
-        });
+        }, loadRole()?.site);
         const peers = (this.mesh?.list() ?? []).map(nodeStatusFromPeer);
         return [self, ...peers];
     }
     peers() {
         return this.mesh?.list() ?? [];
     }
+    /** Consolidated fleet view for the dashboard + `robopark fleet` (GET /fed/status). */
+    statusSnapshot() {
+        return {
+            self: buildManifest(this.deps.identity, this.describeWithBackends()),
+            role: this.getRole(),
+            nodes: this.nodeStatuses(),
+            hardware: this.lastHw,
+            runs: this.localRuns(),
+            agents: this.localAgents(),
+            activity: this.recentFrames(60),
+            ts: Date.now(),
+        };
+    }
     /** Latest local hardware snapshot (for the MOLTFED connector / panels). */
     latestHardware() {
         return this.lastHw;

package/dist/kernel/federation/moltfed-adapter.js

@@ -17,6 +17,7 @@ export function toNodesStatus(statuses) {
             // extra infinicode fields are ignored by InfiniBot but useful to richer UIs
             role: s.role,
             load: s.load,
+            site: s.site,
         })),
     };
 }

package/dist/kernel/federation/telemetry.d.ts

@@ -18,4 +18,4 @@ export declare function selfNodeStatus(identity: NodeIdentity, hw: HardwareSnaps
     version: string;
     capabilities: NodeStatus['capabilities'];
     commands: string[];
-}): NodeStatus;
+}, site?: string): NodeStatus;

package/dist/kernel/federation/telemetry.js

@@ -120,7 +120,7 @@ export function nodeStatusFromPeer(peer) {
     };
 }
 /** Local node's own status entry. */
-export function selfNodeStatus(identity, hw, manifest) {
+export function selfNodeStatus(identity, hw, manifest, site) {
     return {
         nodeId: identity.nodeId,
         displayName: identity.displayName,
@@ -134,5 +134,6 @@ export function selfNodeStatus(identity, hw, manifest) {
         connectedAtMs: Date.now(),
         load: loadFromSnapshot(hw),
         lastSeenAt: Date.now(),
+        site,
     };
 }

package/dist/kernel/federation/transport-http.d.ts

@@ -9,9 +9,22 @@ export interface MeshServerOptions {
     getManifest: () => NodeManifest;
     /** Optional: full mesh view (self + peers) for the GET /fed/nodes probe. */
     getNodes?: () => unknown;
+    /** Optional: consolidated fleet snapshot (self + nodes + hardware + roles +
+     *  runs + recent activity) for the dashboard and `robopark fleet` (GET /fed/status). */
+    getStatus?: () => unknown;
     /** Optional: run a kernel slash-command on this node (POST /fed/command).
-     *  Powers the in-TUI mesh command palette. */
+     *  Powers the in-TUI mesh command palette + the dashboard's action buttons. */
     runCommand?: (input: string) => Promise<unknown>;
+    /** Optional gate on POST /fed/command inputs. Returns {ok:false,reason} to
+     *  reject — used to keep an unauthenticated, network-exposed node read-only. */
+    commandGate?: (input: string) => {
+        ok: boolean;
+        reason?: string;
+    };
+    /** Optional: publish this node's shared config to the fleet (POST /fed/apply). */
+    onApply?: () => Promise<unknown> | unknown;
+    /** Optional: static HTML for the control dashboard, served at GET / and /ui. */
+    dashboardHtml?: string;
     onRpc: RpcHandler;
     logger: Logger;
 }
@@ -25,6 +38,9 @@ export declare class MeshServer {
     start(): Promise<void>;
     /** Push a frame to every connected stream subscriber. */
     broadcast(frame: StreamFrame): void;
+    /** Token presented on a request — Bearer header (peers/CLI) OR ?token= query
+     *  (browsers, which can't set headers on navigation or EventSource). */
+    private presentedToken;
     private authOk;
     private handle;
     private openStream;

package/dist/kernel/federation/transport-http.js

@@ -14,7 +14,16 @@
  * MeshClient/MeshServer shape later for deep InfiniBot-fabric interop.
  */
 import { createServer } from 'node:http';
+import { timingSafeEqual } from 'node:crypto';
 import { frameToSSE, parseSSE } from './protocol.js';
+/** Constant-time string compare — avoids leaking the token via response timing. */
+function safeEqual(a, b) {
+    const ab = Buffer.from(a);
+    const bb = Buffer.from(b);
+    if (ab.length !== bb.length)
+        return false;
+    return timingSafeEqual(ab, bb);
+}
 export class MeshServer {
     opts;
     server;
@@ -51,19 +60,67 @@ export class MeshServer {
             }
         }
     }
+    /** Token presented on a request — Bearer header (peers/CLI) OR ?token= query
+     *  (browsers, which can't set headers on navigation or EventSource). */
+    presentedToken(req) {
+        const h = req.headers['authorization'];
+        if (typeof h === 'string' && h.startsWith('Bearer '))
+            return h.slice(7);
+        const url = req.url ?? '';
+        const q = url.indexOf('?');
+        if (q >= 0) {
+            const t = new URLSearchParams(url.slice(q + 1)).get('token');
+            if (t)
+                return t;
+        }
+        return undefined;
+    }
     authOk(req) {
         if (!this.opts.token)
             return true;
-        const h = req.headers['authorization'];
-        return typeof h === 'string' && h === `Bearer ${this.opts.token}`;
+        const presented = this.presentedToken(req);
+        return presented !== undefined && safeEqual(presented, this.opts.token);
     }
     handle(req, res) {
         const url = req.url ?? '/';
+        const path = url.split('?', 1)[0];
         if (!this.authOk(req)) {
             res.writeHead(401).end('unauthorized');
             return;
         }
         const remote = req.socket.remoteAddress ?? 'unknown';
+        // Control dashboard (single self-contained page). Same-origin fetches carry
+        // the ?token= through, so no CORS is opened.
+        if (req.method === 'GET' && (path === '/' || path === '/ui' || path === '/dashboard')) {
+            if (!this.opts.dashboardHtml) {
+                res.writeHead(404).end('dashboard not enabled (start with --dashboard)');
+                return;
+            }
+            res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
+            res.end(this.opts.dashboardHtml);
+            return;
+        }
+        if (req.method === 'GET' && path === '/fed/status') {
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(JSON.stringify(this.opts.getStatus?.() ?? {}));
+            return;
+        }
+        if (req.method === 'POST' && path.startsWith('/fed/apply')) {
+            if (!this.opts.onApply) {
+                res.writeHead(404).end('no apply handler');
+                return;
+            }
+            Promise.resolve(this.opts.onApply())
+                .then(result => {
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify(result ?? { ok: true }));
+            })
+                .catch(err => {
+                this.opts.logger.warn(`[federation] apply error: ${err instanceof Error ? err.message : String(err)}`);
+                res.writeHead(500).end('apply failed');
+            });
+            return;
+        }
         if (req.method === 'GET' && url.startsWith('/fed/manifest')) {
             res.writeHead(200, { 'content-type': 'application/json' });
             res.end(JSON.stringify(this.opts.getManifest()));
@@ -93,6 +150,12 @@ export class MeshServer {
                     res.writeHead(400).end('bad json');
                     return;
                 }
+                const gate = this.opts.commandGate?.(input);
+                if (gate && !gate.ok) {
+                    res.writeHead(403, { 'content-type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, text: gate.reason ?? 'command not permitted on this node' }));
+                    return;
+                }
                 const result = await this.opts.runCommand(input);
                 res.writeHead(200, { 'content-type': 'application/json' });
                 res.end(JSON.stringify(result ?? { ok: false, text: 'no result' }));

package/dist/kernel/federation/types.d.ts

@@ -125,6 +125,10 @@ export interface NodeStatus {
     /** 0–100 rough load, from the latest hardware snapshot. */
     load?: number;
     lastSeenAt: number;
+    /** Physical deployment this node belongs to (e.g. "Tel Aviv"). Sourced from
+     *  this node's own RoleContext.site — lets a fleet UI group by location as
+     *  a customer scales from one site to many, without per-site bespoke code. */
+    site?: string;
 }
 export type MessageKind = 'hello' | 'welcome' | 'heartbeat' | 'manifest' | 'task.dispatch' | 'task.accepted' | 'task.status' | 'task.result' | 'task.cancel' | 'command' | 'command.result' | 'config.request' | 'config.offer' | 'update.announce' | 'update.request' | 'role.get' | 'role.set' | 'agents.list' | 'agents.offer' | 'message.send' | 'message.accepted' | 'event' | 'telemetry' | 'ack' | 'error';
 /** A dispatched/received task run — tracked for non-blocking handoff + monitoring. */
@@ -167,10 +171,26 @@ export interface AgentHandle {
     description: string;
     lastActiveAt: number;
 }
+/** Result of a one-shot `infinicode maintain` run, pushed to an InfiniBot gateway. */
+export interface MaintenanceReport {
+    nodeId: string;
+    role: string;
+    site?: string;
+    taskName: string;
+    startedAt: number;
+    finishedAt: number;
+    durationMs: number;
+    ok: boolean;
+    summary: string;
+    errors?: string[];
+}
 /** Persistent per-device role + server-architecture context. */
 export interface RoleContext {
     /** e.g. "RoboPanda" — the identity a spawned agent adopts. */
     role: string;
+    /** Physical deployment/location this device belongs to (e.g. "Tel Aviv").
+     *  Optional — a single-site deployment can leave it unset. */
+    site?: string;
     /** Free-text description of this device's job + the wider architecture. */
     architecture?: string;
     /** Extra structured context injected into every task run on this node. */

package/dist/kernel/mcp/mcp-server.js

@@ -37,28 +37,43 @@ export function createMcpServer(deps) {
     // ── Spawn + dispatch (parallel agents across devices, no SSH) ───────────────
     server.registerTool('spawn_agent', {
         title: 'Spawn agent on a device',
-        description: 'Hand a task to a device\'s local agent (by name or id). Non-blocking: returns a runId immediately — use follow_task to monitor. Pass wait:true to block until done (short tasks). Runs on the target with its persistent role. Set agent to run it with a third-party CLI on the target ("claude" | "codex" | "opencode") instead of the native kernel.',
+        description: 'Hand a task to a device\'s local agent (by name or id). Non-blocking: returns a runId immediately — use follow_task to monitor. Pass wait:true to block until done (short tasks). Runs on the target with its persistent role.\n\nExecutor: set `agent` to a fixed CLI ("claude" | "codex" | "opencode" | "gemini") or "kernel" (native). For automatic backend rotation instead of a fixed one, set `agent:"auto"` (or any of profile/strategy/policy/taskType) — the target then resolves a coder-profile *chain* and runs it with fallback (first backend that succeeds wins). Use `profile` to pin a named profile, `taskType` to route by kind (e.g. "refactor","docs","bulk"), `policy` to order by tier ("free-first"|"cheapest"|"fastest"|"highest-quality"|"balanced"), `strategy` to force one mode, and `model` to override the head model.',
         inputSchema: {
             task: z.string().describe('what the agent should do'),
             device: z.string().optional().describe('target device name or node id'),
             capabilities: z.array(z.string()).optional().describe('required capabilities, e.g. ["coding"]'),
-            agent: z.string().optional().describe('executor on the target: "kernel" (default), "claude", "codex", or "opencode"'),
+            agent: z.string().optional().describe('executor: "kernel" (default), "claude" | "codex" | "opencode" | "gemini", or "auto" to rotate across coder profiles'),
+            profile: z.string().optional().describe('pin a named coder profile (e.g. "deep","fast","precise","cheap","oss")'),
+            strategy: z.enum(['auto', 'tasktype', 'policy', 'roundrobin', 'fallback']).optional().describe('rotation strategy (default from config: auto)'),
+            policy: z.enum(['free-first', 'cheapest', 'fastest', 'highest-quality', 'balanced']).optional().describe('policy tier ordering when rotating'),
+            taskType: z.string().optional().describe('route by task kind: refactor|architecture|debug|feature|edit|test|docs|bulk|boilerplate|fix'),
+            model: z.string().optional().describe('model override applied to the chosen backend'),
             role: z.string().optional().describe('override the role context for this task'),
             wait: z.boolean().optional().describe('block until the run finishes (default false)'),
         },
-    }, async ({ task, device, capabilities, agent, role, wait }) => {
-        const caps = [...(capabilities ?? []), ...(agent && agent !== 'kernel' ? [`backend:${agent}`] : [])];
+    }, async ({ task, device, capabilities, agent, profile, strategy, policy, taskType, model, role, wait }) => {
+        const rotate = !!(profile || strategy || policy || taskType || agent === 'auto');
+        const caps = [
+            ...(capabilities ?? []),
+            ...(agent && agent !== 'kernel' && agent !== 'auto' ? [`backend:${agent}`] : []),
+            ...(rotate ? ['coding'] : []),
+        ];
         const t = {
             description: task.slice(0, 80),
             prompt: task,
             capabilities: caps,
             agent,
             role,
+            model,
+            profile,
+            strategy,
+            policy,
+            taskType,
         };
         const res = await federation.dispatch(t, { preferName: device, preferNodeId: device }, { wait });
         if (!res)
             return text({ ok: false, error: 'no capable device online for this task' });
-        return text({ ok: true, peerId: res.peerId, runId: res.runId, agent: agent ?? 'kernel', status: res.record.status, record: res.record });
+        return text({ ok: true, peerId: res.peerId, runId: res.runId, agent: rotate ? 'rotate' : (agent ?? 'kernel'), status: res.record.status, record: res.record });
     });
     server.registerTool('dispatch', {
         title: 'Dispatch to best device',
@@ -142,11 +157,12 @@ export function createMcpServer(deps) {
         description: 'Persist a device\'s role + architecture so spawned agents are proactive and context-aware.',
         inputSchema: {
             role: z.string().describe('e.g. "RoboPanda"'),
+            site: z.string().optional().describe('physical deployment/location, e.g. "Tel Aviv" — lets a fleet UI group by site as you add more locations'),
             architecture: z.string().optional().describe('this device\'s job + the wider system'),
             nodeId: z.string().optional().describe('target node; omit for local'),
         },
-    }, async ({ role, architecture, nodeId }) => {
-        const payload = { role, architecture };
+    }, async ({ role, site, architecture, nodeId }) => {
+        const payload = { role, site, architecture };
         return text(nodeId ? await federation.setRoleOf(nodeId, payload) : federation.setRole(payload));
     });
     // ── Voice (LiveKit intent — media plane handles TTS) ────────────────────────

package/dist/robopark-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/robopark-cli.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * `robopark` — standalone entry for the RoboPark fleet control CLI.
+ *
+ * Same verbs as `infinicode robopark …`, exposed as a top-level `robopark`
+ * command so operators type `robopark fleet` / `robopark setup` directly.
+ */
+import { Command } from 'commander';
+import Conf from 'conf';
+import { attachRoboparkSubcommands } from './commands/robopark.js';
+import { DEFAULT_CONFIG } from './kernel/config-schema.js';
+const VERSION = '2.4.0';
+const config = new Conf({
+    projectName: 'infinicode', // share infinicode's config store (providers, federation)
+    defaults: DEFAULT_CONFIG,
+});
+const program = new Command();
+program
+    .name('robopark')
+    .description('RoboPark fleet control — setup, fleet status, run, apply, dashboard (rides the infinicode mesh)')
+    .version(VERSION);
+attachRoboparkSubcommands(program, config);
+program.parse();

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "infinicode",
-  "version": "2.3.6",
+  "version": "2.4.0",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",
   "types": "./dist/kernel/index.d.ts",
   "bin": {
     "infinicode": "./bin/infinicode.js",
-    "ic": "./bin/infinicode.js"
+    "ic": "./bin/infinicode.js",
+    "robopark": "./bin/robopark.js"
   },
   "exports": {
     ".": {
@@ -17,10 +18,12 @@
     "./kernel": {
       "types": "./dist/kernel/index.d.ts",
       "import": "./dist/kernel/index.js"
-    }
+    },
+    "./robopark": "./dist/robopark-cli.js"
   },
   "files": [
     "bin/infinicode.js",
+    "bin/robopark.js",
     "dist",
     ".opencode/plugins",
     ".opencode/themes",