pikiloom 0.4.41 → 0.4.43

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

@@ -1,4 +1,6 @@
 import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { extname } from 'node:path';
 import { discoverClaudeNativeSessions } from '../workspace/native.js';
 // Real driver: shells the local `claude` CLI in stream-json mode and normalizes its
 // events into kernel DriverEvents. Faithful to pikiloom's claude.ts event shapes
@@ -28,6 +30,9 @@ export class ClaudeDriver {
     }
     run(input, ctx) {
         const steerable = !!input.steerable;
+        // Image attachments must ride a stream-json user message (text-only stdin can't carry images),
+        // so enable that input mode whenever there are attachments, not just for mid-turn steering.
+        const useStreamJson = steerable || !!input.attachments?.length;
         const args = ['-p', '--verbose', '--output-format', 'stream-json', '--include-partial-messages'];
         if (input.model)
             args.push('--model', input.model);
@@ -41,8 +46,10 @@ export class ClaudeDriver {
             args.push('--mcp-config', input.mcpConfigPath);
         if (input.permissionMode)
             args.push('--permission-mode', input.permissionMode); // parity: keep bypass/accept-edits on the kernel path
+        if (useStreamJson)
+            args.push('--input-format', 'stream-json');
         if (steerable)
-            args.push('--input-format', 'stream-json', '--replay-user-messages'); // parity: mid-turn steer
+            args.push('--replay-user-messages'); // parity: mid-turn steer
         if (input.extraArgs?.length)
             args.push(...input.extraArgs);
         const state = {
@@ -54,6 +61,9 @@ export class ClaudeDriver {
             contextWindow: null, turnOutputTokensBase: 0,
             subAgents: new Map(),
             tools: new Map(),
+            taskList: new Map(),
+            taskOrder: [],
+            pendingTaskCreates: new Map(),
         };
         return new Promise((resolve) => {
             let child;
@@ -90,9 +100,9 @@ export class ClaudeDriver {
             else
                 ctx.signal.addEventListener('abort', onAbort, { once: true });
             if (steerable) {
-                ctx.registerSteer(async (prompt) => {
+                ctx.registerSteer(async (prompt, attachments) => {
                     try {
-                        child.stdin.write(claudeUserMessage(prompt) + '\n');
+                        child.stdin.write(claudeUserMessage(prompt, attachments) + '\n');
                         return true;
                     }
                     catch {
@@ -136,8 +146,11 @@ export class ClaudeDriver {
                 finish({ ok, text: state.text, reasoning: state.reasoning || undefined, error: state.error || (ok ? null : `claude exited ${code}${stderr ? `: ${stderr.slice(0, 300)}` : ''}`), stopReason: state.stopReason, sessionId: state.sessionId, usage: usageOf() });
             });
             try {
-                if (steerable)
-                    child.stdin.write(claudeUserMessage(input.prompt) + '\n'); // keep stdin open for steering
+                if (useStreamJson) {
+                    child.stdin.write(claudeUserMessage(input.prompt, input.attachments) + '\n');
+                    if (!steerable)
+                        child.stdin.end(); // single turn; steer mode keeps stdin open for replay
+                }
                 else {
                     child.stdin.write(input.prompt);
                     child.stdin.end();
@@ -301,6 +314,34 @@ export function handleClaudeEvent(ev, s, emit) {
                     emit({ type: 'plan', plan });
                 continue;
             }
+            // Task list (current Claude mechanism): stash the subject; the tool_result assigns the id.
+            // Plan-only — like the legacy driver these never surface as Activity rows.
+            if (name === 'TaskCreate') {
+                const subject = typeof b.input?.subject === 'string' ? b.input.subject.trim() : '';
+                if (subject)
+                    (s.pendingTaskCreates ||= new Map()).set(id, { subject });
+                continue;
+            }
+            if (name === 'TaskUpdate') {
+                const taskId = String(b.input?.taskId ?? '').trim();
+                const rawStatus = String(b.input?.status ?? '').trim().toLowerCase();
+                if (taskId) {
+                    if (rawStatus === 'deleted') {
+                        s.taskList?.delete(taskId);
+                        if (Array.isArray(s.taskOrder))
+                            s.taskOrder = s.taskOrder.filter((x) => x !== taskId);
+                    }
+                    else if (rawStatus) {
+                        const existing = s.taskList?.get(taskId);
+                        if (existing)
+                            existing.status = rawStatus;
+                    }
+                    const plan = rebuildClaudeTaskPlan(s);
+                    if (plan)
+                        emit({ type: 'plan', plan });
+                }
+                continue;
+            }
             if (name === 'Task' || name === 'Agent') {
                 const input = b.input || {};
                 const sub = {
@@ -348,6 +389,23 @@ export function handleClaudeEvent(ev, s, emit) {
                 continue;
             emitClaudeImages(b.content || [], s, emit);
             const id = String(b.tool_use_id || '').trim();
+            // TaskCreate result: the assigned task id arrives here; register the task and emit the plan.
+            if (id && s.pendingTaskCreates?.has(id)) {
+                const pending = s.pendingTaskCreates.get(id);
+                const assignedId = readClaudeTaskCreateId(ev, b);
+                if (pending && assignedId) {
+                    s.pendingTaskCreates.delete(id);
+                    (s.taskList ||= new Map());
+                    (s.taskOrder ||= []);
+                    if (!s.taskList.has(assignedId))
+                        s.taskOrder.push(assignedId);
+                    s.taskList.set(assignedId, { subject: pending.subject, status: 'pending' });
+                    const plan = rebuildClaudeTaskPlan(s);
+                    if (plan)
+                        emit({ type: 'plan', plan });
+                }
+                continue;
+            }
             const tool = id ? s.tools?.get(id) : undefined;
             if (!tool)
                 continue;
@@ -384,10 +442,30 @@ export function handleClaudeEvent(ev, s, emit) {
         return;
     }
 }
-// A stream-json user message (for --input-format stream-json; used to send the prompt and
-// to inject mid-turn steer messages while stdin stays open).
-export function claudeUserMessage(text) {
-    return JSON.stringify({ type: 'user', message: { role: 'user', content: [{ type: 'text', text }] } });
+// Claude vision input formats (matches the legacy driver / Anthropic API: png, jpeg, gif, webp).
+const CLAUDE_IMAGE_MIME = {
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif', '.webp': 'image/webp',
+};
+// A stream-json user message (for --input-format stream-json; used to send the prompt and to
+// inject mid-turn steer messages while stdin stays open). Image attachments are inlined as base64
+// image content blocks so the model actually sees them; other files become a text note. Without
+// this the kernel path sent text only and silently dropped pasted/attached images.
+export function claudeUserMessage(text, attachments) {
+    const content = [];
+    for (const filePath of attachments || []) {
+        const mime = CLAUDE_IMAGE_MIME[extname(filePath).toLowerCase()];
+        if (mime) {
+            try {
+                content.push({ type: 'image', source: { type: 'base64', media_type: mime, data: readFileSync(filePath).toString('base64') } });
+                continue;
+            }
+            catch { /* unreadable -> fall through to a text note */ }
+        }
+        content.push({ type: 'text', text: `[Attached file: ${filePath}]` });
+    }
+    content.push({ type: 'text', text });
+    return JSON.stringify({ type: 'user', message: { role: 'user', content } });
 }
 // Surface base64 image content blocks as artifacts (data URLs), deduped per turn.
 export function emitClaudeImages(blocks, s, emit) {
@@ -425,6 +503,45 @@ export function todoWriteToPlan(input) {
     }
     return steps.length ? { explanation: null, steps } : null;
 }
+// ── Claude task-list (TaskCreate / TaskUpdate) -> UniversalPlan ──────────────────────
+// Current Claude Code drives its task list through TaskCreate/TaskUpdate, NOT TodoWrite
+// (TodoWrite is the legacy mechanism). TaskCreate carries the subject; its tool_result then
+// assigns a stable task id (toolUseResult.task.id, or "Task #N" in the text). TaskUpdate flips
+// a task's status by id. We accumulate the list in driver state and re-emit the whole plan on
+// each change. Without this the kernel path never emits a plan event for Claude, so the
+// dashboard's task-list card never renders. Ported from pikiloom's legacy claude driver.
+// The assigned task id from a TaskCreate tool_result. Prefer the structured field; fall back
+// to parsing "Task #N" from a string result.
+export function readClaudeTaskCreateId(ev, block) {
+    const structured = ev?.toolUseResult?.task?.id;
+    if (structured != null && String(structured).trim())
+        return String(structured).trim();
+    const content = block?.content;
+    if (typeof content === 'string') {
+        const m = content.match(/Task #(\d+)/);
+        if (m)
+            return m[1];
+    }
+    return null;
+}
+export function rebuildClaudeTaskPlan(s) {
+    if (!Array.isArray(s?.taskOrder) || !s.taskOrder.length)
+        return null;
+    const steps = [];
+    for (const id of s.taskOrder) {
+        const task = s.taskList?.get(id);
+        if (!task)
+            continue;
+        const lowered = String(task.status || '').toLowerCase();
+        const status = lowered === 'completed' ? 'completed'
+            : (lowered === 'in_progress' || lowered === 'inprogress') ? 'inProgress'
+                : 'pending';
+        const text = String(task.subject || '').trim();
+        if (text)
+            steps.push({ text, status });
+    }
+    return steps.length ? { explanation: null, steps } : null;
+}
 // ── Tool-call summarization (ported from pikiloom's summarizeClaudeToolUse) ──────────
 // Turns a Claude tool_use {name,input} into a one-line human summary. The runtime's
 // activity projector joins these into snapshot.activity; the structured form lives in

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

@@ -185,13 +185,11 @@ export function codexReasoningItemText(item) {
     ];
     return parts.map((p) => (typeof p === 'string' ? p : p?.text || '')).filter(Boolean).join('\n').trim();
 }
-// A completed final_answer agentMessage that did NOT stream deltas: append + emit it live.
-// deltaItems holds the ids already streamed, so a completed item echoing a streamed one is
-// not double-counted (matches the legacy driver's deltaSeenForItem guard).
+// A completed agentMessage (commentary preamble OR final_answer) that did NOT stream deltas:
+// append + emit it live. deltaItems holds the ids already streamed, so a completed item echoing
+// a streamed one is not double-counted (matches the legacy driver's deltaSeenForItem guard).
+// Both phases are surfaced — codex's commentary preambles are part of the visible "中间过程".
 export function captureCodexAgentMessage(item, s, deltaItems, phases, emit) {
-    const phase = item?.phase || (item?.id ? phases.get(item.id) : null) || 'final_answer';
-    if (phase !== 'final_answer')
-        return;
     const text = typeof item?.text === 'string' ? item.text.trim() : '';
     if (!text)
         return;
@@ -238,11 +236,26 @@ export class CodexDriver {
         const phases = new Map();
         const toolSummaries = new Map();
         const deltaItems = new Set();
+        let lastTextItemId = null;
         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();
+        let settle = () => { };
+        const turnDone = new Promise((res) => { settle = res; });
+        // On abort: gracefully interrupt the running turn, then settle turnDone OURSELVES. A bare
+        // srv.kill() (SIGTERM) never produces a turn/completed notification, so without this explicit
+        // settle() the `await turnDone` below hangs forever — run() never resolves and the task stays
+        // "running" in the orchestrator even though the codex process is already dead ("停止不掉，但实际上已经停了").
+        const onAbort = () => {
+            if (state.sessionId && state.turnId) {
+                srv.call('turn/interrupt', { threadId: state.sessionId, turnId: state.turnId }, 5_000).finally(() => settle());
+            }
+            else {
+                srv.kill();
+                settle();
+            }
+        };
         if (ctx.signal.aborted)
             onAbort();
         else
@@ -265,8 +278,6 @@ export class CodexDriver {
                 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;
@@ -298,13 +309,22 @@ export class CodexDriver {
                         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;
-                            if (params.itemId)
-                                deltaItems.add(params.itemId);
-                            ctx.emit({ type: 'text', delta: params.delta });
+                        if (!params?.delta)
+                            break;
+                        // Surface BOTH commentary (preamble) and final_answer messages live. Codex narrates
+                        // what it is about to do via phase=commentary agentMessages before tool calls;
+                        // gating on final_answer dropped them, leaving the "中间过程" invisible. Separate
+                        // distinct message items with a blank line so preamble and answer don't run together.
+                        if (params.itemId && params.itemId !== lastTextItemId && state.text) {
+                            state.text += '\n\n';
+                            ctx.emit({ type: 'text', delta: '\n\n' });
+                        }
+                        if (params.itemId) {
+                            lastTextItemId = params.itemId;
+                            deltaItems.add(params.itemId);
                         }
+                        state.text += params.delta;
+                        ctx.emit({ type: 'text', delta: params.delta });
                         break;
                     }
                     case 'item/reasoning/textDelta':

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

@@ -1,14 +1,5 @@
-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;
-    };
+import { AcpDriver, applyAcpUpdate } from './acp.js';
+export declare class HermesDriver extends AcpDriver {
     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;
+export declare const applyHermesUpdate: typeof applyAcpUpdate;

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

@@ -1,194 +1,11 @@
-import { spawn } from 'node:child_process';
-// Minimal ACP (Agent Client Protocol) ndjson JSON-RPC client — same wire as codex
-// app-server. Used by the Hermes driver to drive any-model agents over ACP.
-class AcpClient {
-    bin;
-    args;
-    env;
-    proc = null;
-    buf = '';
-    nextId = 1;
-    pending = new Map();
-    notify;
-    constructor(bin, args, env) {
-        this.bin = bin;
-        this.args = args;
-        this.env = env;
-    }
-    onNotification(cb) { this.notify = cb; }
-    start() {
-        try {
-            this.proc = spawn(this.bin, this.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: 'acp exited' } }); this.pending.clear(); });
-        this.proc.on('error', () => { });
-        return true;
-    }
-    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 m;
-            try {
-                m = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            if (m.method && m.id != null) {
-                this.respond(m.id, {});
-            } // agent->client request: ack
-            else if (m.id != null) {
-                const cb = this.pending.get(m.id);
-                if (cb) {
-                    this.pending.delete(m.id);
-                    cb(m);
-                }
-            }
-            else if (m.method)
-                this.notify?.(m.method, m.params ?? {});
-        }
-    }
-    request(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: `ACP '${method}' timed out` } }); }, timeoutMs);
-            this.pending.set(id, (m) => { clearTimeout(timer); resolve(m); });
-            try {
-                this.proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\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; }
-}
-export class HermesDriver {
-    bin;
-    id = 'hermes';
-    capabilities = { steer: false, interact: false, resume: true, tui: false };
+import { AcpDriver, applyAcpUpdate } from './acp.js';
+// Hermes = the reference ACP agent, shipped as a thin preset over the generic AcpDriver.
+// Any other ACP CLI (OpenCode, Gemini-ACP, …) is just `new AcpDriver({ id, command, args })`.
+export class HermesDriver extends AcpDriver {
     constructor(bin = 'hermes') {
-        this.bin = bin;
-    }
-    async run(input, ctx) {
-        const client = new AcpClient(this.bin, ['acp'], input.env);
-        const s = { text: '', reasoning: '', sessionId: input.sessionId ?? null, contextWindow: null, contextUsed: null, error: null };
-        const tools = new Set();
-        if (!client.start())
-            return { ok: false, text: '', error: 'failed to start hermes acp', stopReason: 'error' };
-        const onAbort = () => { try {
-            client.request('session/cancel', { sessionId: s.sessionId });
-        }
-        catch { /* ignore */ } client.kill(); };
-        if (ctx.signal.aborted)
-            onAbort();
-        else
-            ctx.signal.addEventListener('abort', onAbort, { once: true });
-        client.onNotification((method, params) => {
-            if (method !== 'session/update')
-                return;
-            applyHermesUpdate(params?.update ?? params, s, tools, ctx.emit);
-        });
-        try {
-            const init = await client.request('initialize', { protocolVersion: 1, clientCapabilities: { fs: { readTextFile: false, writeTextFile: false } } });
-            if (init.error)
-                return { ok: false, text: '', error: init.error.message || 'initialize failed', stopReason: 'error' };
-            if (!s.sessionId) {
-                const ns = await client.request('session/new', { cwd: input.workdir, mcpServers: [] });
-                if (ns.error)
-                    return { ok: false, text: '', error: ns.error.message || 'session/new failed', stopReason: 'error' };
-                s.sessionId = ns.result?.sessionId || ns.result?.session_id || null;
-                if (s.sessionId)
-                    ctx.emit({ type: 'session', sessionId: s.sessionId });
-            }
-            else {
-                await client.request('session/load', { sessionId: s.sessionId, cwd: input.workdir, mcpServers: [] }, 30_000).catch(() => ({}));
-            }
-            if (!s.sessionId)
-                return { ok: false, text: '', error: 'hermes returned no session id', stopReason: 'error' };
-            if (input.model)
-                await client.request('session/set_model', { sessionId: s.sessionId, modelId: input.model }, 15_000).catch(() => ({}));
-            const promptResp = await client.request('session/prompt', {
-                sessionId: s.sessionId,
-                prompt: [{ type: 'text', text: input.prompt }],
-            }, 7_200_000);
-            const usage = { inputTokens: null, outputTokens: null, cachedInputTokens: null, contextUsedTokens: s.contextUsed, contextPercent: null };
-            if (ctx.signal.aborted)
-                return { ok: false, text: s.text, error: 'Interrupted by user.', stopReason: 'interrupted', sessionId: s.sessionId, usage };
-            if (promptResp.error)
-                return { ok: false, text: s.text, error: promptResp.error.message || 'session/prompt failed', stopReason: 'error', sessionId: s.sessionId, usage };
-            const stopReason = promptResp.result?.stopReason ?? 'end_turn';
-            return { ok: !s.error, text: s.text, reasoning: s.reasoning || undefined, error: s.error, stopReason, sessionId: s.sessionId, usage };
-        }
-        finally {
-            client.kill();
-        }
-    }
-}
-export function applyHermesUpdate(u, s, tools, emit) {
-    if (!u)
-        return;
-    switch (u.sessionUpdate) {
-        case 'agent_message_chunk': {
-            const t = u.content?.text;
-            if (typeof t === 'string' && t) {
-                s.text += t;
-                emit({ type: 'text', delta: t });
-            }
-            return;
-        }
-        case 'agent_thought_chunk': {
-            const t = u.content?.text;
-            if (typeof t === 'string' && t) {
-                s.reasoning += t;
-                emit({ type: 'reasoning', delta: t });
-            }
-            return;
-        }
-        case 'tool_call': {
-            const id = typeof u.toolCallId === 'string' ? u.toolCallId : '';
-            const title = (typeof u.title === 'string' && u.title.trim()) || 'tool';
-            if (id && !tools.has(id)) {
-                tools.add(id);
-                emit({ type: 'tool', call: { id, name: title, summary: title, status: 'running' } });
-            }
-            return;
-        }
-        case 'tool_call_update': {
-            const id = typeof u.toolCallId === 'string' ? u.toolCallId : '';
-            const title = (typeof u.title === 'string' && u.title.trim()) || 'tool';
-            if (id && (u.status === 'completed' || u.status === 'failed'))
-                emit({ type: 'tool', call: { id, name: title, summary: title, status: u.status === 'failed' ? 'failed' : 'done' } });
-            return;
-        }
-        case 'usage_update': {
-            if (typeof u.used === 'number') {
-                s.contextUsed = u.used;
-                emit({ type: 'usage', usage: { inputTokens: null, outputTokens: null, cachedInputTokens: null, contextUsedTokens: u.used, contextPercent: null } });
-            }
-            return;
-        }
+        super({ id: 'hermes', command: bin, args: ['acp'] });
     }
 }
+// Back-compat alias: the generic ACP session/update parser handles the identical wire that
+// the original hermes-specific parser did. Kept so existing imports/tests resolve.
+export const applyHermesUpdate = applyAcpUpdate;

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

@@ -2,4 +2,5 @@ export { EchoDriver } from './echo.js';
 export { ClaudeDriver, handleClaudeEvent, todoWriteToPlan } from './claude.js';
 export { CodexDriver } from './codex.js';
 export { GeminiDriver, parseGeminiEvent } from './gemini.js';
+export { AcpDriver, applyAcpUpdate, toAcpMcpServers, buildAcpPromptBlocks, type AcpDriverConfig } from './acp.js';
 export { HermesDriver, applyHermesUpdate } from './hermes.js';

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

@@ -2,4 +2,5 @@ export { EchoDriver } from './echo.js';
 export { ClaudeDriver, handleClaudeEvent, todoWriteToPlan } from './claude.js';
 export { CodexDriver } from './codex.js';
 export { GeminiDriver, parseGeminiEvent } from './gemini.js';
+export { AcpDriver, applyAcpUpdate, toAcpMcpServers, buildAcpPromptBlocks } from './acp.js';
 export { HermesDriver, applyHermesUpdate } from './hermes.js';

package/packages/kernel/dist/index.d.ts

@@ -12,8 +12,10 @@ export { EchoDriver } from './drivers/echo.js';
 export { ClaudeDriver } from './drivers/claude.js';
 export { CodexDriver } from './drivers/codex.js';
 export { GeminiDriver } from './drivers/gemini.js';
+export { AcpDriver, type AcpDriverConfig } from './drivers/acp.js';
 export { HermesDriver } from './drivers/hermes.js';
 export { WebSurface, type WebSurfaceOptions } from './surfaces/web.js';
 export { CliSurface } from './surfaces/cli.js';
 export * from './workspace/index.js';
+export * from './accounts.js';
 export * from './protocol/index.js';

package/packages/kernel/dist/index.js

@@ -22,10 +22,13 @@ export { EchoDriver } from './drivers/echo.js';
 export { ClaudeDriver } from './drivers/claude.js';
 export { CodexDriver } from './drivers/codex.js';
 export { GeminiDriver } from './drivers/gemini.js';
+export { AcpDriver } from './drivers/acp.js';
 export { HermesDriver } from './drivers/hermes.js';
 export { WebSurface } from './surfaces/web.js';
 export { CliSurface } from './surfaces/cli.js';
 // Workspace: unified top-level directory + session/skill/mcp management (loom.paths/sessions/skills/mcp)
 export * from './workspace/index.js';
+// Multi-account: per-account isolated config dirs (CLAUDE_CONFIG_DIR / CODEX_HOME)
+export * from './accounts.js';
 // Protocol (the wire vocabulary; shared with transports)
 export * from './protocol/index.js';