@pikiloom/kernel 0.3.5 → 0.3.6

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/claude.d.ts

@@ -24,7 +24,7 @@ export declare function claudeBgAgentHoldCapMs(): number;
 export declare function claudeTurnHasAgentBackground(s: any): boolean;
 export declare function claudeBgHoldRecheckMs(): number;
 export declare function claudeBgSettleQuietMs(): number;
-export declare function claudeModelStallMs(effort?: string | null): number;
+export declare function claudeModelStallMs(): number;
 export declare const CLAUDE_TRUNCATED_RECOVERY_PROMPT: string;
 export declare function claudeTruncatedRecoveryEnabled(): boolean;
 export declare function isClaudeSyntheticResumeNoise(text: string): boolean;

package/dist/drivers/claude.js

@@ -193,7 +193,7 @@ export class ClaudeDriver {
                         return;
                     }
                     settleResult({ stopReason: 'stalled', kill: false, ok: false });
-                }, claudeModelStallMs(input.effort));
+                }, claudeModelStallMs());
                 unref(modelStallTimer);
             };
             try {
@@ -801,22 +801,15 @@ export function claudeBgSettleQuietMs() {
     return Number.isFinite(raw) && raw > 0 ? raw : CLAUDE_BG_SETTLE_QUIET_DEFAULT_MS;
 }
 // How long the model may stay COMPLETELY silent after a tool_result (control handed back to it,
-// no background pending) before the driver gives up and settles the turn as 'stalled'. Must be
-// generous: subscription accounts stream NO events during extended thinking, and at the reasoning
-// rungs a legitimate silent think regularly exceeds two minutes — the original 120s default
-// misfired on exactly that (settling a LIVE turn as 'stalled' and then killing its still-running
-// tool via the leak-guard; mirasim#111). A too-long window only means a truly hung turn shows its
-// dead spinner longer, so the costs are asymmetric — err long. Effort-laddered: the deep-reasoning
-// rungs (high and up) think the longest. A still-running tool never trips this (it has no
-// tool_result yet). Override with PIKILOOM_CLAUDE_MODEL_STALL_MS (wins over the ladder).
-const CLAUDE_MODEL_STALL_DEFAULT_MS = 300_000;
-const CLAUDE_MODEL_STALL_DEEP_MS = 600_000;
-const CLAUDE_DEEP_REASONING_EFFORTS = new Set(['high', 'xhigh', 'max', 'ultra']);
-export function claudeModelStallMs(effort) {
+// no background pending) before the driver gives up and settles the turn as 'stalled'. Deliberately
+// generous: legitimate silent extended-thinking (subscription accounts stream no thinking text) and
+// slow providers must not trip it, and a still-running tool never trips it (it has no tool_result
+// yet). This is the backstop for a turn that would otherwise hang forever with the answer never
+// delivered. Override with PIKILOOM_CLAUDE_MODEL_STALL_MS.
+const CLAUDE_MODEL_STALL_DEFAULT_MS = 120_000;
+export function claudeModelStallMs() {
     const raw = Number(process.env.PIKILOOM_CLAUDE_MODEL_STALL_MS);
-    if (Number.isFinite(raw) && raw > 0)
-        return raw;
-    return effort && CLAUDE_DEEP_REASONING_EFFORTS.has(effort) ? CLAUDE_MODEL_STALL_DEEP_MS : CLAUDE_MODEL_STALL_DEFAULT_MS;
+    return Number.isFinite(raw) && raw > 0 ? raw : CLAUDE_MODEL_STALL_DEFAULT_MS;
 }
 // In-process self-heal for a truncated turn: when a clean result lands while the tool loop is
 // still dangling (the model's closing round came back empty), the stdin is still open — inject

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.6",
   "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",