@1agents/session-reader 0.6.2 → 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/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

@@ -22,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, ?) = ?)');
@@ -45,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.

package/dist/src/web/api.d.ts

@@ -0,0 +1,72 @@
+import type { ServerResponse } from 'node:http';
+import type { NormalizedSession } from '../types.js';
+export interface SessionApiOptions {
+    /** Used when the client asks for scope=cwd but does not send ?workspace=. */
+    fallbackCwd: string;
+}
+export declare function resolveListWorkspace(scope: string | null, workspace: string | null, fallbackCwd: string): string | undefined;
+/** Chat-preview turns. Built only after the user clicks a session. */
+export declare function previewTurns(normalized: NormalizedSession): {
+    no: number;
+    turn: number;
+    status: import("../types.js").TurnStatus;
+    prompt: string;
+    userPrompt: string;
+    outcome: string;
+    assistantReply: string;
+    thinking: string;
+    thinkingBlocks: string[];
+    toolCalls: any[];
+    files: string[];
+    commands: number;
+    errors: number;
+    startedAt: string | undefined;
+    endedAt: string | undefined;
+    durationMs: number | undefined;
+}[];
+export declare function sessionPreview(sessionId: string): Promise<{
+    ref: import("../types.js").SessionRef;
+    stats: import("../types.js").ProviderStats;
+    overview: import("../types.js").SessionOverview;
+    turns: {
+        no: number;
+        turn: number;
+        status: import("../types.js").TurnStatus;
+        prompt: string;
+        userPrompt: string;
+        outcome: string;
+        assistantReply: string;
+        thinking: string;
+        thinkingBlocks: string[];
+        toolCalls: any[];
+        files: string[];
+        commands: number;
+        errors: number;
+        startedAt: string | undefined;
+        endedAt: string | undefined;
+        durationMs: number | undefined;
+    }[];
+    files: {
+        displayPath: string;
+        path: string;
+        host?: string;
+        operation: string;
+        turn: number;
+        eventIndex: number;
+        timestamp?: string;
+        provenance: import("../types.js").Provenance;
+        extractor: string;
+        group: import("../types.js").FileGroup;
+    }[];
+}>;
+export declare function listSessionsForUi(options: {
+    limit?: number;
+    provider?: string;
+    since?: string;
+    workspace?: string;
+}): Promise<import("../types.js").SessionRef[]>;
+/**
+ * Shared JSON API used by the DSH plugin and `1session web`.
+ * Path is already stripped of `/api/session-reader`. Returns false if unmatched.
+ */
+export declare function handleSessionApi(pathname: string, url: URL, res: ServerResponse, options: SessionApiOptions): Promise<boolean>;