pikiloom 0.4.62 → 0.4.64

package/README.md

@@ -368,7 +368,7 @@ Questions, feedback, or want to compare notes on agent orchestration? Add me on
 ## Star History
 
 <a href="https://www.star-history.com/#xiaotonng/pikiloom&Date">
-  <img src="https://api.star-history.com/svg?repos=xiaotonng/pikiloom&type=Date" alt="Star History" width="640">
+  <img src="https://raw.githubusercontent.com/xiaotonng/pikiloom/main/docs/star-history.svg" alt="Star History" width="640">
 </a>
 
 ---

package/dist/browser-profile.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 import { spawn, spawnSync } from 'node:child_process';
-import { MANAGED_BROWSER_PROFILE_SUBPATH, PIKILOOM_BROWSER_CDP_URL_ENV, PLAYWRIGHT_MCP_PACKAGE_NAME, PLAYWRIGHT_MCP_PACKAGE_SPEC, PLAYWRIGHT_MCP_BROWSER_ARGS, } from './core/constants.js';
+import { MANAGED_BROWSER_PROFILE_SUBPATH, MANAGED_BROWSER_STEALTH_ARGS, PIKILOOM_BROWSER_CDP_URL_ENV, PLAYWRIGHT_MCP_PACKAGE_NAME, PLAYWRIGHT_MCP_PACKAGE_SPEC, PLAYWRIGHT_MCP_BROWSER_ARGS, } from './core/constants.js';
 const MANAGED_BROWSER_SETUP_STATE_FILENAME = 'managed-browser-setup.json';
 const MANAGED_BROWSER_SHUTDOWN_TIMEOUT_MS = 5_000;
 const MANAGED_BROWSER_SHUTDOWN_POLL_MS = 100;
@@ -148,7 +148,7 @@ export function ensurePlaywrightMcpConfigFile(outputDir = path.dirname(getManage
     const desired = JSON.stringify({
         browser: {
             launchOptions: {
-                ignoreDefaultArgs: ['--disable-blink-features=AutomationControlled'],
+                args: [...MANAGED_BROWSER_STEALTH_ARGS],
             },
         },
     }, null, 2);
@@ -211,6 +211,7 @@ export function getManagedBrowserLaunchArgs(profileDir = getManagedBrowserProfil
     return [
         `--user-data-dir=${profileDir}`,
         '--remote-debugging-port=0',
+        ...MANAGED_BROWSER_STEALTH_ARGS,
         '--no-first-run',
         '--no-default-browser-check',
         '--new-window',

package/dist/core/constants.js

@@ -26,6 +26,10 @@ export const PLAYWRIGHT_MCP_PACKAGE_NAME = '@playwright/mcp';
 export const PLAYWRIGHT_MCP_PACKAGE_VERSION = '0.0.75';
 export const PLAYWRIGHT_MCP_PACKAGE_SPEC = `${PLAYWRIGHT_MCP_PACKAGE_NAME}@${PLAYWRIGHT_MCP_PACKAGE_VERSION}`;
 export const PLAYWRIGHT_MCP_BROWSER_ARGS = ['--browser', 'chrome', '--viewport-size', '1920x1080'];
+// Chrome 150+ sets navigator.webdriver=true whenever remote debugging is on, which trips
+// Google's "This browser or app may not be secure" sign-in block; --test-type suppresses
+// the "unsupported command-line flag" infobar that the first flag would otherwise trigger.
+export const MANAGED_BROWSER_STEALTH_ARGS = ['--disable-blink-features=AutomationControlled', '--test-type'];
 export const PIKILOOM_BROWSER_CDP_URL_ENV = 'PIKILOOM_BROWSER_CDP_URL';
 export const DASHBOARD_PAGINATION = {
     defaultPageSize: 6,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiloom",
-  "version": "0.4.62",
+  "version": "0.4.64",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {

package/packages/kernel/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/packages/kernel/dist/drivers/claude.d.ts

@@ -24,10 +24,11 @@ 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(): number;
+export declare function claudeModelStallMs(effort?: string | null): number;
 export declare const CLAUDE_TRUNCATED_RECOVERY_PROMPT: string;
 export declare function claudeTruncatedRecoveryEnabled(): boolean;
 export declare function isClaudeSyntheticResumeNoise(text: string): boolean;
+export declare function isClaudeSlashCommand(prompt: string): boolean;
 export declare function claudeProducedRealOutput(s: any): boolean;
 export declare function claudeResumeNoopRetryLimit(): number;
 export declare function claudeUserEventHasToolResult(ev: any): boolean;

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

@@ -193,7 +193,7 @@ export class ClaudeDriver {
                         return;
                     }
                     settleResult({ stopReason: 'stalled', kill: false, ok: false });
-                }, claudeModelStallMs());
+                }, claudeModelStallMs(input.effort));
                 unref(modelStallTimer);
             };
             try {
@@ -270,7 +270,13 @@ export class ClaudeDriver {
                             // through its repair to a real answer within this one turn. Bounded (the repair can
                             // no-op more than once); the post-tool stall watchdog is the backstop if the CLI never
                             // engages. Scoped to resumes (input.sessionId) — a fresh session has no dangling turn.
+                            // Excludes local slash commands (isClaudeSlashCommand): /compact, /clear & friends are
+                            // LEGITIMATELY output-empty (their effect is a local action, not an assistant reply), so
+                            // the emptiness that flags a dropped send is normal for them. Re-issuing one is never a
+                            // repair — for /compact it just fires a second compaction that reports "Not enough
+                            // messages to compact." A real dropped send is a plain prompt and still self-heals.
                             if (!hasError && !!input.sessionId && !claudeProducedRealOutput(state)
+                                && !isClaudeSlashCommand(input.prompt)
                                 && noopResumeRetries < claudeResumeNoopRetryLimit()) {
                                 noopResumeRetries++;
                                 let injected = false;
@@ -534,6 +540,23 @@ export function handleClaudeEvent(ev, s, emit) {
         // as the reply nor counts as real output (the no-op-resume recovery keys off that emptiness).
         if (ev.message?.model === '<synthetic>' && isClaudeSyntheticResumeNoise(claudeContentText(ev.message?.content)))
             return;
+        // API-error message: Claude surfaces a failed model call (401 auth, overloaded, quota, …) not as a
+        // result code but as a synthetic assistant message — model '<synthetic>', a lone text block carrying
+        // the human-readable error ("Failed to authenticate. API Error: 401 …"), and a TOP-LEVEL `error` tag
+        // on the event (e.g. "authentication_failed"; the persisted transcript also stamps `isApiErrorMessage`).
+        // It is NOT model output. Routing its text through the normal path below would make the error render
+        // as the assistant's reply body (原文). Send it to `s.error` — the run-end notice, same slot as the
+        // `result{is_error}` branch below — and never to `s.text`. The trailing `result` also flags the error
+        // (and would set `s.error` too), but claiming it here keeps a narration-less turn from double-rendering
+        // (body + notice), and preserves any real narration already streamed before the call failed.
+        const apiErrorTag = typeof ev.error === 'string' ? ev.error.trim() : (ev.isApiErrorMessage ? 'api_error' : '');
+        if (apiErrorTag) {
+            if (!s.error) {
+                const msg = claudeContentText(ev.message?.content).trim();
+                s.error = msg || `Claude reported an API error (${apiErrorTag})`;
+            }
+            return;
+        }
         const contents = ev.message?.content || [];
         for (const b of contents) {
             if (b?.type !== 'tool_use')
@@ -778,15 +801,22 @@ 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'. 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() {
+// 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) {
     const raw = Number(process.env.PIKILOOM_CLAUDE_MODEL_STALL_MS);
-    return Number.isFinite(raw) && raw > 0 ? raw : CLAUDE_MODEL_STALL_DEFAULT_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;
 }
 // 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
@@ -809,6 +839,15 @@ export function isClaudeSyntheticResumeNoise(text) {
     const t = (text || '').trim().toLowerCase();
     return t === 'no response requested.' || t === 'no response requested';
 }
+// A prompt whose first token is a Claude slash command (/compact, /clear, /cost, /model …, a custom
+// /namespace:command). Such a prompt is a LOCAL action, not a request for a model reply, so an
+// output-empty result is expected — not the dropped-send signature the no-op-resume repair targets.
+// The first token must be a bare command name (letters/digits/_/- with an optional :namespace) ending
+// at whitespace or end-of-string, so a filesystem-style path (/Users/foo) is NOT matched. Pure +
+// exported for hermetic testing.
+export function isClaudeSlashCommand(prompt) {
+    return /^\/[a-z0-9][\w-]*(?::[\w-]+)?(?:\s|$)/i.test((prompt || '').trimStart());
+}
 // True once the turn produced ANY real model output — streamed or whole-message text/reasoning, a
 // tool use, or a spawned sub-agent. False for a pure no-op (a synthetic resume-repair result that
 // ran none of the prompt), which is exactly what the no-op-resume recovery keys off. Pure +

package/packages/kernel/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/packages/kernel/dist/runtime/hub.js

@@ -120,6 +120,12 @@ export class Hub {
             extraArgs: spawn.extraArgs,
             configOverrides: spawn.configOverrides,
             extraMcpServers: tools.servers,
+            // The managed path's control verb `LoomIO.steer()` can only reach a driver that was
+            // launched steer-enabled, so honor the driver's declared capability here — otherwise
+            // steer is a silent no-op for steer-capable agents (claude gates registerSteer +
+            // --replay-user-messages on this flag). Drivers that don't support steer stay
+            // un-steerable; those that steer over their own channel regardless (codex RPC) ignore it.
+            steerable: !!driver.capabilities?.steer,
         };
         runner.run(driver, turnInput, input.prompt, model, effort)
             .then(async (result) => {

package/packages/kernel/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/packages/kernel/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);