pikiloom 0.4.60 → 0.4.62

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

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
-import { discoverGeminiNativeSessions } from '../workspace/native.js';
+import { discoverGeminiNativeSessions } from './native.js';
+import { createLineBuffer, parseJsonLine, sigterm, wireAbort } from './shared.js';
 // 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 {
@@ -21,7 +22,7 @@ export class GeminiDriver {
         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 s = { text: '', sessionId: input.sessionId ?? null, input: null, output: null, cached: null, stopReason: null, error: null };
         const tools = new Map();
         return new Promise((resolve) => {
             let child;
@@ -32,32 +33,14 @@ export class GeminiDriver {
                 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 = '';
+            wireAbort(ctx.signal, () => sigterm(child));
+            const nextLines = createLineBuffer();
             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);
+                for (const line of nextLines(chunk)) {
+                    const ev = parseJsonLine(line);
+                    if (ev !== undefined)
+                        parseGeminiEvent(ev, s, tools, ctx.emit);
                 }
             });
             child.stderr.on('data', (c) => { stderr += c.toString('utf8'); });
@@ -92,7 +75,6 @@ export function parseGeminiEvent(ev, s, tools, emit) {
             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') {

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

@@ -1,5 +1,4 @@
-import { AcpDriver, applyAcpUpdate } from './acp.js';
+import { AcpDriver } from './acp.js';
 export declare class HermesDriver extends AcpDriver {
     constructor(bin?: string);
 }
-export declare const applyHermesUpdate: typeof applyAcpUpdate;

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();
 }

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, } 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';

package/packages/kernel/dist/index.js

@@ -8,6 +8,10 @@
 //   await loom.start()
 //
 // pikiloom itself is just a consumer of this package.
+//
+// This barrel IS the public API (pinned by test/api-surface.test.ts). Driver-internal
+// parser/settle helpers are exported by their modules for white-box tests but are
+// deliberately NOT re-exported here.
 export { createLoom } from './runtime/loom.js';
 export { Hub } from './runtime/hub.js';
 export { SessionRunner } from './runtime/session-runner.js';
@@ -19,16 +23,20 @@ export { attachTui } from './runtime/tui.js';
 export { FsSessionStore, NullModelResolver, NoopToolProvider, PassthroughSystemPromptBuilder, AutoCancelInteractionHandler, DeferToTerminalInteractionHandler, NoopCatalog, defaultBaseDir, } from './ports/defaults.js';
 // Drivers & surfaces (also available via subpath exports)
 export { EchoDriver } from './drivers/echo.js';
-export { ClaudeDriver, isTerminalTaskStatus, trackClaudeBackgroundTask, pendingClaudeBackgroundTasks, markClaudeTaskNotificationTerminal, decideClaudeResultSettle, claudeBgHoldCapMs, claudeBgAgentHoldCapMs, claudeTurnHasAgentBackground, claudeBgHoldRecheckMs, claudeBgSettleQuietMs, claudeModelStallMs, claudeUserEventHasToolResult, handleClaudeEvent, claudeTurnEndedDangling, claudeTruncatedRecoveryEnabled, CLAUDE_TRUNCATED_RECOVERY_PROMPT, } from './drivers/claude.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';
+// Native-session discovery: pure readers of each agent CLI's own transcript store
+// (driver-axis knowledge; drivers implement listNativeSessions with these).
+export { discoverClaudeNativeSessions, discoverCodexNativeSessions, discoverGeminiNativeSessions, encodeClaudeProjectDir, } from './drivers/native.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)
+// Multi-account: which env var carries an agent's auth token, so an app can inject a
+// selected account's token per spawn (see accounts.ts for the design notes).
 export * from './accounts.js';
 // Protocol (the wire vocabulary; shared with transports)
 export * from './protocol/index.js';

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

@@ -101,6 +101,11 @@ export interface SessionMeta {
     phase?: SessionPhase;
     updatedAt?: number;
 }
+export declare function makeSessionKey(agent: string, sessionId: string): string;
+export declare function splitSessionKey(sessionKey: string): {
+    agent: string;
+    sessionId: string;
+};
 export interface SnapshotPatch {
     full?: UniversalSnapshot;
     appendText?: string;

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

@@ -2,6 +2,16 @@
 // This is the SSOT shape: a driver-agnostic, accumulating snapshot of one session,
 // plus a small set of control verbs. Ported from pikiloom's pikichannel protocol.
 export const PROTOCOL_VERSION = 1;
+// ---- Session keys ----
+// A sessionKey is `${agent}:${sessionId}` — the composite id shared by the runtime, every
+// store, and every terminal. These two helpers ARE that contract; nothing else parses it.
+export function makeSessionKey(agent, sessionId) {
+    return `${agent}:${sessionId}`;
+}
+export function splitSessionKey(sessionKey) {
+    const i = sessionKey.indexOf(':');
+    return i < 0 ? { agent: '', sessionId: sessionKey } : { agent: sessionKey.slice(0, i), sessionId: sessionKey.slice(i + 1) };
+}
 export function emptySnapshot() {
     return { phase: 'idle', updatedAt: 0 };
 }

package/packages/kernel/dist/runtime/hub.js

@@ -1,10 +1,6 @@
 import { randomUUID } from 'node:crypto';
-import { diffSnapshot, emptySnapshot, } from '../protocol/index.js';
+import { diffSnapshot, emptySnapshot, makeSessionKey, splitSessionKey, } from '../protocol/index.js';
 import { SessionRunner } from './session-runner.js';
-function splitKey(sessionKey) {
-    const i = sessionKey.indexOf(':');
-    return i < 0 ? { agent: '', sessionId: sessionKey } : { agent: sessionKey.slice(0, i), sessionId: sessionKey.slice(i + 1) };
-}
 export class Hub {
     deps;
     sessions = new Map();
@@ -57,12 +53,12 @@ export class Hub {
         if (!driver)
             throw new Error(`No driver registered for agent "${agent}"`);
         const workdir = input.workdir || this.deps.workdir;
-        const resumeId = input.sessionKey ? splitKey(input.sessionKey).sessionId : null;
+        const resumeId = input.sessionKey ? splitSessionKey(input.sessionKey).sessionId : null;
         const preExisted = resumeId ? !!(await this.deps.sessionStore.get(agent, resumeId)) : false;
         const { sessionId, workspacePath } = await this.deps.sessionStore.ensure(agent, {
             sessionId: resumeId, workdir, title: input.prompt.slice(0, 80),
         });
-        const sessionKey = `${agent}:${sessionId}`;
+        const sessionKey = makeSessionKey(agent, sessionId);
         const taskId = randomUUID();
         const runner = new SessionRunner(sessionKey, agent, taskId, (snap, seq) => this.onRunnerUpdate(sessionKey, snap, seq), this.deps.interactionHandler);
         this.runnersByTask.set(taskId, runner);
@@ -320,7 +316,7 @@ export class Hub {
         return e ? { snapshot: e.snapshot, seq: e.seq } : null;
     }
     async getHistory(sessionKey) {
-        const { agent, sessionId } = splitKey(sessionKey);
+        const { agent, sessionId } = splitSessionKey(sessionKey);
         if (!agent || !this.deps.sessionStore.history)
             return [];
         try {

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

@@ -1,5 +1,4 @@
 export { resolveLoomPaths, normalizeStateDirName, type LoomPaths, type LoomScope } from './paths.js';
-export { discoverClaudeNativeSessions, discoverCodexNativeSessions, discoverGeminiNativeSessions, encodeClaudeProjectDir, NATIVE_SESSION_RUNNING_THRESHOLD_MS, type DiscoverOptions, type NativeSessionInfo, } from './native.js';
 export { SessionsManager, type ManagedSessionInfo, type SessionSource, type ListSessionsOptions, type SearchSessionsOptions, type SessionsManagerDeps, } from './sessions.js';
-export { SkillsManager, ensureDirSymlink, type SkillInfo, type SkillSearchResult, type SkillsManagerOptions, } from './skills.js';
+export { SkillsManager, ensureDirSymlink, parseSkillMeta, type SkillInfo, type SkillMeta, type SkillSearchResult, type SkillsManagerOptions, } from './skills.js';
 export { McpRegistry, type McpCatalogEntry, type McpSearchResult, type McpRegistryOptions, } from './mcp.js';

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

@@ -1,7 +1,8 @@
 // Workspace subsystem: the unified top-level directory + session/skill/mcp management that
 // a consuming app gets "for free" off createLoom() (exposed as loom.paths/sessions/skills/mcp).
+// (Native-session discovery lives with the drivers — drivers/native.ts — because knowing each
+// agent CLI's on-disk transcript format is driver-axis knowledge.)
 export { resolveLoomPaths, normalizeStateDirName } from './paths.js';
-export { discoverClaudeNativeSessions, discoverCodexNativeSessions, discoverGeminiNativeSessions, encodeClaudeProjectDir, NATIVE_SESSION_RUNNING_THRESHOLD_MS, } from './native.js';
 export { SessionsManager, } from './sessions.js';
-export { SkillsManager, ensureDirSymlink, } from './skills.js';
+export { SkillsManager, ensureDirSymlink, parseSkillMeta, } from './skills.js';
 export { McpRegistry, } from './mcp.js';

package/packages/kernel/dist/workspace/mcp.js

@@ -1,3 +1,4 @@
+import { searchNpmPackages } from './npm-search.js';
 const BUILTIN_RECOMMENDED = [
     { id: 'filesystem', name: 'Filesystem', description: 'Read/write files under allowed directories.', category: 'core', transport: { type: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem'] }, homepage: 'https://github.com/modelcontextprotocol/servers' },
     { id: 'github', name: 'GitHub', description: 'GitHub repos, issues, and PRs.', category: 'dev', brand: 'github', transport: { type: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-github'] }, envKeys: ['GITHUB_PERSONAL_ACCESS_TOKEN'], homepage: 'https://github.com/modelcontextprotocol/servers' },
@@ -57,22 +58,11 @@ export class McpRegistry {
         }
         // 2) npm fallback.
         try {
-            const url = `https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(`mcp server ${q}`.trim())}&size=${n}`;
-            const res = await fetchImpl(url, { headers: { accept: 'application/json' } });
-            if (!res.ok)
-                return [];
-            const data = await res.json();
-            const objects = Array.isArray(data?.objects) ? data.objects : [];
-            return objects.map((o) => {
-                const pkg = o?.package ?? {};
-                return {
-                    name: String(pkg.name ?? ''),
-                    description: pkg.description ?? null,
-                    source: 'npm',
-                    npmPackage: pkg.name ?? null,
-                    homepage: pkg.links?.homepage ?? pkg.links?.npm ?? null,
-                };
-            }).filter(s => s.name).slice(0, n);
+            const hits = await searchNpmPackages(`mcp server ${q}`.trim(), n, fetchImpl);
+            return hits.map(h => ({
+                name: h.name, description: h.description, source: 'npm',
+                npmPackage: h.name, homepage: h.homepage,
+            })).slice(0, n);
         }
         catch (e) {
             this.log?.(`[mcp] npm search failed: ${e?.message || e}`);

package/packages/kernel/dist/workspace/npm-search.d.ts

@@ -0,0 +1,9 @@
+export interface NpmPackageHit {
+    name: string;
+    description: string | null;
+    homepage: string | null;
+    author: string | null;
+    version: string | null;
+}
+/** Query registry.npmjs.org's search endpoint. [] on non-OK; throws on network failure. */
+export declare function searchNpmPackages(text: string, size: number, fetchImpl: typeof fetch): Promise<NpmPackageHit[]>;

package/packages/kernel/dist/workspace/npm-search.js

@@ -0,0 +1,21 @@
+// Shared npm-registry search used by SkillsManager.search and McpRegistry's npm fallback.
+// Workspace-internal — not exported by any barrel.
+/** Query registry.npmjs.org's search endpoint. [] on non-OK; throws on network failure. */
+export async function searchNpmPackages(text, size, fetchImpl) {
+    const url = `https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(text)}&size=${size}`;
+    const res = await fetchImpl(url, { headers: { accept: 'application/json' } });
+    if (!res.ok)
+        return [];
+    const data = await res.json();
+    const objects = Array.isArray(data?.objects) ? data.objects : [];
+    return objects.map((o) => {
+        const pkg = o?.package ?? {};
+        return {
+            name: String(pkg.name ?? ''),
+            description: pkg.description ?? null,
+            homepage: pkg.links?.homepage ?? pkg.links?.npm ?? null,
+            author: pkg.publisher?.username ?? pkg.author?.name ?? null,
+            version: pkg.version ?? null,
+        };
+    }).filter(h => h.name);
+}