@1agents/session-reader 0.6.1 → 0.7.0

package/dist/src/dsh/index.d.ts

@@ -0,0 +1,2 @@
+export * from './adapter.js';
+export * from './plugin.js';

package/dist/src/dsh/index.js

@@ -0,0 +1,2 @@
+export * from './adapter.js';
+export * from './plugin.js';

package/dist/src/dsh/plugin.d.ts

@@ -0,0 +1,3 @@
+export declare const name = "session-reader";
+export declare const inject: string[];
+export declare function apply(ctx: any): void;

package/dist/src/dsh/plugin.js

@@ -0,0 +1,392 @@
+import fs from 'node:fs';
+import { resolveSession, searchSessions, buildOverview, summarizeTurns, turnDetail, eventDetails, } from '../index.js';
+import { handleSessionApi } from '../web/api.js';
+import { convertSessionToDshEvents } from './adapter.js';
+export const name = 'session-reader';
+export const inject = ['tools', 'webServer'];
+export function apply(ctx) {
+    // 1. Register tools if ctx.tools is present
+    if (ctx.tools && typeof ctx.tools.register === 'function') {
+        // session_search
+        ctx.tools.register({
+            name: 'session_search',
+            description: 'Search past AI coding sessions across Claude Code, Codex, Antigravity, Grok and DSH. By default searches sessions in the current working directory / workspace.',
+            parameters: {
+                query: { type: 'string', required: true, description: 'Keywords, file paths, or error messages to search for' },
+                workspace: { type: 'string', description: 'Filter by workspace path (optional, defaults to current session workspace)' },
+                scope: { type: 'string', description: 'Search scope: cwd (default, current session directory), global (all workspaces), or specific path' },
+                since: { type: 'string', description: 'Time filter, e.g. 24h, 7d, 30d' },
+                kind: { type: 'string', description: 'Filter by kind: user, assistant, thinking, tool_call, tool_result' },
+                limit: { type: 'number', description: 'Max number of sessions to return' },
+            },
+            output: {
+                schema: { type: 'array' },
+                render: (_args, value) => [{ type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value, null, 2) }],
+            },
+            async execute(args, exec) {
+                const currentCwd = exec?.agent?.session?.header?.cwd ?? process.cwd();
+                let targetWorkspace;
+                if (args.scope === 'global') {
+                    targetWorkspace = undefined;
+                }
+                else if (args.workspace) {
+                    targetWorkspace = args.workspace;
+                }
+                else if (args.scope && args.scope !== 'cwd') {
+                    targetWorkspace = args.scope;
+                }
+                else {
+                    // Default to current session PWD
+                    targetWorkspace = currentCwd;
+                }
+                const hits = await searchSessions(args.query, {
+                    workspace: targetWorkspace,
+                    since: args.since,
+                    kinds: args.kind ? [args.kind] : undefined,
+                    limit: args.limit,
+                });
+                return hits.map((h) => ({
+                    sessionId: h.session.id,
+                    provider: h.session.provider,
+                    workspace: h.session.workspace,
+                    title: h.session.title,
+                    updatedAt: h.session.updatedAt,
+                    matchCount: h.matches.length,
+                    matches: h.matches.slice(0, 5).map((m) => ({
+                        turn: m.turn,
+                        kind: m.kind,
+                        excerpt: m.excerpt,
+                    })),
+                }));
+            },
+        });
+        // session_overview
+        ctx.tools.register({
+            name: 'session_overview',
+            description: 'Get statistics, files modified, commands executed, and end-state facts of a past session.',
+            parameters: {
+                sessionId: { type: 'string', required: true, description: 'Session ID or 8-char prefix' },
+            },
+            output: {
+                schema: { type: 'object' },
+                render: (_args, value) => [{ type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value, null, 2) }],
+            },
+            async execute(args) {
+                const resolved = await resolveSession(args.sessionId);
+                if (!resolved)
+                    throw new Error(`Session not found: ${args.sessionId}`);
+                const normalized = await resolved.adapter.parse(resolved.candidate);
+                const overview = buildOverview(normalized);
+                return {
+                    id: normalized.ref.id,
+                    provider: normalized.ref.provider,
+                    title: normalized.ref.title,
+                    workspace: normalized.ref.workspace,
+                    markdown: overview.markdown,
+                    stats: overview.stats,
+                };
+            },
+        });
+        // session_turns
+        ctx.tools.register({
+            name: 'session_turns',
+            description: 'Get turn-by-turn summary of what was discussed and done in a session.',
+            parameters: {
+                sessionId: { type: 'string', required: true, description: 'Session ID or 8-char prefix' },
+            },
+            output: {
+                schema: { type: 'array' },
+                render: (_args, value) => [{ type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value, null, 2) }],
+            },
+            async execute(args) {
+                const resolved = await resolveSession(args.sessionId);
+                if (!resolved)
+                    throw new Error(`Session not found: ${args.sessionId}`);
+                const normalized = await resolved.adapter.parse(resolved.candidate);
+                return summarizeTurns(normalized);
+            },
+        });
+        // session_turn_detail
+        ctx.tools.register({
+            name: 'session_turn_detail',
+            description: 'Inspect full untruncated events, tool calls, and results for a specific turn in a session.',
+            parameters: {
+                sessionId: { type: 'string', required: true, description: 'Session ID or 8-char prefix' },
+                turn: { type: 'number', required: true, description: 'Turn number' },
+                events: { type: 'string', description: 'Event selector, e.g. "11", "11-13", "11,15,22"' },
+            },
+            output: {
+                schema: { oneOf: [{ type: 'object' }, { type: 'array' }] },
+                render: (_args, value) => [{ type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value, null, 2) }],
+            },
+            async execute(args) {
+                const resolved = await resolveSession(args.sessionId);
+                if (!resolved)
+                    throw new Error(`Session not found: ${args.sessionId}`);
+                const normalized = await resolved.adapter.parse(resolved.candidate);
+                if (args.events) {
+                    return await eventDetails(normalized, args.events);
+                }
+                return turnDetail(normalized, args.turn);
+            },
+        });
+        // session_open_in_dsh
+        ctx.tools.register({
+            name: 'session_open_in_dsh',
+            description: 'Load a cross-agent historical session into DSH native sessions and automatically assign it to the DSH workspace.',
+            parameters: {
+                sessionId: { type: 'string', required: true, description: 'Session ID to import into DSH' },
+                currentCwd: { type: 'string', description: 'Optional current session working directory fallback' },
+            },
+            output: {
+                schema: { type: 'object' },
+                render: (_args, value) => [{ type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value, null, 2) }],
+            },
+            async execute(args, exec) {
+                const resolved = await resolveSession(args.sessionId);
+                if (!resolved)
+                    throw new Error(`Session not found: ${args.sessionId}`);
+                const normalized = await resolved.adapter.parse(resolved.candidate);
+                const dshEvents = convertSessionToDshEvents(normalized);
+                const rawId = normalized.ref.id;
+                const sanitizedId = rawId.replace(/[^a-zA-Z0-9_-]/g, '-');
+                const dshSessionId = sanitizedId.startsWith('session-') ? sanitizedId : `session-${sanitizedId}`;
+                const currentSessionCwd = exec?.agent?.session?.header?.cwd ?? args.currentCwd;
+                let targetCwd;
+                if (normalized.ref.workspace && typeof normalized.ref.workspace === 'string' && normalized.ref.workspace.startsWith('/')) {
+                    try {
+                        const st = await fs.promises.stat(normalized.ref.workspace);
+                        if (st.isDirectory()) {
+                            targetCwd = await fs.promises.realpath(normalized.ref.workspace);
+                        }
+                    }
+                    catch { }
+                }
+                if (!targetCwd) {
+                    const fallback = currentSessionCwd || process.cwd();
+                    try {
+                        const st = await fs.promises.stat(fallback);
+                        if (st.isDirectory()) {
+                            targetCwd = await fs.promises.realpath(fallback);
+                        }
+                    }
+                    catch { }
+                }
+                if (!targetCwd)
+                    targetCwd = process.cwd();
+                const createdAt = normalized.ref.createdAt ? Date.parse(normalized.ref.createdAt) : Date.now();
+                const header = {
+                    version: 2,
+                    id: dshSessionId,
+                    cwd: targetCwd,
+                    createdAt: isNaN(createdAt) ? Date.now() : createdAt,
+                    isSeeded: false,
+                    delegationDepth: 0,
+                };
+                const persistence = ctx.get ? ctx.get('sessionPersistence') : ctx.sessionPersistence;
+                if (persistence && typeof persistence.create === 'function') {
+                    try {
+                        const existingStat = await persistence.stat(dshSessionId);
+                        if (!existingStat) {
+                            const handle = await persistence.create(header);
+                            await handle.append(dshEvents);
+                            await handle.flush();
+                            await handle.close();
+                        }
+                    }
+                    catch (e) {
+                        console.warn('[session-reader] persistence notice:', e?.message || e);
+                    }
+                }
+                const sessions = ctx.get ? ctx.get('sessions') : ctx.sessions;
+                if (sessions && typeof sessions.create === 'function') {
+                    try {
+                        if (!sessions.get(dshSessionId)) {
+                            sessions.create(dshSessionId, { seed: dshEvents, meta: header });
+                        }
+                    }
+                    catch (e) {
+                        console.warn('[session-reader] sessions.create notice:', e?.message || e);
+                    }
+                }
+                const workspaceRegistry = ctx.get ? (ctx.get('workspaceRegistry') ?? ctx.workspaceRegistry) : ctx.workspaceRegistry;
+                let attachedWorkspaceId;
+                if (workspaceRegistry && typeof workspaceRegistry.create === 'function') {
+                    try {
+                        const ws = await workspaceRegistry.create(targetCwd);
+                        if (ws && typeof ws.attachSession === 'function') {
+                            await ws.attachSession(dshSessionId);
+                            attachedWorkspaceId = ws.id;
+                        }
+                    }
+                    catch (wsErr) {
+                        console.warn('[session-reader] workspace attach notice:', wsErr?.message || wsErr);
+                    }
+                }
+                return {
+                    success: true,
+                    dshSessionId,
+                    eventCount: dshEvents.length,
+                    title: normalized.ref.title,
+                    workspace: targetCwd,
+                    workspaceId: attachedWorkspaceId,
+                };
+            },
+        });
+    }
+    // 2. Register HTTP routes if ctx.webServer is present
+    if (ctx.webServer && typeof ctx.webServer.register === 'function') {
+        ctx.webServer.register({
+            kind: 'prefix',
+            path: '/api/session-reader',
+            handler: async (req, res) => {
+                const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+                const pathname = url.pathname.replace(/^\/api\/session-reader/, '');
+                res.setHeader('Content-Type', 'application/json; charset=utf-8');
+                res.setHeader('Access-Control-Allow-Origin', '*');
+                res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+                res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+                if (req.method === 'OPTIONS') {
+                    res.statusCode = 204;
+                    res.end();
+                    return;
+                }
+                try {
+                    if (pathname === '/open-in-dsh') {
+                        let sessionId = url.searchParams.get('id');
+                        let currentCwd = url.searchParams.get('currentCwd') ?? undefined;
+                        if (!sessionId && (req.method === 'POST' || req.method === 'PUT')) {
+                            const body = await new Promise((resolve) => {
+                                let data = '';
+                                req.on('data', chunk => data += chunk);
+                                req.on('end', () => {
+                                    try {
+                                        resolve(JSON.parse(data));
+                                    }
+                                    catch {
+                                        resolve({});
+                                    }
+                                });
+                                req.on('error', () => resolve({}));
+                            });
+                            sessionId = body?.sessionId || body?.id;
+                            currentCwd = body?.currentCwd || currentCwd;
+                        }
+                        if (!sessionId) {
+                            res.statusCode = 400;
+                            res.end(JSON.stringify({ error: 'Missing sessionId' }));
+                            return;
+                        }
+                        const resolved = await resolveSession(sessionId);
+                        if (!resolved) {
+                            res.statusCode = 404;
+                            res.end(JSON.stringify({ error: `Session not found: ${sessionId}` }));
+                            return;
+                        }
+                        const normalized = await resolved.adapter.parse(resolved.candidate);
+                        const dshEvents = convertSessionToDshEvents(normalized);
+                        const rawId = normalized.ref.id;
+                        const sanitizedId = rawId.replace(/[^a-zA-Z0-9_-]/g, '-');
+                        const dshSessionId = sanitizedId.startsWith('session-') ? sanitizedId : `session-${sanitizedId}`;
+                        let targetCwd;
+                        if (normalized.ref.workspace && typeof normalized.ref.workspace === 'string' && normalized.ref.workspace.startsWith('/')) {
+                            try {
+                                const st = await fs.promises.stat(normalized.ref.workspace);
+                                if (st.isDirectory()) {
+                                    targetCwd = await fs.promises.realpath(normalized.ref.workspace);
+                                }
+                            }
+                            catch { }
+                        }
+                        if (!targetCwd) {
+                            const fallback = currentCwd || process.cwd();
+                            try {
+                                const st = await fs.promises.stat(fallback);
+                                if (st.isDirectory()) {
+                                    targetCwd = await fs.promises.realpath(fallback);
+                                }
+                            }
+                            catch { }
+                        }
+                        if (!targetCwd)
+                            targetCwd = process.cwd();
+                        const createdAt = normalized.ref.createdAt ? Date.parse(normalized.ref.createdAt) : Date.now();
+                        const header = {
+                            version: 2,
+                            id: dshSessionId,
+                            cwd: targetCwd,
+                            createdAt: isNaN(createdAt) ? Date.now() : createdAt,
+                            isSeeded: false,
+                            delegationDepth: 0,
+                        };
+                        // 1. Persistence if available
+                        const persistence = ctx.get ? ctx.get('sessionPersistence') : ctx.sessionPersistence;
+                        if (persistence && typeof persistence.create === 'function') {
+                            try {
+                                const existingStat = await persistence.stat(dshSessionId);
+                                if (!existingStat) {
+                                    const handle = await persistence.create(header);
+                                    await handle.append(dshEvents);
+                                    await handle.flush();
+                                    await handle.close();
+                                }
+                            }
+                            catch (persistErr) {
+                                console.warn('[session-reader] persistence notice:', persistErr?.message || persistErr);
+                            }
+                        }
+                        // 2. In-memory sessions if available
+                        const sessions = ctx.get ? ctx.get('sessions') : ctx.sessions;
+                        if (sessions && typeof sessions.create === 'function') {
+                            try {
+                                if (!sessions.get(dshSessionId)) {
+                                    sessions.create(dshSessionId, {
+                                        seed: dshEvents,
+                                        meta: header,
+                                    });
+                                }
+                            }
+                            catch (sessionErr) {
+                                console.warn('[session-reader] sessions.create notice:', sessionErr?.message || sessionErr);
+                            }
+                        }
+                        // 3. Workspace attachment if workspaceRegistry is available
+                        const workspaceRegistry = ctx.get ? (ctx.get('workspaceRegistry') ?? ctx.workspaceRegistry) : ctx.workspaceRegistry;
+                        let attachedWorkspaceId;
+                        if (workspaceRegistry && typeof workspaceRegistry.create === 'function') {
+                            try {
+                                const ws = await workspaceRegistry.create(targetCwd);
+                                if (ws && typeof ws.attachSession === 'function') {
+                                    await ws.attachSession(dshSessionId);
+                                    attachedWorkspaceId = ws.id;
+                                }
+                            }
+                            catch (wsErr) {
+                                console.warn('[session-reader] workspace attach notice:', wsErr?.message || wsErr);
+                            }
+                        }
+                        res.statusCode = 200;
+                        res.end(JSON.stringify({
+                            success: true,
+                            dshSessionId,
+                            eventCount: dshEvents.length,
+                            title: normalized.ref.title,
+                            workspace: targetCwd,
+                            workspaceId: attachedWorkspaceId,
+                        }));
+                        return;
+                    }
+                    const handled = await handleSessionApi(pathname, url, res, { fallbackCwd: process.cwd() });
+                    if (handled)
+                        return;
+                    res.statusCode = 404;
+                    res.end(JSON.stringify({ error: 'Endpoint not found' }));
+                }
+                catch (err) {
+                    res.statusCode = 500;
+                    res.end(JSON.stringify({ error: err?.message ?? String(err) }));
+                }
+            },
+        });
+    }
+}

package/dist/src/index.d.ts

@@ -20,3 +20,5 @@ export { EDGE_VERSION, EXTRACTOR_VERSION, PARSER_VERSION, SCHEMA_VERSION, } from
 export { SKILL_NAME, agentTargets, bundledSkillDir, describeState, installSkill, skillStatus, uninstallSkill, type AgentStatus, type AgentTarget, type EntryState, type InstallMode, type InstallOptions, type InstallResult, type SkillAgent, type UninstallResult, } from './skill.js';
 export { buildManifest, nodeIdentity, sessionUri, SESSION_CAPABILITIES, type AccessDescriptor, type NetworkService, type NodeManifest, } from './serve/node.js';
 export { createServer, serve, type ServeOptions } from './serve/http.js';
+export { convertSessionToDshEvents, type DshSessionEvent, type ConvertOptions } from './dsh/adapter.js';
+export { apply, inject, name } from './dsh/index.js';

package/dist/src/index.js

@@ -18,3 +18,5 @@ export { EDGE_VERSION, EXTRACTOR_VERSION, PARSER_VERSION, SCHEMA_VERSION, } from
 export { SKILL_NAME, agentTargets, bundledSkillDir, describeState, installSkill, skillStatus, uninstallSkill, } from './skill.js';
 export { buildManifest, nodeIdentity, sessionUri, SESSION_CAPABILITIES, } from './serve/node.js';
 export { createServer, serve } from './serve/http.js';
+export { convertSessionToDshEvents } from './dsh/adapter.js';
+export { apply, inject, name } from './dsh/index.js';

package/dist/src/resolver.d.ts

@@ -10,6 +10,13 @@ export interface ListOptions {
      * after the first run. Set false to read the source files directly.
      */
     useIndex?: boolean;
+    /**
+     * When true (default), fingerprint-sweep every on-disk candidate so the
+     * listing is complete and fresh. Set false to query the index only — no
+     * parse, no all-files sweep. The DSH panel uses this so opening it does
+     * not load every session; click a row to load that one.
+     */
+    refresh?: boolean;
     /**
      * How many session files may be opened. Defaults to a small budget so an
      * unfiltered `list` stays cheap; pass `Infinity` when completeness matters

package/dist/src/resolver.js

@@ -107,6 +107,18 @@ async function listIndexedSessions(options) {
     const { listSessionRows, refOf } = await import('./store/read.js');
     const db = await openStore();
     const sinceMs = parseSince(options.since);
+    const scoped = options.workspace ? canonicalizePath(options.workspace) : undefined;
+    const query = {
+        ...(scoped && scoped !== '/' ? { workspace: scoped } : {}),
+        ...(options.provider ? { provider: options.provider } : {}),
+        ...(sinceMs ? { sinceMs } : {}),
+        limit: options.limit ?? 20,
+    };
+    // Skip the all-files fingerprint sweep: the caller only wants whatever
+    // the index already knows. Used by the DSH panel's lazy listing.
+    if (options.refresh === false) {
+        return listSessionRows(db, query).map(refOf);
+    }
     const ids = [];
     for (const adapter of adapters) {
         if (options.provider && adapter.provider !== options.provider)
@@ -119,14 +131,7 @@ async function listIndexedSessions(options) {
                 ids.push(result.id);
         }
     }
-    const scoped = options.workspace ? canonicalizePath(options.workspace) : undefined;
-    return listSessionRows(db, {
-        ids,
-        ...(scoped && scoped !== '/' ? { workspace: scoped } : {}),
-        ...(options.provider ? { provider: options.provider } : {}),
-        ...(sinceMs ? { sinceMs } : {}),
-        limit: options.limit ?? 20,
-    }).map(refOf);
+    return listSessionRows(db, { ids, ...query }).map(refOf);
 }
 export async function findSessionsByWorkspace(workspacePath, options = {}) {
     return listRecentSessions({ ...options, limit: options.limit ?? 50, workspace: workspacePath });

package/dist/src/serve/http.js

@@ -172,7 +172,19 @@ export function createServer(options = {}) {
 export async function serve(options = {}) {
     const host = options.host ?? '127.0.0.1';
     const server = createServer(options);
-    await new Promise((resolve) => server.listen(options.port ?? DEFAULT_PORT, host, resolve));
+    // 请求的端口。实际绑定到哪个从 server.address() 读——传 0 时它是随机的。
+    const wanted = options.port ?? DEFAULT_PORT;
+    // 端口占用是最常见的启动失败，默认会抛一整屏 Node 栈——对着栈猜"是不是
+    // 已经起了一个"没意义，直接说清楚怎么办。
+    await new Promise((resolve, reject) => {
+        server.once('error', (error) => {
+            reject(error.code === 'EADDRINUSE'
+                ? new Error(`端口 ${wanted} 已被占用。换一个：--port <n>；或先停掉占用它的进程：` +
+                    `lsof -nP -iTCP:${wanted} -sTCP:LISTEN`)
+                : error);
+        });
+        server.listen(wanted, host, resolve);
+    });
     const { port } = server.address();
     const identity = await nodeIdentity();
     // 只听回环的服务，外部发现得了却连不上——如实说，别让调用方白跑一趟。

package/dist/src/store/nul.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 写进 SQLite 的 TEXT 列之前调用。
+ *
+ * 绝大多数内容两个字符都不含，直接原样返回——所以常态是零拷贝。
+ */
+export declare function encodeText(value: string): string;
+export declare function encodeText(value: string | null | undefined): string | null;
+/** 从 SQLite 的 TEXT 列读出来之后调用。 */
+export declare function decodeText(value: string): string;
+export declare function decodeText(value: string | null | undefined): string | null;
+/** 测试与诊断用：这段文本经过 SQLite 的 TEXT 列会不会被截断。 */
+export declare function wouldTruncate(value: string): boolean;

package/dist/src/store/nul.js

@@ -0,0 +1,52 @@
+/**
+ * SQLite 的 TEXT 列在第一个 NUL 处截断——不报错，安静地丢掉后面全部内容。
+ *
+ * 实测：一个 antigravity 会话里 `wsl -l -v` 的 UTF-16 输出被当 UTF-8 读，产生
+ * 交错的 NUL；502 字符的 tool_result 存进索引再读出来只剩 342，后面 160 个
+ * 字符凭空消失。round-trip 测试因此长期飘红，而失败信息指向的是内容本身，
+ * 很难看出是存储层干的。
+ *
+ * 改存 BLOB 能保真，但 `text` / `tool_result` 上有 SQL 搜索（`LIKE` 对 BLOB
+ * 不工作），所以改成**写入时转义、读取时还原**。
+ *
+ * 引导符用 U+FFFF：Unicode 明确规定的 noncharacter，不会出现在有效文本里；
+ * 万一真出现也会被双写，所以还原无歧义。
+ *
+ * 两个常量用 `String.fromCharCode` 而不是字面量，免得源文件里真带上这些
+ * 字符——它们在编辑器、diff、终端里都是隐形的。
+ */
+const NUL = String.fromCharCode(0x00);
+const LEAD = String.fromCharCode(0xffff);
+const ESCAPED_NUL = `${LEAD}0`;
+const ESCAPED_LEAD = `${LEAD}${LEAD}`;
+export function encodeText(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (!value.includes(NUL) && !value.includes(LEAD))
+        return value;
+    // 顺序要紧：先把引导符自己双写，再拿它去转义 NUL。反过来会把刚写出的
+    // 转义序列又转义一遍。
+    return value.split(LEAD).join(ESCAPED_LEAD).split(NUL).join(ESCAPED_NUL);
+}
+export function decodeText(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (!value.includes(LEAD))
+        return value;
+    let out = '';
+    for (let i = 0; i < value.length; i++) {
+        if (value[i] !== LEAD) {
+            out += value[i];
+            continue;
+        }
+        const next = value[++i];
+        // 双写还原成引导符本身；LEAD+'0' 还原成 NUL；落单的引导符原样留着，
+        // 宁可多留一个字符，也不要把不认识的序列吞掉。
+        out += next === LEAD ? LEAD : next === '0' ? NUL : LEAD + (next ?? '');
+    }
+    return out;
+}
+/** 测试与诊断用：这段文本经过 SQLite 的 TEXT 列会不会被截断。 */
+export function wouldTruncate(value) {
+    return value.includes(NUL);
+}

package/dist/src/store/read.d.ts

@@ -26,8 +26,12 @@ export declare function sessionRow(db: DatabaseSync, id: string): SessionRow | u
 /** Resolves a full id, an id prefix, or a native id against the index. */
 export declare function findSessionRow(db: DatabaseSync, needle: string): SessionRow | undefined;
 export interface ListQuery {
-    /** Ids seen on disk during this sweep; rows outside it are stale and skipped. */
-    ids: string[];
+    /**
+     * Ids seen on disk during this sweep; rows outside it are stale and skipped.
+     * Omit to list from the whole index (lazy UI listings that skip the sweep).
+     * An explicit empty array still means "nothing in scope".
+     */
+    ids?: string[];
     /** Canonical root; matches the directory itself and everything under it. */
     workspace?: string;
     provider?: string;

package/dist/src/store/read.js

@@ -1,3 +1,4 @@
+import { decodeText } from './nul.js';
 import { turnStartsFrom } from '../turns.js';
 import { emptyProviderStats, } from '../types.js';
 export function sessionRow(db, id) {
@@ -21,15 +22,18 @@ export function findSessionRow(db, needle) {
  * workspace never silently loses its older sessions to a candidate cap.
  */
 export function listSessionRows(db, query) {
-    if (!query.ids.length)
-        return [];
-    db.exec('DROP TABLE IF EXISTS temp.list_scope');
-    db.exec('CREATE TEMP TABLE list_scope (id TEXT PRIMARY KEY)');
-    const insert = db.prepare('INSERT OR IGNORE INTO temp.list_scope (id) VALUES (?)');
-    for (const id of query.ids)
-        insert.run(id);
-    const where = ['id IN (SELECT id FROM temp.list_scope)'];
+    const where = [];
     const params = [];
+    if (query.ids) {
+        if (!query.ids.length)
+            return [];
+        db.exec('DROP TABLE IF EXISTS temp.list_scope');
+        db.exec('CREATE TEMP TABLE list_scope (id TEXT PRIMARY KEY)');
+        const insert = db.prepare('INSERT OR IGNORE INTO temp.list_scope (id) VALUES (?)');
+        for (const id of query.ids)
+            insert.run(id);
+        where.push('id IN (SELECT id FROM temp.list_scope)');
+    }
     if (query.workspace) {
         // Prefix comparison rather than LIKE: real paths contain `_`, a LIKE wildcard.
         where.push('(workspace = ? OR substr(workspace, 1, ?) = ?)');
@@ -44,11 +48,10 @@ export function listSessionRows(db, query) {
         params.push(query.sinceMs);
     }
     params.push(query.limit ?? 20);
-    return db
-        .prepare(`SELECT * FROM sessions WHERE ${where.join(' AND ')} ` +
+    const sql = `SELECT * FROM sessions${where.length ? ` WHERE ${where.join(' AND ')}` : ''} ` +
         // Undated rows sort last instead of first, which is where DESC puts NULL.
-        'ORDER BY (ended_at IS NULL), ended_at DESC LIMIT ?')
-        .all(...params);
+        'ORDER BY (ended_at IS NULL), ended_at DESC LIMIT ?';
+    return db.prepare(sql).all(...params);
 }
 /**
  * Turn starts for one indexed session, without rebuilding it.
@@ -70,7 +73,7 @@ export function refOf(row) {
         id: row.native_id,
         provider: row.provider,
         path: row.source_path,
-        ...(row.title === null ? {} : { title: row.title }),
+        ...(row.title === null ? {} : { title: decodeText(row.title) }),
         ...(row.workspace === null ? {} : { workspace: row.workspace }),
         ...(row.started_at === null ? {} : { createdAt: row.started_at }),
         ...(row.ended_at === null ? {} : { updatedAt: row.ended_at }),
@@ -89,12 +92,12 @@ function eventsOf(db, id, nativeId) {
         id: `${nativeId}#${row.idx}`,
         index: row.idx,
         kind: row.kind,
-        ...(row.text === null ? {} : { text: row.text }),
+        ...(row.text === null ? {} : { text: decodeText(row.text) }),
         ...(row.tool_name === null ? {} : { toolName: row.tool_name }),
         ...(row.tool_args_json === null
             ? {}
             : { toolArgs: JSON.parse(row.tool_args_json) }),
-        ...(row.tool_result === null ? {} : { toolResult: row.tool_result }),
+        ...(row.tool_result === null ? {} : { toolResult: decodeText(row.tool_result) }),
         ...(row.is_error === null ? {} : { isError: row.is_error === 1 }),
         ...(row.ts === null ? {} : { timestamp: row.ts }),
         ...(row.source_index === null ? {} : { sourceIndex: row.source_index }),

package/dist/src/store/schema.d.ts

@@ -7,7 +7,7 @@
  * the behaviour — never derive them from a git hash, `dist` ships without git.
  */
 /** DDL layout. A bump drops and rebuilds the whole database. */
-export declare const SCHEMA_VERSION = 1;
+export declare const SCHEMA_VERSION = 2;
 /** L1 semantics — anything in `parsers/` that changes normalized events. */
 export declare const PARSER_VERSION = 3;
 /** L2 rules — `writes.ts` / `ledger.ts`. Re-derives facts from stored events. */