infinicode 1.0.0 → 2.1.0

package/dist/kernel/browser/browser-controller.js

@@ -0,0 +1,175 @@
+export class BrowserController {
+    playwright;
+    browser;
+    page;
+    mode = 'unavailable';
+    opts;
+    constructor(opts = {}) {
+        this.opts = { headless: true, browser: 'chromium', timeoutMs: 30_000, ...opts };
+    }
+    async init() {
+        try {
+            this.playwright = await import('playwright');
+            this.mode = 'playwright';
+        }
+        catch {
+            this.mode = 'fetch';
+        }
+    }
+    getMode() {
+        return this.mode;
+    }
+    async runAction(action) {
+        if (this.mode === 'playwright' && this.playwright) {
+            return this.runPlaywright(action);
+        }
+        return this.runFetch(action);
+    }
+    async close() {
+        try {
+            await this.page?.close();
+        }
+        catch { /* best-effort */ }
+        try {
+            await this.browser?.close();
+        }
+        catch { /* best-effort */ }
+        this.page = undefined;
+        this.browser = undefined;
+    }
+    async ensurePage() {
+        if (!this.playwright)
+            throw new Error('playwright not loaded');
+        if (!this.browser) {
+            const launch = this.opts.browser === 'firefox' ? this.playwright.firefox.launch
+                : this.opts.browser === 'webkit' ? this.playwright.webkit.launch
+                    : this.playwright.chromium.launch;
+            this.browser = await launch.call(this.playwright.chromium, { headless: this.opts.headless });
+        }
+        if (!this.page) {
+            const ctx = await this.browser.newContext();
+            this.page = await ctx.newPage();
+            this.page.setDefaultTimeout(this.opts.timeoutMs ?? 30_000);
+        }
+    }
+    async runPlaywright(action) {
+        await this.ensurePage();
+        const page = this.page;
+        try {
+            switch (action.type) {
+                case 'navigate': {
+                    if (!action.url)
+                        throw new Error('navigate requires url');
+                    await page.goto(action.url, { waitUntil: 'domcontentloaded' });
+                    return { ok: true, url: page.url(), title: await page.title() };
+                }
+                case 'click': {
+                    if (!action.selector)
+                        throw new Error('click requires selector');
+                    await page.click(action.selector);
+                    return { ok: true, url: page.url() };
+                }
+                case 'type': {
+                    if (!action.selector || action.text === undefined)
+                        throw new Error('type requires selector+text');
+                    await page.fill(action.selector, action.text);
+                    return { ok: true };
+                }
+                case 'extract': {
+                    const text = await page.innerText('body');
+                    return { ok: true, url: page.url(), title: await page.title(), text, markdown: htmlToMarkdown(await page.content()) };
+                }
+                case 'screenshot': {
+                    const path = `${this.opts.screenshotDir ?? './.openkernel/screenshots'}/shot-${Date.now()}.png`;
+                    await page.screenshot({ path, fullPage: true });
+                    return { ok: true, screenshotPath: path };
+                }
+                case 'evaluate': {
+                    if (!action.script)
+                        throw new Error('evaluate requires script');
+                    const result = await page.evaluate(action.script);
+                    return { ok: true, text: typeof result === 'string' ? result : JSON.stringify(result) };
+                }
+                case 'wait': {
+                    if (action.selector) {
+                        await page.waitForSelector(action.selector, { timeout: action.ms ?? this.opts.timeoutMs });
+                    }
+                    else {
+                        await page.waitForTimeout(action.ms ?? 1000);
+                    }
+                    return { ok: true };
+                }
+                case 'scroll': {
+                    await page.evaluate((y) => globalThis.scrollBy?.(0, y ?? 800), action.ms);
+                    return { ok: true };
+                }
+                default:
+                    return { ok: false, error: `unknown action: ${action.type}` };
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { ok: false, error: message };
+        }
+    }
+    async runFetch(action) {
+        if (action.type === 'navigate' && action.url) {
+            try {
+                const response = await fetch(action.url, {
+                    signal: AbortSignal.timeout(this.opts.timeoutMs ?? 30_000),
+                    headers: { 'User-Agent': 'OpenKernel-Browser/1.0' },
+                });
+                if (!response.ok)
+                    return { ok: false, url: action.url, error: `HTTP ${response.status}` };
+                const html = await response.text();
+                return {
+                    ok: true,
+                    url: action.url,
+                    title: extractTitle(html),
+                    text: stripHtml(html),
+                    html,
+                    markdown: htmlToMarkdown(html),
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { ok: false, error: message };
+            }
+        }
+        return { ok: false, error: `fetch mode does not support action: ${action.type}` };
+    }
+}
+export function htmlToMarkdown(html) {
+    return stripHtml(html)
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+export function stripHtml(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[\s\S]*?<\/style>/gi, '')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+export function extractTitle(html) {
+    const match = html.match(/<title[^>]*>([^<]*)<\/title>/i);
+    return match ? match[1].trim() : '';
+}
+export function actionArtifacts(results) {
+    return results
+        .filter(r => r.text || r.screenshotPath)
+        .map((r, i) => ({
+        id: `browser-${i}`,
+        type: (r.screenshotPath ? 'image' : 'document'),
+        content: r.text ?? r.markdown,
+        path: r.screenshotPath,
+        mimeType: r.screenshotPath ? 'image/png' : 'text/markdown',
+    }));
+}

package/dist/kernel/checkpoint-engine.d.ts

@@ -0,0 +1,17 @@
+import type { Checkpoint, Mission, WorkerInstanceState } from './types.js';
+import type { EventBus } from './event-bus.js';
+import type { Logger } from './types.js';
+export declare class CheckpointEngine {
+    private eventBus;
+    private logger;
+    private dir;
+    private maxPerMission;
+    constructor(eventBus: EventBus, logger: Logger, storageDir?: string);
+    setMaxPerMission(n: number): void;
+    save(mission: Mission, workerStates: WorkerInstanceState[], reason: Checkpoint['reason']): Promise<Checkpoint>;
+    private pruneMission;
+    load(missionId: string, checkpointId: string): Checkpoint | undefined;
+    latest(missionId: string): Checkpoint | undefined;
+    list(missionId: string): Checkpoint[];
+    purge(missionId: string): number;
+}

package/dist/kernel/checkpoint-engine.js

@@ -0,0 +1,128 @@
+/**
+ * OpenKernel — Checkpoint Engine
+ *
+ * Stores: mission, objectives, current task, completed tasks, worker state,
+ * provider, memory, logs, artifacts.
+ * Supports: pause, resume, crash recovery, migration, long-running missions.
+ */
+import { nanoid } from 'nanoid';
+import { mkdirSync, existsSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+export class CheckpointEngine {
+    eventBus;
+    logger;
+    dir;
+    maxPerMission = 20;
+    constructor(eventBus, logger, storageDir) {
+        this.eventBus = eventBus;
+        this.logger = logger;
+        this.dir = resolve(storageDir ?? join(process.cwd(), '.openkernel', 'checkpoints'));
+        if (!existsSync(this.dir)) {
+            mkdirSync(this.dir, { recursive: true });
+        }
+    }
+    setMaxPerMission(n) {
+        this.maxPerMission = n;
+    }
+    async save(mission, workerStates, reason) {
+        // cap per-mission checkpoint files to prevent disk exhaustion
+        this.pruneMission(mission.id);
+        const id = nanoid(12);
+        const checkpoint = {
+            id,
+            missionId: mission.id,
+            mission: structuredClone(mission),
+            workerStates,
+            timestamp: Date.now(),
+            reason,
+        };
+        const file = join(this.dir, `${mission.id}_${id}.json`);
+        writeFileSync(file, JSON.stringify(checkpoint, null, 2), 'utf-8');
+        mission.checkpoints.push(id);
+        this.eventBus.emit({
+            type: 'CHECKPOINT',
+            timestamp: Date.now(),
+            missionId: mission.id,
+            data: { checkpointId: id, reason, file },
+        });
+        this.logger.info(`Checkpoint saved: ${id} (reason: ${reason})`);
+        return checkpoint;
+    }
+    pruneMission(missionId) {
+        if (!existsSync(this.dir))
+            return;
+        const prefix = `${missionId}_`;
+        const files = readdirSync(this.dir)
+            .filter(f => f.startsWith(prefix) && f.endsWith('.json'))
+            .sort();
+        while (files.length >= this.maxPerMission) {
+            const oldest = files.shift();
+            if (!oldest)
+                break;
+            try {
+                unlinkSync(join(this.dir, oldest));
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    load(missionId, checkpointId) {
+        const file = join(this.dir, `${missionId}_${checkpointId}.json`);
+        if (!existsSync(file))
+            return undefined;
+        try {
+            const raw = readFileSync(file, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            this.logger.warn(`Failed to load checkpoint ${checkpointId}: ${err}`);
+            return undefined;
+        }
+    }
+    latest(missionId) {
+        if (!existsSync(this.dir))
+            return undefined;
+        const prefix = `${missionId}_`;
+        const files = readdirSync(this.dir)
+            .filter(f => f.startsWith(prefix) && f.endsWith('.json'))
+            .sort();
+        if (files.length === 0)
+            return undefined;
+        const latestFile = files[files.length - 1];
+        try {
+            const raw = readFileSync(join(this.dir, latestFile), 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    list(missionId) {
+        if (!existsSync(this.dir))
+            return [];
+        const prefix = `${missionId}_`;
+        const files = readdirSync(this.dir)
+            .filter(f => f.startsWith(prefix) && f.endsWith('.json'))
+            .sort();
+        const checkpoints = [];
+        for (const file of files) {
+            try {
+                const raw = readFileSync(join(this.dir, file), 'utf-8');
+                checkpoints.push(JSON.parse(raw));
+            }
+            catch {
+                // skip corrupt
+            }
+        }
+        return checkpoints;
+    }
+    purge(missionId) {
+        if (!existsSync(this.dir))
+            return 0;
+        const prefix = `${missionId}_`;
+        const files = readdirSync(this.dir).filter(f => f.startsWith(prefix));
+        for (const f of files) {
+            unlinkSync(join(this.dir, f));
+        }
+        return files.length;
+    }
+}

package/dist/kernel/command-system.d.ts

@@ -0,0 +1,37 @@
+/**
+ * OpenKernel — Command System
+ *
+ * The canonical OpenKernel slash-command surface from the spec:
+ *   /status /workers /logs /pause /resume /retry /models /providers
+ *   /checkpoints /goal   (+ /missions /cancel /help)
+ *
+ * One registry, reused everywhere: the CLI console REPL and notification
+ * plugins (Telegram/Discord/Slack) all dispatch through `kernel.command(...)`,
+ * so behavior is defined once. Each command returns a renderable `CommandResult`
+ * (text) so any surface can display it.
+ */
+import type { Kernel } from './kernel.js';
+import type { CommandResult } from './types.js';
+export interface CommandContext {
+    kernel: Kernel;
+    args: string[];
+    raw: string;
+}
+export interface KernelCommand {
+    name: string;
+    aliases?: string[];
+    description: string;
+    usage?: string;
+    run(ctx: CommandContext): Promise<CommandResult> | CommandResult;
+}
+export declare const DEFAULT_COMMANDS: KernelCommand[];
+export declare class KernelCommandRegistry {
+    private kernel;
+    private commands;
+    private aliases;
+    constructor(kernel: Kernel);
+    register(cmd: KernelCommand): void;
+    list(): KernelCommand[];
+    resolve(name: string): KernelCommand | undefined;
+    execute(input: string): Promise<CommandResult>;
+}

package/dist/kernel/command-system.js

@@ -0,0 +1,239 @@
+const ok = (text, data) => ({ ok: true, text, data });
+const err = (text) => ({ ok: false, text });
+/** Resolve a mission by id, "latest", or an optional status filter. */
+function pickMission(kernel, arg, status) {
+    const missions = kernel.listMissions();
+    if (arg && arg !== 'latest')
+        return kernel.getMission(arg);
+    const pool = status ? missions.filter(m => m.status === status) : missions;
+    return pool[pool.length - 1];
+}
+export const DEFAULT_COMMANDS = [
+    {
+        name: 'help',
+        aliases: ['?', 'commands'],
+        description: 'List available commands',
+        run({ kernel }) {
+            const lines = kernel.commands.list().map(c => {
+                const alias = c.aliases?.length ? ` (/${c.aliases.join(', /')})` : '';
+                return `  /${c.name}${alias} — ${c.description}${c.usage ? `  [${c.usage}]` : ''}`;
+            });
+            return ok(`OpenKernel commands:\n${lines.join('\n')}`);
+        },
+    },
+    {
+        name: 'status',
+        description: 'Overall kernel status: providers, workers, missions',
+        run({ kernel }) {
+            const infos = kernel.providerManager.listInfos();
+            const healthy = infos.filter(p => p.healthy).length;
+            const active = kernel.workerRuntime.getActive().length;
+            const missions = kernel.listMissions();
+            const recent = missions.slice(-5).map(m => `  ${m.id} ${m.status} — ${m.name} (${m.tasks.filter(t => t.status === 'COMPLETED').length}/${m.tasks.length})`);
+            const head = `Providers ${healthy}/${infos.length} healthy · Workers active ${active} · Missions ${missions.length}`;
+            return ok(recent.length ? `${head}\n${recent.join('\n')}` : head);
+        },
+    },
+    {
+        name: 'providers',
+        aliases: ['p'],
+        description: 'Provider health, latency, and per-request token limits',
+        run({ kernel }) {
+            const infos = kernel.providerManager.listInfos();
+            if (!infos.length)
+                return ok('No providers registered.');
+            const lines = infos.map(p => {
+                const tpm = p.maxRequestTokens ? `tpm=${p.maxRequestTokens}` : '';
+                const e = p.error ? ` err=${p.error.replace(/\s+/g, ' ').slice(0, 60)}` : '';
+                return `${p.healthy ? '●' : '○'} ${p.id.padEnd(10)} lat=${p.latencyMs ?? '?'}ms ${tpm}${e}`;
+            });
+            return ok(lines.join('\n'));
+        },
+    },
+    {
+        name: 'models',
+        aliases: ['m'],
+        description: 'Available models across providers (optional filter)',
+        usage: '/models [filter]',
+        async run({ kernel, args }) {
+            const filter = args.join(' ').toLowerCase();
+            const models = await kernel.providerManager.getAvailableModels();
+            const filtered = filter ? models.filter(m => `${m.providerId}/${m.id}`.toLowerCase().includes(filter)) : models;
+            if (!filtered.length)
+                return ok(filter ? `No models match "${filter}".` : 'No models available.');
+            const byProv = {};
+            for (const m of filtered)
+                (byProv[m.providerId] ??= []).push(m.id);
+            const lines = Object.entries(byProv).map(([p, ids]) => `${p} (${ids.length}): ${ids.slice(0, 12).join(', ')}${ids.length > 12 ? ' …' : ''}`);
+            return ok(`${filtered.length} model(s)\n${lines.join('\n')}`);
+        },
+    },
+    {
+        name: 'workers',
+        aliases: ['w'],
+        description: 'Registered worker types and active worker instances',
+        run({ kernel }) {
+            const defs = kernel.workerRuntime.listRegisteredDefinitions();
+            const active = kernel.workerRuntime.getActive();
+            const activeStr = active.map(w => `${w.type}:${w.status}`).join(', ') || 'none';
+            return ok(`Registered (${defs.length}): ${defs.map(d => d.type).join(', ')}\nActive (${active.length}): ${activeStr}`);
+        },
+    },
+    {
+        name: 'logs',
+        aliases: ['log'],
+        description: 'Recent event-bus activity',
+        usage: '/logs [count]',
+        run({ kernel, args }) {
+            const n = Math.max(1, Math.min(100, parseInt(args[0] ?? '15', 10) || 15));
+            const hist = kernel.getEventHistory().slice(-n);
+            if (!hist.length)
+                return ok('No events yet.');
+            const lines = hist.map(e => {
+                const t = new Date(e.timestamp).toISOString().slice(11, 19);
+                return `${t} ${e.type}${e.missionId ? ' ' + e.missionId : ''}${e.taskId ? '/' + e.taskId : ''}`;
+            });
+            return ok(lines.join('\n'));
+        },
+    },
+    {
+        name: 'missions',
+        aliases: ['ls'],
+        description: 'List missions in this session',
+        run({ kernel }) {
+            const missions = kernel.listMissions();
+            if (!missions.length)
+                return ok('No missions this session.');
+            return ok(missions.map(m => `${m.id} ${m.status} — ${m.name} (${m.tasks.length} tasks)`).join('\n'));
+        },
+    },
+    {
+        name: 'checkpoints',
+        aliases: ['ckpt'],
+        description: 'Checkpoints per mission',
+        usage: '/checkpoints [missionId]',
+        run({ kernel, args }) {
+            const missions = args[0] ? [kernel.getMission(args[0])].filter(Boolean) : kernel.listMissions();
+            if (!missions.length)
+                return ok('No missions.');
+            return ok(missions.map(m => `${m.id}: ${m.checkpoints.length} checkpoint(s)`).join('\n'));
+        },
+    },
+    {
+        name: 'pause',
+        description: 'Pause a running mission',
+        usage: '/pause [missionId|latest]',
+        async run({ kernel, args }) {
+            const m = pickMission(kernel, args[0], 'RUNNING');
+            if (!m)
+                return err('No running mission to pause.');
+            await kernel.pause(m.id);
+            return ok(`Paused ${m.id}.`);
+        },
+    },
+    {
+        name: 'resume',
+        description: 'Resume a paused mission',
+        usage: '/resume [missionId|latest]',
+        async run({ kernel, args }) {
+            const m = pickMission(kernel, args[0], 'PAUSED');
+            if (!m)
+                return err('No paused mission to resume.');
+            const resumed = await kernel.resume(m.id);
+            return ok(`Resumed ${m.id} — now ${resumed.status}.`);
+        },
+    },
+    {
+        name: 'cancel',
+        description: 'Cancel a mission',
+        usage: '/cancel <missionId|latest>',
+        async run({ kernel, args }) {
+            const m = pickMission(kernel, args[0]);
+            if (!m)
+                return err('No mission to cancel.');
+            await kernel.cancel(m.id);
+            return ok(`Cancelled ${m.id}.`);
+        },
+    },
+    {
+        name: 'retry',
+        description: 'Re-run a mission\'s failed/skipped tasks',
+        usage: '/retry [missionId|latest]',
+        async run({ kernel, args }) {
+            const m = pickMission(kernel, args[0]);
+            if (!m)
+                return err('No mission to retry.');
+            const before = m.tasks.filter(t => t.status === 'FAILED' || t.status === 'SKIPPED').length;
+            if (before === 0)
+                return ok(`Mission ${m.id} has no failed tasks.`);
+            const result = await kernel.retry(m.id);
+            const done = result.tasks.filter(t => t.status === 'COMPLETED').length;
+            return ok(`Retried ${before} task(s) on ${m.id} — now ${result.status} (${done}/${result.tasks.length} complete).`);
+        },
+    },
+    {
+        name: 'goal',
+        aliases: ['g'],
+        description: 'Start and run a new mission from a goal',
+        usage: '/goal <text>',
+        async run({ kernel, args }) {
+            const goal = args.join(' ').trim();
+            if (!goal)
+                return err('Usage: /goal <text>');
+            const mission = await kernel.execute({
+                description: goal,
+                goal,
+                tasks: [{ description: goal, capabilities: ['reasoning', 'coding'], input: { prompt: goal } }],
+            });
+            const done = mission.tasks.filter(t => t.status === 'COMPLETED').length;
+            const preview = mission.tasks
+                .map(t => t.output?.content?.slice(0, 400))
+                .filter(Boolean)
+                .join('\n---\n');
+            return {
+                ok: mission.status === 'COMPLETED',
+                text: `Mission ${mission.id} ${mission.status} (${done}/${mission.tasks.length})${preview ? '\n' + preview : ''}`,
+                data: { missionId: mission.id },
+            };
+        },
+    },
+];
+export class KernelCommandRegistry {
+    kernel;
+    commands = new Map();
+    aliases = new Map();
+    constructor(kernel) {
+        this.kernel = kernel;
+        for (const cmd of DEFAULT_COMMANDS)
+            this.register(cmd);
+    }
+    register(cmd) {
+        this.commands.set(cmd.name, cmd);
+        for (const a of cmd.aliases ?? [])
+            this.aliases.set(a, cmd.name);
+    }
+    list() {
+        return [...this.commands.values()];
+    }
+    resolve(name) {
+        const key = name.toLowerCase();
+        return this.commands.get(key) ?? this.commands.get(this.aliases.get(key) ?? '');
+    }
+    async execute(input) {
+        const trimmed = (input ?? '').trim().replace(/^\//, '').trim();
+        if (!trimmed)
+            return this.resolve('help').run({ kernel: this.kernel, args: [], raw: input });
+        const parts = trimmed.split(/\s+/);
+        const name = parts[0];
+        const args = parts.slice(1);
+        const cmd = this.resolve(name);
+        if (!cmd)
+            return err(`Unknown command: /${name}. Try /help.`);
+        try {
+            return await cmd.run({ kernel: this.kernel, args, raw: input });
+        }
+        catch (e) {
+            return err(`/${name} failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+}

package/dist/kernel/config-schema.d.ts

@@ -0,0 +1,57 @@
+/**
+ * infinicode — Extended config schema for OpenKernel.
+ *
+ * Adds worker model pinning + cloud provider credentials on top of the
+ * original Ollama master config.
+ */
+import type { WorkerType } from '../kernel/types.js';
+export interface CloudProviderConfig {
+    id: string;
+    name: string;
+    baseURL: string;
+    apiKey?: string;
+    headerName?: string;
+    enabled: boolean;
+}
+export interface WorkerModelPref {
+    /** Provider+model pair, e.g. "ollama/qwen2.5-coder:14b" or "groq/llama-3.3-70b-versatile". */
+    providerId: string;
+    modelId: string;
+}
+/** Device-mesh / federation settings. */
+export interface FederationConfig {
+    /** Enable the mesh on `infinicode serve`. */
+    enabled?: boolean;
+    /** This node's role in the mesh. */
+    role?: 'hub' | 'peer' | 'satellite' | 'relay';
+    /** Friendly node name (defaults to hostname). */
+    displayName?: string;
+    /** Mesh listen port (default 47913). */
+    port?: number;
+    host?: string;
+    /** Shared bearer token peers must present (app-layer auth). */
+    token?: string;
+    /** Base URLs of peers to connect to on start. */
+    seeds?: string[];
+    /** Seconds between peer heartbeats (default 30). */
+    heartbeatSec?: number;
+    /** Accept + apply auto-updates announced by a hub/relay. */
+    autoUpdate?: boolean;
+    /** Zero-config LAN discovery: broadcast + auto-connect peers on this subnet. */
+    lan?: boolean;
+    /** UDP discovery port for LAN discovery (default 47915). */
+    lanPort?: number;
+}
+export interface InfinicodeConfig {
+    masterUrl: string;
+    tailscaleMasterUrl?: string;
+    defaultModel: string;
+    theme: string;
+    policy?: string;
+    workerModels?: Partial<Record<WorkerType, WorkerModelPref>>;
+    cloudProviders?: CloudProviderConfig[];
+    federation?: FederationConfig;
+}
+export declare const DEFAULT_CONFIG: InfinicodeConfig;
+export declare const WORKER_TYPES_ORDER: WorkerType[];
+export declare const WORKER_DESCRIPTIONS: Record<WorkerType, string>;

package/dist/kernel/config-schema.js

@@ -0,0 +1,36 @@
+export const DEFAULT_CONFIG = {
+    masterUrl: 'http://localhost:11434',
+    defaultModel: 'qwen2.5-coder:14b',
+    theme: 'infini',
+    // Auto-routes across all providers by capability + benchmark. Use 'offline'
+    // to lock to local, or 'quality'/'fastest'/'free-first' to bias the router.
+    policy: 'balanced',
+    workerModels: {},
+    cloudProviders: [],
+};
+export const WORKER_TYPES_ORDER = [
+    'coding',
+    'frontend',
+    'research',
+    'architecture',
+    'review',
+    'documentation',
+    'translation',
+    'terminal',
+    'verification',
+    'vision',
+    'browser',
+];
+export const WORKER_DESCRIPTIONS = {
+    coding: 'Writes code — functions, implementations, fixes',
+    frontend: 'Builds production-grade UI (HTML/CSS/vanilla JS) — design systems, components, animation',
+    research: 'Searches, crawls, summarizes with citations',
+    architecture: 'Designs structure, modules, data flow, tradeoffs',
+    review: 'Critiques code, design, or plans',
+    documentation: 'Produces docs in Markdown',
+    translation: 'Translates content across languages',
+    terminal: 'Produces shell commands',
+    verification: 'Verifies tasks meet acceptance criteria',
+    vision: 'Analyzes images, OCR, visual content',
+    browser: 'Drives a browser via Playwright',
+};