pikiloom 0.4.36 → 0.4.38

package/packages/kernel/dist/drivers/codex.js

@@ -0,0 +1,346 @@
+import { spawn } from 'node:child_process';
+// Minimal newline-delimited JSON-RPC client for `codex app-server` (ported faithfully
+// from pikiloom's CodexAppServer; trimmed to what the kernel needs).
+class AppServer {
+    bin;
+    configOverrides;
+    env;
+    proc = null;
+    buf = '';
+    nextId = 1;
+    pending = new Map();
+    notify;
+    requestResponder;
+    constructor(bin, configOverrides, env) {
+        this.bin = bin;
+        this.configOverrides = configOverrides;
+        this.env = env;
+    }
+    onNotification(cb) { this.notify = cb; }
+    onServerRequest(cb) { this.requestResponder = cb; }
+    async start() {
+        const args = ['app-server'];
+        const overrides = this.configOverrides.some(c => /^features\.goals\s*=/.test(c)) ? this.configOverrides : [...this.configOverrides, 'features.goals=true'];
+        for (const c of overrides)
+            args.push('-c', c);
+        try {
+            this.proc = spawn(this.bin, args, { stdio: ['pipe', 'pipe', 'pipe'], env: this.env ? { ...process.env, ...this.env } : process.env });
+        }
+        catch {
+            return false;
+        }
+        this.proc.stdout.on('data', (chunk) => this.onData(chunk));
+        this.proc.on('close', () => { for (const cb of this.pending.values())
+            cb({ error: { message: 'app-server exited' } }); this.pending.clear(); });
+        this.proc.on('error', () => { });
+        const init = await this.call('initialize', { clientInfo: { name: '@pikiloom/kernel', version: '0.1.0' }, capabilities: { experimentalApi: true } }, 15_000);
+        return !init.error;
+    }
+    onData(chunk) {
+        this.buf += chunk.toString('utf8');
+        const lines = this.buf.split('\n');
+        this.buf = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (msg.method && msg.id != null) { // server -> client request
+                const id = msg.id;
+                Promise.resolve(this.requestResponder ? this.requestResponder(msg.method, msg.params ?? {}, id) : {})
+                    .then((result) => this.respond(id, result ?? {}))
+                    .catch(() => this.respond(id, {}));
+            }
+            else if (msg.id != null) { // response to our call
+                const cb = this.pending.get(msg.id);
+                if (cb) {
+                    this.pending.delete(msg.id);
+                    cb(msg);
+                }
+            }
+            else if (msg.method) { // notification
+                this.notify?.(msg.method, msg.params ?? {});
+            }
+        }
+    }
+    call(method, params, timeoutMs = 60_000) {
+        return new Promise((resolve) => {
+            if (!this.proc || this.proc.killed) {
+                resolve({ error: { message: 'not connected' } });
+                return;
+            }
+            const id = this.nextId++;
+            const timer = setTimeout(() => { this.pending.delete(id); resolve({ error: { message: `RPC '${method}' timed out` } }); }, timeoutMs);
+            this.pending.set(id, (m) => { clearTimeout(timer); resolve(m); });
+            const msg = { jsonrpc: '2.0', id, method };
+            if (params !== undefined)
+                msg.params = params;
+            try {
+                this.proc.stdin.write(JSON.stringify(msg) + '\n');
+            }
+            catch {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                resolve({ error: { message: 'write failed' } });
+            }
+        });
+    }
+    respond(id, result) {
+        try {
+            this.proc?.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
+        }
+        catch { /* closed */ }
+    }
+    kill() { try {
+        this.proc?.kill('SIGTERM');
+    }
+    catch { /* ignore */ } this.proc = null; }
+}
+function planFromUpdate(params) {
+    const rawSteps = Array.isArray(params?.plan?.steps) ? params.plan.steps : Array.isArray(params?.steps) ? params.steps : Array.isArray(params?.plan) ? params.plan : [];
+    const steps = rawSteps.map((st) => {
+        const text = typeof st?.step === 'string' ? st.step : typeof st?.text === 'string' ? st.text : '';
+        const raw = String(st?.status || 'pending');
+        const status = raw === 'completed' ? 'completed' : (raw === 'in_progress' || raw === 'inProgress') ? 'inProgress' : 'pending';
+        return text ? { text, status } : null;
+    }).filter(Boolean);
+    return steps.length ? { explanation: typeof params?.explanation === 'string' ? params.explanation : null, steps } : null;
+}
+function codexCommandPreview(command) {
+    const text = (Array.isArray(command) ? command.join(' ') : typeof command === 'string' ? command : '').replace(/\s+/g, ' ').trim();
+    return text.length > 120 ? text.slice(0, 119).trimEnd() + '…' : text;
+}
+function codexFileChangeSummary(item) {
+    const changes = Array.isArray(item?.changes) ? item.changes : [];
+    const paths = changes.map((c) => (typeof c?.path === 'string' ? c.path.split('/').filter(Boolean).slice(-2).join('/') : '')).filter(Boolean);
+    if (paths.length === 1)
+        return `Edit ${paths[0]}`;
+    if (paths.length > 1)
+        return `Edit ${paths.length} files`;
+    return 'Edit files';
+}
+// Normalize a codex app-server item -> {id, name, summary}. The summary mirrors pikiloom's
+// vocabulary ("Run shell: <cmd>", "Edit <path>") so the activity projection reads naturally.
+function codexToolSummary(item) {
+    const id = String(item?.id || '');
+    if (!id)
+        return null;
+    if (item.type === 'commandExecution') {
+        const c = codexCommandPreview(item.command);
+        return { id, name: 'shell', summary: c ? `Run shell: ${c}` : 'Run shell command' };
+    }
+    if (item.type === 'fileChange' || item.type === 'patch')
+        return { id, name: 'edit', summary: codexFileChangeSummary(item) };
+    const tool = typeof item?.tool === 'string' ? item.tool : typeof item?.name === 'string' ? item.name : item?.type;
+    return tool ? { id, name: String(tool), summary: String(tool) } : null;
+}
+// codex `item/tool/requestUserInput` params -> a normalized UniversalInteraction
+// (faithful to the legacy codex driver's toAgentInteraction shape).
+function codexUserInputToInteraction(params, promptId) {
+    const raw = Array.isArray(params?.questions) ? params.questions : [];
+    const questions = raw.map((q) => {
+        const opts = Array.isArray(q?.options) ? q.options : [];
+        const hasOpts = opts.length > 0;
+        return {
+            id: String(q?.id || ''),
+            header: String(q?.header || '') || 'Question',
+            text: String(q?.question || ''),
+            type: (hasOpts ? 'select' : 'text'),
+            choices: hasOpts ? opts.map((o) => ({ label: String(o?.label || ''), description: String(o?.description || ''), value: String(o?.label || '') })) : undefined,
+            allowFreeform: !!q?.isOther || !hasOpts,
+            allowEmpty: true,
+        };
+    }).filter((q) => q.id && q.text);
+    if (!questions.length)
+        return null;
+    return { promptId, kind: 'user-input', title: 'User Input Required', hint: 'Use the buttons when available, or reply with text.', questions };
+}
+export class CodexDriver {
+    bin;
+    id = 'codex';
+    capabilities = { steer: true, interact: false, resume: true, tui: true };
+    constructor(bin = 'codex') {
+        this.bin = bin;
+    }
+    async run(input, ctx) {
+        // BYOK provider routing arrives as `-c key=value` overrides; pass them through so the
+        // kernel path keeps third-party models (e.g. glm via OpenRouter) instead of falling back
+        // to the native account.
+        const config = [...(input.configOverrides || [])];
+        const srv = new AppServer(this.bin, config, input.env);
+        const state = { text: '', reasoning: '', sessionId: input.sessionId ?? null, input: null, output: null, cached: null, status: null, error: null, turnId: null };
+        const phases = new Map();
+        const toolSummaries = new Map();
+        let steerRegistered = false;
+        const ok = await srv.start();
+        if (!ok)
+            return { ok: false, text: '', error: 'failed to start codex app-server', stopReason: 'error' };
+        const onAbort = () => srv.kill();
+        if (ctx.signal.aborted)
+            onAbort();
+        else
+            ctx.signal.addEventListener('abort', onAbort, { once: true });
+        try {
+            const threadParams = { cwd: input.workdir, model: input.model || null };
+            if (input.systemPrompt)
+                threadParams.developerInstructions = input.systemPrompt;
+            if (input.fullAccess) {
+                threadParams.approvalPolicy = 'never';
+                threadParams.sandbox = 'danger-full-access';
+            }
+            const threadResp = input.sessionId
+                ? await srv.call('thread/resume', { threadId: input.sessionId, ...threadParams })
+                : await srv.call('thread/start', threadParams);
+            if (threadResp.error)
+                return { ok: false, text: '', error: threadResp.error.message || 'thread/start failed', stopReason: 'error' };
+            const threadId = threadResp.result?.thread?.id ?? input.sessionId ?? null;
+            if (threadId && threadId !== state.sessionId) {
+                state.sessionId = threadId;
+                ctx.emit({ type: 'session', sessionId: threadId });
+            }
+            let settle = () => { };
+            const turnDone = new Promise((res) => { settle = res; });
+            srv.onNotification((method, params) => {
+                if (params?.threadId && params.threadId !== state.sessionId && method !== 'turn/started')
+                    return;
+                switch (method) {
+                    case 'turn/started':
+                        state.turnId = params?.turn?.id ?? null;
+                        if (!steerRegistered && state.turnId) {
+                            steerRegistered = true;
+                            ctx.registerSteer(async (prompt, attachments = []) => {
+                                if (!state.sessionId || !state.turnId)
+                                    return false;
+                                const r = await srv.call('turn/steer', { threadId: state.sessionId, expectedTurnId: state.turnId, input: buildTurnInput(prompt, attachments) }, 30_000);
+                                if (r.error)
+                                    return false;
+                                state.turnId = r.result?.turnId ?? state.turnId;
+                                return true;
+                            });
+                        }
+                        break;
+                    case 'item/started': {
+                        const item = params?.item || {};
+                        if (item.type === 'agentMessage' && item.id)
+                            phases.set(item.id, item.phase || 'final_answer');
+                        const t = codexToolSummary(item);
+                        if (t && !toolSummaries.has(t.id)) {
+                            toolSummaries.set(t.id, t.summary);
+                            ctx.emit({ type: 'tool', call: { id: t.id, name: t.name, summary: t.summary, status: 'running' } });
+                        }
+                        break;
+                    }
+                    case 'item/agentMessage/delta': {
+                        const phase = params?.itemId ? (phases.get(params.itemId) || 'final_answer') : 'final_answer';
+                        if (phase === 'final_answer' && params?.delta) {
+                            state.text += params.delta;
+                            ctx.emit({ type: 'text', delta: params.delta });
+                        }
+                        break;
+                    }
+                    case 'item/reasoning/textDelta':
+                    case 'item/reasoning/summaryTextDelta':
+                        if (params?.delta) {
+                            state.reasoning += params.delta;
+                            ctx.emit({ type: 'reasoning', delta: params.delta });
+                        }
+                        break;
+                    case 'item/completed': {
+                        const item = params?.item || {};
+                        const t = codexToolSummary(item);
+                        if (t && toolSummaries.has(t.id))
+                            ctx.emit({ type: 'tool', call: { id: t.id, name: t.name, summary: toolSummaries.get(t.id) || t.summary, status: item.status === 'failed' ? 'failed' : 'done' } });
+                        break;
+                    }
+                    case 'turn/plan/updated': {
+                        const plan = planFromUpdate(params);
+                        if (plan)
+                            ctx.emit({ type: 'plan', plan });
+                        break;
+                    }
+                    case 'thread/tokenUsage/updated': {
+                        const u = params?.tokenUsage || params?.usage || {};
+                        if (u.input_tokens != null || u.inputTokens != null)
+                            state.input = u.input_tokens ?? u.inputTokens;
+                        if (u.output_tokens != null || u.outputTokens != null)
+                            state.output = u.output_tokens ?? u.outputTokens;
+                        if (u.cached_input_tokens != null || u.cachedInputTokens != null)
+                            state.cached = u.cached_input_tokens ?? u.cachedInputTokens;
+                        ctx.emit({ type: 'usage', usage: { inputTokens: state.input, outputTokens: state.output, cachedInputTokens: state.cached, contextPercent: null } });
+                        break;
+                    }
+                    case 'turn/completed': {
+                        const turn = params?.turn || {};
+                        state.status = turn.status ?? 'completed';
+                        if (turn.error)
+                            state.error = turn.error.message || turn.error.code || 'turn error';
+                        settle();
+                        break;
+                    }
+                }
+            });
+            // Codex server->client requests: route user-input to the HITL seam (ctx.askUser),
+            // accept approvals by default (parity with the legacy codex driver).
+            srv.onServerRequest(async (method, params, id) => {
+                if (method === 'item/tool/requestUserInput') {
+                    const interaction = codexUserInputToInteraction(params, `codex-input-${id}`);
+                    if (!interaction)
+                        return { answers: {} };
+                    const answers = await ctx.askUser(interaction);
+                    return { answers: Object.fromEntries(Object.entries(answers).map(([qid, vals]) => [qid, { answers: vals }])) };
+                }
+                if (method === 'item/commandExecution/requestApproval' || method === 'item/fileChange/requestApproval')
+                    return { decision: 'accept' };
+                if (method === 'item/permissions/requestApproval')
+                    return { permissions: {}, scope: 'turn' };
+                return {};
+            });
+            const turnResp = await srv.call('turn/start', {
+                threadId: state.sessionId,
+                input: buildTurnInput(input.prompt, input.attachments || []),
+                model: input.model || undefined,
+                effort: input.effort || undefined,
+            });
+            if (turnResp.error)
+                return { ok: false, text: state.text, error: turnResp.error.message || 'turn/start failed', stopReason: 'error', sessionId: state.sessionId };
+            await turnDone;
+            const usage = { inputTokens: state.input, outputTokens: state.output, cachedInputTokens: state.cached, contextPercent: null };
+            const ok2 = (state.status === 'completed' || state.status == null) && !state.error && !ctx.signal.aborted;
+            return {
+                ok: ok2,
+                text: state.text,
+                reasoning: state.reasoning || undefined,
+                error: state.error || (ctx.signal.aborted ? 'Interrupted by user.' : null),
+                stopReason: ctx.signal.aborted ? 'interrupted' : (state.status || 'end_turn'),
+                sessionId: state.sessionId,
+                usage,
+            };
+        }
+        finally {
+            srv.kill();
+        }
+    }
+    tui(input) {
+        const args = [];
+        if (input.model)
+            args.push('-m', input.model);
+        if (input.extraArgs?.length)
+            args.push(...input.extraArgs);
+        return { command: this.bin, args, cwd: input.workdir, env: input.env };
+    }
+}
+const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp']);
+function buildTurnInput(prompt, attachments) {
+    const input = [];
+    for (const f of attachments) {
+        const ext = f.slice(f.lastIndexOf('.')).toLowerCase();
+        input.push(IMAGE_EXTS.has(ext) ? { type: 'localImage', path: f } : { type: 'text', text: `[Attached file: ${f}]` });
+    }
+    input.push({ type: 'text', text: prompt });
+    return input;
+}

package/packages/kernel/dist/drivers/echo.d.ts

@@ -0,0 +1,20 @@
+import type { AgentDriver, AgentTurnInput, DriverContext, DriverResult } from '../contracts/driver.js';
+export declare class EchoDriver implements AgentDriver {
+    readonly id = "echo";
+    readonly capabilities: {
+        steer: boolean;
+        interact: boolean;
+        resume: boolean;
+        tui: boolean;
+    };
+    tui(input: {
+        workdir: string;
+        env?: Record<string, string>;
+    }): {
+        command: string;
+        args: string[];
+        cwd: string;
+        env?: Record<string, string>;
+    };
+    run(input: AgentTurnInput, ctx: DriverContext): Promise<DriverResult>;
+}

package/packages/kernel/dist/drivers/echo.js

@@ -0,0 +1,61 @@
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+// Deterministic, dependency-free driver used for hermetic E2E. Its behavior is keyed
+// off prompt prefixes so tests can exercise every event + control verb without timing
+// races:
+//   "ASK: <q>"  -> emits an interaction, awaits the answer, echoes it
+//   "HOLD ..."  -> registers steer + blocks until steered OR stopped, then echoes
+//   anything    -> reasoning + tool(running/done) + streamed text echo + usage
+const ECHO_TUI = `process.stdout.write('ECHO-TUI-READY\\n');process.stdin.on('data',d=>{const s=d.toString();if(s.includes('Q')){process.stdout.write('BYE\\n');setTimeout(()=>process.exit(0),10);return;}process.stdout.write('GOT:'+s);});`;
+export class EchoDriver {
+    id = 'echo';
+    capabilities = { steer: true, interact: true, resume: true, tui: true };
+    // A hermetic raw-PTY "TUI": prints a banner, echoes input, exits on 'Q'. Lets the
+    // Lane R passthrough path be exercised without a real agent.
+    tui(input) {
+        return { command: process.execPath, args: ['-e', ECHO_TUI], cwd: input.workdir, env: input.env };
+    }
+    async run(input, ctx) {
+        const prompt = input.prompt;
+        ctx.emit({ type: 'reasoning', delta: `Considering: ${prompt}` });
+        if (prompt.startsWith('ASK:')) {
+            const q = prompt.slice(4).trim() || 'Your input?';
+            const answers = await ctx.askUser({
+                promptId: 'echo-ask', kind: 'user-input', title: 'Echo asks',
+                questions: [{ id: 'a', text: q, allowFreeform: true }],
+            });
+            const a = answers['a']?.[0] ?? '(none)';
+            const text = `You said: ${a}`;
+            ctx.emit({ type: 'text', delta: text });
+            return { ok: true, text, reasoning: `Considering: ${prompt}`, stopReason: 'end_turn' };
+        }
+        let steered = null;
+        if (prompt.startsWith('HOLD')) {
+            ctx.emit({ type: 'activity', line: 'holding for steer' });
+            await new Promise((resolve) => {
+                ctx.registerSteer(async (p) => { steered = p; resolve(); return true; });
+                if (ctx.signal.aborted)
+                    resolve();
+                else
+                    ctx.signal.addEventListener('abort', () => resolve(), { once: true });
+            });
+            if (ctx.signal.aborted) {
+                return { ok: false, text: '', error: 'Interrupted by user.', stopReason: 'interrupted' };
+            }
+        }
+        ctx.emit({ type: 'tool', call: { id: 't1', name: 'echo_tool', summary: 'echo the prompt', status: 'running' } });
+        const base = `Echo: ${prompt}` + (steered ? ` | steered: ${steered}` : '');
+        let acc = '';
+        for (const tok of base.split(/(\s+)/)) {
+            if (ctx.signal.aborted)
+                return { ok: false, text: acc, error: 'Interrupted by user.', stopReason: 'interrupted' };
+            acc += tok;
+            if (tok)
+                ctx.emit({ type: 'text', delta: tok });
+            await sleep(2);
+        }
+        ctx.emit({ type: 'tool', call: { id: 't1', name: 'echo_tool', summary: 'echo the prompt', status: 'done', result: 'ok' } });
+        const usage = { inputTokens: prompt.length, outputTokens: base.length, cachedInputTokens: 0, contextPercent: null };
+        ctx.emit({ type: 'usage', usage });
+        return { ok: true, text: acc, reasoning: `Considering: ${prompt}`, usage, stopReason: 'end_turn' };
+    }
+}

package/packages/kernel/dist/drivers/gemini.d.ts

@@ -0,0 +1,18 @@
+import type { AgentDriver, AgentTurnInput, DriverContext, DriverResult, DriverEvent, TuiInput, TuiSpec } from '../contracts/driver.js';
+export declare class GeminiDriver implements AgentDriver {
+    private readonly bin;
+    readonly id = "gemini";
+    readonly capabilities: {
+        steer: boolean;
+        interact: boolean;
+        resume: boolean;
+        tui: boolean;
+    };
+    constructor(bin?: string);
+    run(input: AgentTurnInput, ctx: DriverContext): Promise<DriverResult>;
+    tui(input: TuiInput): TuiSpec;
+}
+export declare function parseGeminiEvent(ev: any, s: any, tools: Map<string, {
+    name: string;
+    summary: string;
+}>, emit: (e: DriverEvent) => void): void;

package/packages/kernel/dist/drivers/gemini.js

@@ -0,0 +1,143 @@
+import { spawn } from 'node:child_process';
+// Native kernel Gemini driver: `gemini --output-format stream-json ... -p <prompt>` and
+// parse its stream-json events into kernel DriverEvents. Faithful to pikiloom's geminiParse.
+export class GeminiDriver {
+    bin;
+    id = 'gemini';
+    capabilities = { steer: false, interact: false, resume: true, tui: true };
+    constructor(bin = 'gemini') {
+        this.bin = bin;
+    }
+    run(input, ctx) {
+        const args = ['--output-format', 'stream-json'];
+        if (input.model)
+            args.push('--model', input.model);
+        if (input.sessionId)
+            args.push('--resume', input.sessionId);
+        const extra = input.extraArgs || [];
+        if (!extra.some(a => a === '--approval-mode' || a === '--yolo' || a === '-y'))
+            args.push('--approval-mode', 'yolo');
+        if (extra.length)
+            args.push(...extra);
+        args.push('-p', input.prompt);
+        const s = { text: '', sessionId: input.sessionId ?? null, model: input.model ?? null, input: null, output: null, cached: null, stopReason: null, error: null };
+        const tools = new Map();
+        return new Promise((resolve) => {
+            let child;
+            try {
+                child = spawn(this.bin, args, { cwd: input.workdir, env: input.env ? { ...process.env, ...input.env } : process.env, stdio: ['ignore', 'pipe', 'pipe'] });
+            }
+            catch (err) {
+                resolve({ ok: false, text: '', error: `spawn failed: ${err?.message || err}`, stopReason: 'error' });
+                return;
+            }
+            const onAbort = () => { try {
+                child.kill('SIGTERM');
+            }
+            catch { /* ignore */ } };
+            if (ctx.signal.aborted)
+                onAbort();
+            else
+                ctx.signal.addEventListener('abort', onAbort, { once: true });
+            let buf = '';
+            let stderr = '';
+            child.stdout.on('data', (chunk) => {
+                buf += chunk.toString('utf8');
+                const lines = buf.split('\n');
+                buf = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    let ev;
+                    try {
+                        ev = JSON.parse(trimmed);
+                    }
+                    catch {
+                        continue;
+                    }
+                    parseGeminiEvent(ev, s, tools, ctx.emit);
+                }
+            });
+            child.stderr.on('data', (c) => { stderr += c.toString('utf8'); });
+            child.on('error', (err) => resolve({ ok: false, text: s.text, error: `gemini spawn error: ${err.message}`, stopReason: 'error' }));
+            child.on('close', (code) => {
+                const usage = { inputTokens: s.input, outputTokens: s.output, cachedInputTokens: s.cached, contextPercent: null };
+                if (ctx.signal.aborted) {
+                    resolve({ ok: false, text: s.text, error: 'Interrupted by user.', stopReason: 'interrupted', sessionId: s.sessionId, usage });
+                    return;
+                }
+                const ok = !s.error && code === 0;
+                resolve({ ok, text: s.text, error: s.error || (ok ? null : `gemini exited ${code}${stderr ? `: ${stderr.slice(0, 200)}` : ''}`), stopReason: s.stopReason, sessionId: s.sessionId, usage });
+            });
+        });
+    }
+    tui(input) {
+        const args = [];
+        if (input.model)
+            args.push('--model', input.model);
+        if (input.extraArgs?.length)
+            args.push(...input.extraArgs);
+        return { command: this.bin, args, cwd: input.workdir, env: input.env };
+    }
+}
+export function parseGeminiEvent(ev, s, tools, emit) {
+    const t = ev.type || '';
+    if (t === 'init') {
+        if (ev.session_id && ev.session_id !== s.sessionId) {
+            s.sessionId = ev.session_id;
+            emit({ type: 'session', sessionId: ev.session_id });
+        }
+        s.model = ev.model ?? s.model;
+        return;
+    }
+    if (t === 'message' && ev.role === 'assistant') {
+        if (ev.delta) {
+            const d = ev.content || '';
+            if (d) {
+                s.text += d;
+                emit({ type: 'text', delta: d });
+            }
+        }
+        else if (!s.text.trim() && ev.content) {
+            s.text = ev.content;
+            emit({ type: 'text', delta: ev.content });
+        }
+        return;
+    }
+    if (t === 'tool_use' || t === 'tool_call') {
+        const id = String(ev.tool_id || ev.id || '').trim();
+        const name = String(ev.tool_name || ev.name || ev.tool || 'Tool');
+        if (id && !tools.has(id)) {
+            tools.set(id, { name, summary: name });
+            emit({ type: 'tool', call: { id, name, summary: name, status: 'running' } });
+        }
+        return;
+    }
+    if (t === 'tool_result') {
+        const id = String(ev.tool_id || ev.id || '').trim();
+        const tool = id ? tools.get(id) : undefined;
+        if (tool)
+            emit({ type: 'tool', call: { id, name: tool.name, summary: tool.summary, status: ev.is_error ? 'failed' : 'done' } });
+        return;
+    }
+    if (t === 'error' && ev.severity === 'error') {
+        s.error = String(ev.message || ev.error || 'Gemini error');
+        return;
+    }
+    if (t === 'result') {
+        if (ev.session_id)
+            s.sessionId = ev.session_id;
+        if (ev.status === 'error' || ev.status === 'failure')
+            s.error = String(ev.error || ev.message || `status ${ev.status}`);
+        s.stopReason = ev.status === 'success' ? 'end_turn' : ev.status;
+        const u = ev.stats;
+        if (u) {
+            s.input = u.input_tokens ?? u.input ?? s.input;
+            s.output = u.output_tokens ?? u.output ?? s.output;
+            s.cached = u.cached ?? s.cached;
+            emit({ type: 'usage', usage: { inputTokens: s.input, outputTokens: s.output, cachedInputTokens: s.cached, contextPercent: null } });
+        }
+        return;
+    }
+}

package/packages/kernel/dist/drivers/hermes.d.ts

@@ -0,0 +1,14 @@
+import type { AgentDriver, AgentTurnInput, DriverContext, DriverResult, DriverEvent } from '../contracts/driver.js';
+export declare class HermesDriver implements AgentDriver {
+    private readonly bin;
+    readonly id = "hermes";
+    readonly capabilities: {
+        steer: boolean;
+        interact: boolean;
+        resume: boolean;
+        tui: boolean;
+    };
+    constructor(bin?: string);
+    run(input: AgentTurnInput, ctx: DriverContext): Promise<DriverResult>;
+}
+export declare function applyHermesUpdate(u: any, s: any, tools: Set<string>, emit: (e: DriverEvent) => void): void;