@pikiloom/kernel 0.3.5 → 0.3.7

package/dist/contracts/driver.d.ts

@@ -88,6 +88,7 @@ export interface NativeSessionInfo {
     preview: string | null;
     cwd: string | null;
     model: string | null;
+    effort?: string | null;
     createdAt: string | null;
     updatedAt: string | null;
     running: boolean;

package/dist/drivers/codex.d.ts

@@ -1,9 +1,12 @@
 import type { AgentDriver, AgentTurnInput, DriverContext, DriverEvent, DriverResult, TuiInput, TuiSpec, NativeSessionInfo } from '../contracts/driver.js';
+import type { UniversalToolCall } from '../protocol/index.js';
 export declare function codexToolSummary(item: any): {
     id: string;
     name: string;
     summary: string;
 } | null;
+/** Project one app-server item into the kernel's rich, expandable tool-call shape. */
+export declare function codexToolCall(item: any, fallbackStatus: UniversalToolCall['status']): UniversalToolCall | null;
 export interface CodexContentState {
     text: string;
     reasoning: string;

package/dist/drivers/codex.js

@@ -34,6 +34,89 @@ const CODEX_TOOL_CALL_TYPES = new Set(['dynamicToolCall', 'mcpToolCall', 'collab
 // Field-less placeholder summaries — a completed item with only one of these never overrides
 // a more specific summary cached at item/started.
 const CODEX_GENERIC_TOOL_SUMMARIES = new Set(['Search web', 'Run shell command', 'Edit files', 'Use tool']);
+const CODEX_TOOL_INPUT_MAX = 4 * 1024;
+const CODEX_TOOL_RESULT_MAX = 12 * 1024;
+function codexToolText(value, max) {
+    if (value == null)
+        return null;
+    let text;
+    if (typeof value === 'string')
+        text = value;
+    else {
+        try {
+            text = JSON.stringify(value, null, 2);
+        }
+        catch {
+            text = String(value);
+        }
+    }
+    text = text.replace(/\r\n/g, '\n').trim();
+    if (!text)
+        return null;
+    return text.length <= max ? text : `${text.slice(0, max).trimEnd()}\n… (truncated)`;
+}
+function codexToolInput(item) {
+    switch (item?.type) {
+        case 'commandExecution': {
+            const command = Array.isArray(item.command) ? item.command.join(' ') : item.command;
+            if (!command)
+                return null;
+            const detail = { command };
+            if (typeof item.cwd === 'string' && item.cwd.trim())
+                detail.cwd = item.cwd;
+            return codexToolText(detail, CODEX_TOOL_INPUT_MAX);
+        }
+        case 'fileChange':
+        case 'patch':
+            return codexToolText(item.changes ?? item.patch ?? item.diff, CODEX_TOOL_INPUT_MAX);
+        case 'mcpToolCall':
+        case 'dynamicToolCall':
+            return codexToolText(item.arguments ?? item.input, CODEX_TOOL_INPUT_MAX);
+        case 'collabAgentToolCall':
+            return codexToolText({
+                prompt: item.prompt ?? undefined,
+                model: item.model ?? undefined,
+                reasoningEffort: item.reasoningEffort ?? item.reasoning_effort ?? undefined,
+                receiverThreadIds: item.receiverThreadIds ?? item.receiver_thread_ids ?? undefined,
+            }, CODEX_TOOL_INPUT_MAX);
+        case 'webSearch':
+            return codexToolText(item.action ?? item.query, CODEX_TOOL_INPUT_MAX);
+        default:
+            return null;
+    }
+}
+function codexToolResult(item) {
+    if (item?.type === 'commandExecution') {
+        const output = codexToolText(item.aggregatedOutput ?? item.aggregated_output, CODEX_TOOL_RESULT_MAX);
+        const exitCode = item.exitCode ?? item.exit_code;
+        if (output && typeof exitCode === 'number' && exitCode !== 0)
+            return `${output}\n\n(exit code ${exitCode})`;
+        if (output)
+            return output;
+        return typeof exitCode === 'number' && exitCode !== 0 ? `exit code ${exitCode}` : null;
+    }
+    if (item?.type === 'mcpToolCall') {
+        const error = item.error?.message ?? item.error;
+        if (error)
+            return codexToolText(error, CODEX_TOOL_RESULT_MAX);
+        return codexToolText(item.result, CODEX_TOOL_RESULT_MAX);
+    }
+    if (item?.type === 'dynamicToolCall') {
+        return codexToolText(item.contentItems ?? item.content_items, CODEX_TOOL_RESULT_MAX);
+    }
+    if (item?.type === 'collabAgentToolCall') {
+        return codexToolText(item.agentsStates ?? item.agents_states, CODEX_TOOL_RESULT_MAX);
+    }
+    return null;
+}
+function codexToolStatus(item, fallback) {
+    const raw = String(item?.status || '').toLowerCase();
+    if (raw === 'failed' || raw === 'declined' || item?.success === false || item?.error)
+        return 'failed';
+    if (raw === 'completed' || raw === 'done' || item?.success === true)
+        return 'done';
+    return fallback;
+}
 export function codexToolSummary(item) {
     const id = String(item?.id || '');
     if (!id)
@@ -66,6 +149,27 @@ export function codexToolSummary(item) {
     }
     return null;
 }
+/** Project one app-server item into the kernel's rich, expandable tool-call shape. */
+export function codexToolCall(item, fallbackStatus) {
+    const base = codexToolSummary(item);
+    if (!base)
+        return null;
+    return {
+        ...base,
+        input: codexToolInput(item),
+        result: codexToolResult(item),
+        status: codexToolStatus(item, fallbackStatus),
+    };
+}
+function appendCodexToolOutput(previous, delta) {
+    if (typeof delta !== 'string' || !delta)
+        return previous ?? null;
+    const next = `${previous ?? ''}${delta}`.replace(/\r\n/g, '\n');
+    if (next.length <= CODEX_TOOL_RESULT_MAX)
+        return next;
+    const marker = '… (earlier output truncated)\n';
+    return marker + next.slice(-(CODEX_TOOL_RESULT_MAX - marker.length));
+}
 // codex `item/tool/requestUserInput` params -> a normalized UniversalInteraction
 // (faithful to the legacy codex driver's toAgentInteraction shape).
 function codexUserInputToInteraction(params, promptId) {
@@ -153,7 +257,7 @@ export class CodexDriver {
         const srv = new StdioRpcClient({ command: this.bin, args, env: input.env, label: 'codex app-server' });
         const state = { text: '', reasoning: '', streamedReasoning: false, msgs: [], thinkParts: [], sessionId: input.sessionId ?? null, input: null, output: null, cached: null, contextUsed: null, contextWindow: null, status: null, error: null, turnId: null };
         const phases = new Map();
-        const toolSummaries = new Map();
+        const toolCalls = new Map();
         const deltaItems = new Set();
         let lastTextItemId = null;
         let steerRegistered = false;
@@ -218,13 +322,35 @@ export class CodexDriver {
                         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' } });
+                        const call = codexToolCall(item, 'running');
+                        if (call && !toolCalls.has(call.id)) {
+                            toolCalls.set(call.id, call);
+                            ctx.emit({ type: 'tool', call });
                         }
                         break;
                     }
+                    case 'item/commandExecution/outputDelta':
+                    case 'item/fileChange/outputDelta': {
+                        const id = String(params?.itemId || '');
+                        const previous = toolCalls.get(id);
+                        if (!previous)
+                            break;
+                        const call = { ...previous, result: appendCodexToolOutput(previous.result, params?.delta) };
+                        toolCalls.set(id, call);
+                        ctx.emit({ type: 'tool', call });
+                        break;
+                    }
+                    case 'item/fileChange/patchUpdated': {
+                        const id = String(params?.itemId || '');
+                        const projected = codexToolCall({ type: 'fileChange', id, changes: params?.changes }, 'running');
+                        if (!projected)
+                            break;
+                        const previous = toolCalls.get(id);
+                        const call = previous ? { ...previous, ...projected, result: projected.result ?? previous.result } : projected;
+                        toolCalls.set(id, call);
+                        ctx.emit({ type: 'tool', call });
+                        break;
+                    }
                     case 'item/agentMessage/delta': {
                         if (!params?.delta)
                             break;
@@ -259,14 +385,26 @@ export class CodexDriver {
                             captureCodexAgentMessage(item, state, deltaItems, phases, ctx.emit);
                         else if (item.type === 'reasoning')
                             captureCodexReasoning(codexReasoningItemText(item), state, ctx.emit);
-                        const t = codexToolSummary(item);
-                        if (t) {
+                        const projected = codexToolCall(item, 'done');
+                        if (projected) {
                             // Prefer the completed item's summary when it is specific — webSearch carries its
                             // query only at completion (item/started may be query-less or absent entirely,
-                            // so no `toolSummaries.has` gate: a completed-only tool still gets its row).
-                            const summary = !CODEX_GENERIC_TOOL_SUMMARIES.has(t.summary) ? t.summary : (toolSummaries.get(t.id) || t.summary);
-                            toolSummaries.set(t.id, summary);
-                            ctx.emit({ type: 'tool', call: { id: t.id, name: t.name, summary, status: item.status === 'failed' ? 'failed' : 'done' } });
+                            // so a completed-only tool still gets its row).
+                            const previous = toolCalls.get(projected.id);
+                            const summary = !CODEX_GENERIC_TOOL_SUMMARIES.has(projected.summary)
+                                ? projected.summary
+                                : (previous?.summary || projected.summary);
+                            const call = {
+                                ...previous,
+                                ...projected,
+                                summary,
+                                input: projected.input ?? previous?.input ?? null,
+                                // Some app-server versions stream output deltas but omit aggregatedOutput on the
+                                // terminal item. Preserve the accumulated live result in that case.
+                                result: projected.result ?? previous?.result ?? null,
+                            };
+                            toolCalls.set(call.id, call);
+                            ctx.emit({ type: 'tool', call });
                         }
                         break;
                     }

package/dist/drivers/native.js

@@ -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/dist/workspace/sessions.d.ts

@@ -16,6 +16,7 @@ export interface ManagedSessionInfo {
     source: SessionSource;
     createdAt: string | null;
     updatedAt: string | null;
+    messageCount?: number | null;
 }
 export interface ListSessionsOptions {
     /**
@@ -28,6 +29,8 @@ export interface ListSessionsOptions {
     agent?: string;
     includeNative?: boolean;
     limit?: number;
+    /** Skip this many of the most-recent rows before taking `limit` — for paginated "load more". */
+    offset?: number;
 }
 export interface SearchSessionsOptions extends ListSessionsOptions {
     query: string;

package/dist/workspace/sessions.js

@@ -24,6 +24,7 @@ function managedToInfo(agent, rec) {
         source: 'managed',
         createdAt: rec.createdAt ?? null,
         updatedAt: rec.updatedAt ?? null,
+        messageCount: null, // managed records don't track a turn count; native rows carry the head-approx one
     };
 }
 function nativeToInfo(agent, n) {
@@ -35,12 +36,13 @@ function nativeToInfo(agent, n) {
         preview: n.preview,
         workdir: n.cwd,
         model: n.model,
-        effort: null,
+        effort: n.effort ?? null,
         runState: n.running ? 'running' : 'completed',
         running: n.running,
         source: 'native',
         createdAt: n.createdAt,
         updatedAt: n.updatedAt,
+        messageCount: n.messageCount ?? null,
     };
 }
 export class SessionsManager {
@@ -55,6 +57,15 @@ export class SessionsManager {
         const drivers = this.deps.drivers();
         const agentIds = opts.agent ? [opts.agent] : [...drivers.keys()];
         const byKey = new Map();
+        // Native discovery must surface enough of the newest rows to satisfy offset+limit paging, since
+        // the final page is sliced AFTER merging managed + native. `undefined` limit = discover all.
+        const offset = Math.max(0, opts.offset ?? 0);
+        const nativeLimit = typeof opts.limit === 'number' ? offset + opts.limit : undefined;
+        // Native session keys a managed record already represents because the agent minted a DIVERGENT
+        // transcript id (rec.sessionId ≠ rec.nativeSessionId — the new-chat case). Those native rows are
+        // dropped below so they don't double up with their managed row. Deduping HERE (before paging) keeps
+        // page sizes and "has more" correct — doing it in a host wrapper after slicing shrinks pages.
+        const coveredNativeKeys = new Set();
         // Managed sessions (the kernel's own store).
         for (const agent of agentIds) {
             let records = [];
@@ -65,6 +76,9 @@ export class SessionsManager {
                 this.deps.log?.(`[sessions] store.list(${agent}) failed: ${e?.message || e}`);
             }
             for (const rec of records) {
+                if (rec.nativeSessionId && rec.nativeSessionId !== rec.sessionId) {
+                    coveredNativeKeys.add(makeSessionKey(agent, rec.nativeSessionId));
+                }
                 if (scope === 'workspace') {
                     if (!rec.workdir || path.resolve(rec.workdir) !== workdir)
                         continue;
@@ -80,13 +94,15 @@ export class SessionsManager {
                     continue;
                 let natives = [];
                 try {
-                    natives = await driver.listNativeSessions({ workdir, limit: opts.limit });
+                    natives = await driver.listNativeSessions({ workdir, limit: nativeLimit });
                 }
                 catch (e) {
                     this.deps.log?.(`[sessions] ${agent}.listNativeSessions failed: ${e?.message || e}`);
                 }
                 for (const n of natives) {
                     const key = makeSessionKey(agent, n.sessionId);
+                    if (coveredNativeKeys.has(key))
+                        continue; // a managed record already represents this transcript
                     const existing = byKey.get(key);
                     if (existing) {
                         // Same identity discovered both ways: managed record wins, but adopt the newer
@@ -104,15 +120,16 @@ export class SessionsManager {
             }
         }
         const out = [...byKey.values()].sort((a, b) => ts(b.updatedAt) - ts(a.updatedAt));
-        return typeof opts.limit === 'number' ? out.slice(0, Math.max(0, opts.limit)) : out;
+        return typeof opts.limit === 'number' ? out.slice(offset, offset + opts.limit) : offset ? out.slice(offset) : out;
     }
     async search(opts) {
         const q = (opts.query || '').trim().toLowerCase();
-        const all = await this.list({ ...opts, limit: undefined });
+        const all = await this.list({ ...opts, limit: undefined, offset: 0 });
         const matched = q
             ? all.filter(s => [s.title, s.preview, s.sessionId, s.model, s.agent].some(v => v != null && v.toLowerCase().includes(q)))
             : all;
-        return typeof opts.limit === 'number' ? matched.slice(0, Math.max(0, opts.limit)) : matched;
+        const offset = Math.max(0, opts.offset ?? 0);
+        return typeof opts.limit === 'number' ? matched.slice(offset, offset + opts.limit) : offset ? matched.slice(offset) : matched;
     }
     async get(sessionKey, opts = {}) {
         const { agent, sessionId } = splitSessionKey(sessionKey);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikiloom/kernel",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Heterogeneous coding agents (Claude / Codex / Gemini / ACP) -> an interaction-friendly, accumulating session snapshot + control handle, over pluggable surfaces (IM, Web, tunnel, TUI). The reusable core pikiloom itself is built on.",
   "type": "module",
   "license": "MIT",