pikiloom 0.4.61 → 0.4.63

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

@@ -1,4 +1,4 @@
-import { AcpDriver, applyAcpUpdate } from './acp.js';
+import { AcpDriver } 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 {
@@ -6,6 +6,3 @@ export class HermesDriver extends AcpDriver {
         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

@@ -1,6 +1,7 @@
 export { EchoDriver } from './echo.js';
-export { ClaudeDriver, handleClaudeEvent, todoWriteToPlan } from './claude.js';
+export { ClaudeDriver } 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';
+export { GeminiDriver } from './gemini.js';
+export { AcpDriver, type AcpDriverConfig } from './acp.js';
+export { HermesDriver } from './hermes.js';
+export { discoverClaudeNativeSessions, discoverCodexNativeSessions, discoverGeminiNativeSessions, encodeClaudeProjectDir, type DiscoverOptions, type NativeSessionInfo, } from './native.js';

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

@@ -1,6 +1,10 @@
+// The agent axis: one driver per coding-agent CLI, plus native-session discovery (pure
+// readers of each CLI's own on-disk transcript store). White-box parser/settle helpers are
+// deliberately NOT re-exported here — tests import them from their defining module.
 export { EchoDriver } from './echo.js';
-export { ClaudeDriver, handleClaudeEvent, todoWriteToPlan } from './claude.js';
+export { ClaudeDriver } 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';
+export { GeminiDriver } from './gemini.js';
+export { AcpDriver } from './acp.js';
+export { HermesDriver } from './hermes.js';
+export { discoverClaudeNativeSessions, discoverCodexNativeSessions, discoverGeminiNativeSessions, encodeClaudeProjectDir, } from './native.js';

package/packages/kernel/dist/{workspace → drivers}/native.d.ts

@@ -6,7 +6,6 @@ export interface DiscoverOptions {
     /** A session whose file changed within this window is treated as "running". */
     runningThresholdMs?: number;
 }
-export declare const NATIVE_SESSION_RUNNING_THRESHOLD_MS = 10000;
 /** Claude encodes a workdir into a project dir name by replacing non-alphanumerics with '-'. */
 export declare function encodeClaudeProjectDir(workdir: string): string;
 export declare function discoverClaudeNativeSessions(workdir: string, opts?: DiscoverOptions): NativeSessionInfo[];

package/packages/kernel/dist/{workspace → drivers}/native.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-export const NATIVE_SESSION_RUNNING_THRESHOLD_MS = 10_000;
+const NATIVE_SESSION_RUNNING_THRESHOLD_MS = 10_000;
 function homeOf(opts) {
     return opts?.home || os.homedir();
 }
@@ -21,6 +21,53 @@ function statSafe(p) {
         return null;
     }
 }
+// A transcript's title/preview/model/effort/turns all live in a BOUNDED slice of the file: the HEAD
+// (first prompt, model, ai-title) and the TAIL (latest reply, last turn_context). We read only those
+// slices — never the whole file — so discovery stays O(bounded) per session even when a rollout grows
+// to hundreds of MB. Results are memoized by the file's (mtime,size): an unchanged transcript is read
+// once and every later list call is free, so adding the tail read costs nothing on repeat. Any real
+// change moves mtime+size and re-reads, so the cache can never go stale.
+const HEAD_BYTES = 256 * 1024;
+const TAIL_BYTES = 256 * 1024;
+/** Read a bounded byte region as UTF-8. A partial leading/trailing line is expected; callers skip unparseable lines. */
+function readRegion(filePath, start, length) {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const buf = Buffer.alloc(Math.max(0, length));
+        const n = fs.readSync(fd, buf, 0, buf.length, Math.max(0, start));
+        return buf.toString('utf8', 0, n);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function memoized(cache, filePath, stat, compute) {
+    const hit = cache.get(filePath);
+    if (hit && hit.mtimeMs === stat.mtimeMs && hit.size === stat.size)
+        return hit.value;
+    const value = compute();
+    cache.set(filePath, { mtimeMs: stat.mtimeMs, size: stat.size, value });
+    return value;
+}
+/** Extract plain text from a Codex `response_item` message content (array of `{type,text}` blocks). */
+function codexText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((b) => b && typeof b.text === 'string' && (b.type === 'text' || (b.type ?? '').endsWith('_text')))
+        .map((b) => b.text)
+        .join('');
+}
+/** Reasoning effort from a Codex `turn_context` payload: top-level `effort`, else the nested collaboration setting. */
+function codexEffortOf(payload) {
+    const top = payload?.effort;
+    if (typeof top === 'string' && top.trim())
+        return top.trim();
+    const re = payload?.collaboration_mode?.settings?.reasoning_effort;
+    return typeof re === 'string' && re.trim() ? re.trim() : null;
+}
 // ---- Claude: ~/.claude/projects/<encoded-workdir>/<sessionId>.jsonl ----
 /** Claude encodes a workdir into a project dir name by replacing non-alphanumerics with '-'. */
 export function encodeClaudeProjectDir(workdir) {
@@ -40,52 +87,80 @@ function claudeText(content) {
     }
     return parts.join(' ');
 }
-function readClaudeHead(filePath, size) {
-    let title = null;
-    let model = null;
-    let lastUser = null;
-    let lastAssistant = null;
-    let turns = 0;
-    let head = '';
-    try {
-        const fd = fs.openSync(filePath, 'r');
-        const buf = Buffer.alloc(Math.min(256 * 1024, Math.max(65536, size)));
-        const n = fs.readSync(fd, buf, 0, buf.length, 0);
-        fs.closeSync(fd);
-        head = buf.toString('utf8', 0, n);
-    }
-    catch {
-        return { title: null, model: null, preview: null, turns: 0 };
-    }
-    for (const line of head.split('\n')) {
-        if (!line || line[0] !== '{')
-            continue;
-        let ev;
+const claudeMetaCache = new Map();
+function readClaudeMeta(filePath, stat) {
+    return memoized(claudeMetaCache, filePath, stat, () => {
+        const size = stat.size;
+        let title = null;
+        let headModel = null;
+        let lastUser = null;
+        let headAssistant = null;
+        let turns = 0;
+        let head = '';
         try {
-            ev = JSON.parse(line);
+            head = readRegion(filePath, 0, Math.min(HEAD_BYTES, Math.max(65536, size)));
         }
         catch {
-            continue;
+            return { title: null, model: null, preview: null, turns: 0 };
         }
-        if (ev.type === 'user' && ev.isMeta !== true) {
-            const text = claudeText(ev.message?.content).trim();
-            if (text && !text.startsWith('<') && !text.startsWith('[Image:')) {
-                if (!title)
-                    title = cleanTitle(text);
-                lastUser = text;
-                turns++;
+        for (const line of head.split('\n')) {
+            if (!line || line[0] !== '{')
+                continue;
+            let ev;
+            try {
+                ev = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (ev.type === 'user' && ev.isMeta !== true) {
+                const text = claudeText(ev.message?.content).trim();
+                if (text && !text.startsWith('<') && !text.startsWith('[Image:')) {
+                    if (!title)
+                        title = cleanTitle(text);
+                    lastUser = text;
+                    turns++;
+                }
+            }
+            else if (ev.type === 'assistant') {
+                if (!headModel && ev.message?.model && ev.message.model !== '<synthetic>')
+                    headModel = ev.message.model;
+                const text = claudeText(ev.message?.content).trim();
+                if (text)
+                    headAssistant = text;
             }
         }
-        else if (ev.type === 'assistant') {
-            if (!model && ev.message?.model && ev.message.model !== '<synthetic>')
-                model = ev.message.model;
-            const text = claudeText(ev.message?.content).trim();
-            if (text)
-                lastAssistant = text;
+        // The LATEST reply lives at the end of a long transcript, not in the head — read a bounded tail
+        // slice for an accurate preview (and the most recent model). Skipped when the file already fits
+        // in the head window (then the head scan above already saw the whole thing).
+        let tailAssistant = null;
+        let tailModel = null;
+        if (size > HEAD_BYTES) {
+            try {
+                for (const line of readRegion(filePath, size - TAIL_BYTES, TAIL_BYTES).split('\n')) {
+                    if (!line || line[0] !== '{')
+                        continue;
+                    let ev;
+                    try {
+                        ev = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (ev.type !== 'assistant')
+                        continue;
+                    const text = claudeText(ev.message?.content).trim();
+                    if (text)
+                        tailAssistant = text;
+                    if (ev.message?.model && ev.message.model !== '<synthetic>')
+                        tailModel = ev.message.model;
+                }
+            }
+            catch { /* keep head-derived values */ }
         }
-    }
-    const preview = cleanTitle(lastAssistant || lastUser, 200);
-    return { title, model, preview, turns };
+        const preview = cleanTitle(tailAssistant || headAssistant || lastUser, 200);
+        return { title, model: tailModel || headModel, preview, turns };
+    });
 }
 export function discoverClaudeNativeSessions(workdir, opts = {}) {
     const home = homeOf(opts);
@@ -111,7 +186,7 @@ export function discoverClaudeNativeSessions(workdir, opts = {}) {
     const selected = typeof opts.limit === 'number' ? files.slice(0, Math.max(0, opts.limit)) : files;
     const now = Date.now();
     return selected.map(({ sessionId, filePath, stat }) => {
-        const { title, model, preview, turns } = readClaudeHead(filePath, stat.size);
+        const { title, model, preview, turns } = readClaudeMeta(filePath, stat);
         return {
             sessionId,
             title,
@@ -148,6 +223,18 @@ function loadCodexTitleIndex(home) {
     }
     return map;
 }
+// A rollout's `session_meta` (id/cwd/timestamp) is written once at creation and never changes, so its
+// parsed head is cached by path permanently — the per-list cwd filter then costs one 8 KB read per file
+// only the FIRST time it is ever seen, not on every list call.
+const codexHeadCache = new Map();
+function readCodexHeadCached(filePath) {
+    const hit = codexHeadCache.get(filePath);
+    if (hit !== undefined)
+        return hit;
+    const v = readCodexHead(filePath);
+    codexHeadCache.set(filePath, v);
+    return v;
+}
 function readCodexHead(filePath) {
     try {
         const fd = fs.openSync(filePath, 'r');
@@ -173,6 +260,81 @@ function readCodexHead(filePath) {
         return null;
     }
 }
+const codexMetaCache = new Map();
+/**
+ * Bounded per-row metadata for a Codex rollout: the first user prompt (title fallback when the thread
+ * has no index name) from a HEAD slice, and the latest reply + last model/effort from a TAIL slice.
+ * Memoized by (mtime,size); never reads the whole file.
+ */
+function readCodexBoundedMeta(filePath, stat) {
+    return memoized(codexMetaCache, filePath, stat, () => {
+        let firstPrompt = null;
+        let firstAny = null;
+        let preview = null;
+        let model = null;
+        let effort = null;
+        try {
+            // HEAD: the first real user turn (skip a leading <handover> injected by an agent switch).
+            for (const line of readRegion(filePath, 0, Math.min(HEAD_BYTES, stat.size)).split('\n')) {
+                const t = line.trim();
+                if (!t || t[0] !== '{' || !t.includes('user_message'))
+                    continue;
+                let ev;
+                try {
+                    ev = JSON.parse(t);
+                }
+                catch {
+                    continue;
+                }
+                if (ev.type !== 'event_msg' || ev.payload?.type !== 'user_message')
+                    continue;
+                const text = String(ev.payload.message ?? '').trim();
+                if (!text)
+                    continue;
+                if (!firstAny)
+                    firstAny = text;
+                if (!String(text).toLowerCase().startsWith('<handover')) {
+                    firstPrompt = text;
+                    break;
+                }
+            }
+        }
+        catch { /* best-effort */ }
+        try {
+            // TAIL: the latest assistant reply + last turn_context (model/effort).
+            const start = Math.max(0, stat.size - TAIL_BYTES);
+            for (const line of readRegion(filePath, start, Math.min(TAIL_BYTES, stat.size)).split('\n')) {
+                const t = line.trim();
+                if (!t || t[0] !== '{')
+                    continue;
+                let ev;
+                try {
+                    ev = JSON.parse(t);
+                }
+                catch {
+                    continue;
+                }
+                const p = ev.payload;
+                if (!p)
+                    continue;
+                if (ev.type === 'turn_context') {
+                    if (typeof p.model === 'string' && p.model.trim())
+                        model = p.model.trim();
+                    const e = codexEffortOf(p);
+                    if (e)
+                        effort = e;
+                }
+                else if (ev.type === 'response_item' && p.type === 'message' && p.role === 'assistant') {
+                    const text = codexText(p.content).trim();
+                    if (text)
+                        preview = text;
+                }
+            }
+        }
+        catch { /* best-effort */ }
+        return { firstPrompt: cleanTitle(firstPrompt ?? firstAny), preview: cleanTitle(preview, 200), model, effort };
+    });
+}
 export function discoverCodexNativeSessions(workdir, opts = {}) {
     const home = homeOf(opts);
     const sessionsDir = path.join(home, '.codex', 'sessions');
@@ -206,7 +368,7 @@ export function discoverCodexNativeSessions(workdir, opts = {}) {
     const out = [];
     const seen = new Set();
     for (const { filePath, stat } of files) {
-        const meta = readCodexHead(filePath);
+        const meta = readCodexHeadCached(filePath);
         if (!meta || meta.isSubagent || path.resolve(meta.cwd) !== resolvedWorkdir)
             continue;
         if (seen.has(meta.sessionId))
@@ -214,12 +376,17 @@ export function discoverCodexNativeSessions(workdir, opts = {}) {
         seen.add(meta.sessionId);
         const idx = titleIndex.get(meta.sessionId);
         const updatedAt = idx?.updatedAt || stat.mtime.toISOString();
+        // Only files that passed the cwd/subagent filter above pay for the bounded head+tail read (first
+        // prompt / preview / model / effort) — scoped to THIS workdir's own rollouts, and memoized per file.
+        const bounded = readCodexBoundedMeta(filePath, stat);
         out.push({
             sessionId: meta.sessionId,
-            title: cleanTitle(idx?.threadName || null),
-            preview: null,
+            // The agent's own thread name wins; otherwise fall back to the first prompt so the row is named + searchable.
+            title: cleanTitle(idx?.threadName || null) ?? bounded.firstPrompt,
+            preview: bounded.preview,
             cwd: meta.cwd,
-            model: null,
+            model: bounded.model,
+            effort: bounded.effort,
             createdAt: meta.timestamp || stat.birthtime.toISOString(),
             updatedAt,
             running: Date.now() - Date.parse(updatedAt) < threshold,

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

@@ -0,0 +1,45 @@
+export type RpcMsg = {
+    jsonrpc?: string;
+    id?: number | string;
+    method?: string;
+    params?: any;
+    result?: any;
+    error?: any;
+};
+/** Throw from an onRequest handler to answer with a specific JSON-RPC error code. */
+export declare class RpcError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+}
+export interface StdioRpcOptions {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    label?: string;
+}
+export declare class StdioRpcClient {
+    private readonly opts;
+    private proc;
+    private nextId;
+    private readonly pending;
+    private notifyCb?;
+    private requestCb?;
+    private readonly stderrTail;
+    private readonly label;
+    constructor(opts: StdioRpcOptions);
+    onNotification(cb: (method: string, params: any) => void): void;
+    /** Serve peer->client requests. Throw RpcError for a coded error; anything else answers -32603. */
+    onRequest(cb: (method: string, params: any, id: number | string) => any | Promise<any>): void;
+    /** Rolling tail of the process' stderr — startup/crash diagnostics. */
+    stderrText(): string;
+    start(): boolean;
+    private onLine;
+    private handleRequest;
+    request(method: string, params?: any, timeoutMs?: number): Promise<RpcMsg>;
+    notify(method: string, params?: any): void;
+    private respond;
+    private respondError;
+    private write;
+    kill(): void;
+}

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

@@ -0,0 +1,130 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+/** Throw from an onRequest handler to answer with a specific JSON-RPC error code. */
+export class RpcError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+const STDERR_TAIL_LINES = 20;
+export class StdioRpcClient {
+    opts;
+    proc = null;
+    nextId = 1;
+    pending = new Map();
+    notifyCb;
+    requestCb;
+    stderrTail = [];
+    label;
+    constructor(opts) {
+        this.opts = opts;
+        this.label = opts.label || opts.command;
+    }
+    onNotification(cb) { this.notifyCb = cb; }
+    /** Serve peer->client requests. Throw RpcError for a coded error; anything else answers -32603. */
+    onRequest(cb) { this.requestCb = cb; }
+    /** Rolling tail of the process' stderr — startup/crash diagnostics. */
+    stderrText() { return this.stderrTail.join('\n'); }
+    start() {
+        try {
+            this.proc = spawn(this.opts.command, this.opts.args, {
+                cwd: this.opts.cwd,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: this.opts.env ? { ...process.env, ...this.opts.env } : process.env,
+            });
+        }
+        catch {
+            return false;
+        }
+        const rl = createInterface({ input: this.proc.stdout, crlfDelay: Infinity });
+        rl.on('line', (line) => this.onLine(line));
+        // Always drain stderr (an unread pipe backpressures the child) and keep a tail for errors.
+        this.proc.stderr.on('data', (chunk) => {
+            for (const ln of chunk.toString('utf8').split('\n')) {
+                const t = ln.trim();
+                if (!t)
+                    continue;
+                this.stderrTail.push(t.slice(0, 240));
+                if (this.stderrTail.length > STDERR_TAIL_LINES)
+                    this.stderrTail.shift();
+            }
+        });
+        this.proc.on('close', () => {
+            for (const cb of this.pending.values())
+                cb({ error: { message: `${this.label} exited` } });
+            this.pending.clear();
+        });
+        this.proc.on('error', () => { });
+        return true;
+    }
+    onLine(line) {
+        const t = line.trim();
+        if (!t)
+            return;
+        let m;
+        try {
+            m = JSON.parse(t);
+        }
+        catch {
+            return;
+        } // non-JSON stdout noise
+        if (m.method && m.id != null) {
+            void this.handleRequest(m);
+            return;
+        } // peer -> client request
+        if (m.id != null) { // response to one of our requests
+            const cb = this.pending.get(m.id);
+            if (cb) {
+                this.pending.delete(m.id);
+                cb(m);
+            }
+            return;
+        }
+        if (m.method)
+            this.notifyCb?.(m.method, m.params ?? {}); // notification
+    }
+    async handleRequest(m) {
+        const id = m.id;
+        if (!this.requestCb) {
+            this.respondError(id, -32601, `Method not implemented: ${m.method}`);
+            return;
+        }
+        try {
+            const result = await this.requestCb(m.method, m.params ?? {}, id);
+            this.respond(id, result ?? null);
+        }
+        catch (e) {
+            const code = e instanceof RpcError ? e.code : -32603;
+            this.respondError(id, code, e?.message || 'handler error');
+        }
+    }
+    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: `${this.label} '${method}' timed out` } }); }, timeoutMs);
+            this.pending.set(id, (m) => { clearTimeout(timer); resolve(m); });
+            this.write({ jsonrpc: '2.0', id, method, params });
+        });
+    }
+    notify(method, params) { this.write({ jsonrpc: '2.0', method, params }); }
+    respond(id, result) { this.write({ jsonrpc: '2.0', id, result }); }
+    respondError(id, code, message) { this.write({ jsonrpc: '2.0', id, error: { code, message } }); }
+    write(msg) {
+        if (!this.proc || this.proc.killed)
+            return;
+        try {
+            this.proc.stdin.write(JSON.stringify(msg) + '\n');
+        }
+        catch { /* stream closed */ }
+    }
+    kill() { try {
+        this.proc?.kill('SIGTERM');
+    }
+    catch { /* ignore */ } this.proc = null; }
+}

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

@@ -0,0 +1,21 @@
+import type { ChildProcess } from 'node:child_process';
+/** Stateful newline splitter for a child process' stdout: feed chunks, get complete lines. */
+export declare function createLineBuffer(): (chunk: Buffer | string) => string[];
+/** Parse one ndjson line; undefined for blank lines / non-JSON noise. */
+export declare function parseJsonLine(line: string): any | undefined;
+/**
+ * Run `fn` when the signal aborts (immediately if it already has). Returns an
+ * unsubscribe for drivers that must detach the handler when the turn settles.
+ */
+export declare function wireAbort(signal: AbortSignal, fn: () => void): () => void;
+/** SIGTERM a child, swallowing the already-dead race. */
+export declare function sigterm(proc: ChildProcess | null | undefined): void;
+/** Mime type when the file is an inlineable image, else null. */
+export declare function imageMimeForFile(filePath: string): string | null;
+/** The text note substituted for a non-image attachment. */
+export declare function attachedFileNote(filePath: string): string;
+/**
+ * Context-window occupancy as a display percent (one decimal, capped at 99.9).
+ * Pass `used` as null when the caller wants "no data" rather than 0%.
+ */
+export declare function contextPercent(used: number | null | undefined, window: number | null | undefined): number | null;

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

@@ -0,0 +1,66 @@
+import { extname } from 'node:path';
+// Driver-internal helpers shared by the concrete drivers (claude/codex/gemini/acp).
+// NOT part of the public API — nothing here is re-exported by any barrel. Each helper
+// exists because the same code appeared verbatim in 3+ drivers.
+/** Stateful newline splitter for a child process' stdout: feed chunks, get complete lines. */
+export function createLineBuffer() {
+    let buf = '';
+    return (chunk) => {
+        buf += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+        const lines = buf.split('\n');
+        buf = lines.pop() || '';
+        return lines;
+    };
+}
+/** Parse one ndjson line; undefined for blank lines / non-JSON noise. */
+export function parseJsonLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return undefined;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Run `fn` when the signal aborts (immediately if it already has). Returns an
+ * unsubscribe for drivers that must detach the handler when the turn settles.
+ */
+export function wireAbort(signal, fn) {
+    if (signal.aborted) {
+        fn();
+        return () => { };
+    }
+    signal.addEventListener('abort', fn, { once: true });
+    return () => signal.removeEventListener('abort', fn);
+}
+/** SIGTERM a child, swallowing the already-dead race. */
+export function sigterm(proc) {
+    try {
+        proc?.kill('SIGTERM');
+    }
+    catch { /* ignore */ }
+}
+// Attachment vocabulary: every driver inlines the same image formats (the Anthropic
+// vision set, which the others accept too) and notes non-image files the same way.
+const IMAGE_MIME_BY_EXT = {
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif', '.webp': 'image/webp',
+};
+/** Mime type when the file is an inlineable image, else null. */
+export function imageMimeForFile(filePath) {
+    return IMAGE_MIME_BY_EXT[extname(filePath).toLowerCase()] ?? null;
+}
+/** The text note substituted for a non-image attachment. */
+export function attachedFileNote(filePath) {
+    return `[Attached file: ${filePath}]`;
+}
+/**
+ * Context-window occupancy as a display percent (one decimal, capped at 99.9).
+ * Pass `used` as null when the caller wants "no data" rather than 0%.
+ */
+export function contextPercent(used, window) {
+    return window && used != null ? Math.min(99.9, Math.round((used / window) * 1000) / 10) : null;
+}

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

@@ -9,13 +9,14 @@ export type { SessionStore, CoreSessionRecord, ModelResolver, ModelInjection, To
 export type { LoomIO, PromptInput, Surface, SurfaceCapabilities, Plugin, SpawnContribution, } from './contracts/surface.js';
 export { FsSessionStore, NullModelResolver, NoopToolProvider, PassthroughSystemPromptBuilder, AutoCancelInteractionHandler, DeferToTerminalInteractionHandler, NoopCatalog, defaultBaseDir, } from './ports/defaults.js';
 export { EchoDriver } from './drivers/echo.js';
-export { ClaudeDriver, isTerminalTaskStatus, trackClaudeBackgroundTask, pendingClaudeBackgroundTasks, markClaudeTaskNotificationTerminal, decideClaudeResultSettle, claudeBgHoldCapMs, claudeBgAgentHoldCapMs, claudeTurnHasAgentBackground, claudeBgHoldRecheckMs, claudeBgSettleQuietMs, type ClaudeResultSettleDecision, claudeModelStallMs, claudeUserEventHasToolResult, handleClaudeEvent, claudeTurnEndedDangling, claudeTruncatedRecoveryEnabled, CLAUDE_TRUNCATED_RECOVERY_PROMPT, isClaudeSyntheticResumeNoise, claudeProducedRealOutput, claudeResumeNoopRetryLimit, } from './drivers/claude.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 { discoverClaudeNativeSessions, discoverCodexNativeSessions, discoverGeminiNativeSessions, encodeClaudeProjectDir, type DiscoverOptions, } from './drivers/native.js';
 export * from './workspace/index.js';
 export * from './accounts.js';
 export * from './protocol/index.js';