@adhdev/daemon-core 0.9.82-rc.45 → 0.9.82-rc.451

package/src/providers/native-history/dispatcher.ts

@@ -0,0 +1,373 @@
+/**
+ * Spec-aware dispatcher for native conversation history.
+ *
+ * The four existing readers (claude/codex/antigravity/hermes) already know
+ * how to parse each agent's on-disk format. This dispatcher just resolves
+ * the right file given a workspace + sessionId hint, then hands it off.
+ *
+ * Wired into ProviderModule.scripts.readNativeHistory by provider-loader
+ * when spec.json declares native_history.reader. The script signature
+ * matches what chat-history.ts expects (see callProviderNativeHistoryRead).
+ */
+'use strict';
+
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { readSession as readClaudeCliSession } from './claude-cli-transcript.js';
+import { readSession as readCodexCliSession } from './codex-cli-transcript.js';
+import { readSession as readAntigravityCliSession } from './antigravity-cli-transcript.js';
+import { readSession as readHermesCliSession } from './hermes-cli-transcript.js';
+import { SPAWN_BIND_GRACE_MS } from './constants.js';
+
+export type ReaderId = 'claude-cli' | 'codex-cli' | 'antigravity-cli' | 'hermes-cli';
+
+export interface NativeHistoryInput {
+    agentType?: string;
+    sessionId?: string;
+    providerSessionId?: string;
+    historySessionId?: string;
+    workspace?: string;
+    sessionStartedAtMs?: number;
+    format?: string;
+    watchPath?: string;
+    forceRefresh?: boolean;
+    args?: Record<string, unknown>;
+}
+
+export interface NativeHistoryResult {
+    messages: Array<{ role: string; content: string; receivedAt?: number; kind?: string; workspace?: string }>;
+    providerSessionId?: string;
+    sourcePath: string;
+    sourceMtimeMs: number;
+    nativeHistoryCoverage?: 'full' | 'partial' | 'best-effort';
+}
+
+export function createNativeHistoryDispatcher(reader: ReaderId): (input: NativeHistoryInput) => NativeHistoryResult | null {
+    return (input: NativeHistoryInput) => {
+        const workspace = input.workspace || '';
+        const sessionId = input.sessionId || input.historySessionId || '';
+        // Caller may pass a providerSessionId (the *provider's own* id, e.g.
+        // the uuid claude writes into the jsonl basename). When present, the
+        // dispatcher only returns a transcript whose file id matches —
+        // otherwise the newest_by_mtime fallback can surface a different
+        // session's chat (round 9 part b: the user reported "previous chat
+        // shows up before I type anything" on every provider).
+        const requestedProviderSid = input.providerSessionId || '';
+
+        const sessionStartedAtMs = typeof input.sessionStartedAtMs === 'number'
+            ? input.sessionStartedAtMs
+            : typeof input.args?.sessionStartedAtMs === 'number'
+                ? input.args.sessionStartedAtMs
+                : 0;
+        const sourcePath = resolveSourcePath(reader, workspace, sessionId, sessionStartedAtMs);
+        if (!sourcePath) return null;
+        if (input.forceRefresh === true || input.args?.forceRefresh === true) {
+            try { fs.statSync(sourcePath); } catch { /* best-effort metadata refresh */ }
+        }
+
+        const session = readByReader(reader, sourcePath, sessionId, workspace, requestedProviderSid);
+        if (!session) return null;
+
+        if (requestedProviderSid && session.providerSessionId && session.providerSessionId !== requestedProviderSid) {
+            return null;
+        }
+
+        return {
+            messages: session.messages.map((m: any) => ({
+                role: normalizeRole(m.role),
+                content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+                receivedAt: typeof m.receivedAt === 'number' ? m.receivedAt : Date.parse(m.timestamp || '') || Date.now(),
+                kind: typeof m.kind === 'string' ? m.kind : 'standard',
+                workspace: typeof m.workspace === 'string' ? m.workspace : workspace || undefined,
+            })),
+            providerSessionId: session.providerSessionId,
+            sourcePath: session.sourcePath,
+            sourceMtimeMs: session.sourceMtimeMs,
+            nativeHistoryCoverage: (session as any).nativeHistoryCoverage || 'full',
+        };
+    };
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Per-provider path resolution
+// ────────────────────────────────────────────────────────────────────────────
+
+function resolveSourcePath(reader: ReaderId, workspace: string, sessionId: string, sessionStartedAtMs: number): string | null {
+    switch (reader) {
+        case 'claude-cli':   return resolveClaudePath(workspace, sessionId);
+        case 'codex-cli':    return resolveCodexPath(workspace, sessionId, sessionStartedAtMs);
+        case 'antigravity-cli': return resolveAntigravityPath(workspace, sessionId);
+        case 'hermes-cli':   return resolveHermesPath(workspace, sessionId);
+    }
+}
+
+function resolveClaudePath(workspace: string, sessionId: string): string | null {
+    // claude stores per-cwd: ~/.claude/projects/<cwd-as-dashes>/<uuid>.jsonl
+    const dir = path.join(os.homedir(), '.claude', 'projects', cwdAsDashes(workspace));
+    if (!fs.existsSync(dir)) return null;
+    if (sessionId) {
+        const candidate = path.join(dir, `${sessionId}.jsonl`);
+        if (fs.existsSync(candidate)) return candidate;
+    }
+    // No exact match: return null. The newest_by_mtime fallback used to
+    // grab whichever transcript was touched most recently, but that
+    // surfaced a different (often the user's *external* claude session
+    // in the same workspace) chat in the dashboard before the user
+    // typed anything. The right answer is to show nothing until either
+    // the daemon's sessionId actually maps to a file or the caller
+    // passes the correct providerSessionId (round 9 part b).
+    return null;
+}
+
+function resolveCodexPath(workspace: string, sessionId: string, sessionStartedAtMs: number): string | null {
+    // codex stores by UTC date: ~/.codex/sessions/<year>/<month>/<day>/<file>.jsonl
+    const root = codexSessionsRoot();
+    if (sessionId && isUuidLikeSessionId(sessionId)) {
+        return findCodexPathBySessionId(root, sessionId);
+    }
+    return findCodexPathByRuntime(root, workspace, sessionStartedAtMs);
+}
+
+function findCodexPathBySessionId(root: string, sessionId: string): string | null {
+    if (!fs.existsSync(root)) return null;
+    const needle = sessionId.toLowerCase();
+    const matches: Array<{ p: string; mtime: number }> = [];
+    const stack: string[] = [root];
+    while (stack.length > 0) {
+        const current = stack.pop()!;
+        let entries: fs.Dirent[] = [];
+        try { entries = fs.readdirSync(current, { withFileTypes: true }); } catch { continue; }
+        for (const entry of entries) {
+            const entryPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(entryPath);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue;
+            if (!entry.name.toLowerCase().includes(needle)) continue;
+            if (!isSafeFilename(entry.name.replace('.jsonl', ''))) continue;
+            matches.push({ p: entryPath, mtime: safeMtime(entryPath) });
+        }
+    }
+    matches.sort((a, b) => b.mtime - a.mtime);
+    return matches[0]?.p ?? null;
+}
+
+function findCodexPathByRuntime(root: string, workspace: string, sessionStartedAtMs: number): string | null {
+    if (!fs.existsSync(root) || !workspace) return null;
+    const workspaceResolved = resolveRealPath(workspace);
+    const cutoff = Date.now() - RECENT_WINDOW_MS;
+    const matches: Array<{ p: string; mtime: number; diff: number }> = [];
+    const stack: string[] = [root];
+
+    while (stack.length > 0) {
+        const current = stack.pop()!;
+        let entries: fs.Dirent[] = [];
+        try { entries = fs.readdirSync(current, { withFileTypes: true }); } catch { continue; }
+        for (const entry of entries) {
+            const entryPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(entryPath);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue;
+            const mtime = safeMtime(entryPath);
+            if (mtime < cutoff) continue;
+            const meta = readCodexSessionMeta(entryPath);
+            if (!meta?.cwd || resolveRealPath(meta.cwd) !== workspaceResolved) continue;
+            const diff = sessionStartedAtMs > 0 && meta.timestampMs != null
+                ? Math.abs(meta.timestampMs - sessionStartedAtMs)
+                : 0;
+            if (sessionStartedAtMs > 0 && (meta.timestampMs == null || diff > SPAWN_BIND_GRACE_MS)) continue;
+            matches.push({ p: entryPath, mtime, diff });
+        }
+    }
+
+    matches.sort((a, b) => sessionStartedAtMs > 0
+        ? a.diff - b.diff || b.mtime - a.mtime
+        : b.mtime - a.mtime);
+    return matches[0]?.p ?? null;
+}
+
+function readCodexSessionMeta(filePath: string): { cwd?: string; timestampMs?: number } | null {
+    try {
+        const fd = fs.openSync(filePath, 'r');
+        try {
+            const buffer = Buffer.alloc(8192);
+            const bytes = fs.readSync(fd, buffer, 0, buffer.length, 0);
+            if (bytes <= 0) return null;
+            const text = buffer.subarray(0, bytes).toString('utf8');
+            const firstLine = text.slice(0, text.indexOf('\n') >= 0 ? text.indexOf('\n') : text.length).trim();
+            if (!firstLine) return null;
+            const record = JSON.parse(firstLine) as Record<string, unknown>;
+            if (record.type !== 'session_meta' || !record.payload || typeof record.payload !== 'object') return null;
+            const payload = record.payload as Record<string, unknown>;
+            const timestampRaw = payload.timestamp;
+            const timestampMs = typeof timestampRaw === 'string'
+                ? Date.parse(timestampRaw)
+                : typeof timestampRaw === 'number'
+                    ? (timestampRaw < 1e12 ? timestampRaw * 1000 : timestampRaw)
+                    : NaN;
+            return {
+                cwd: typeof payload.cwd === 'string' ? payload.cwd : undefined,
+                timestampMs: Number.isFinite(timestampMs) ? timestampMs : undefined,
+            };
+        } finally {
+            fs.closeSync(fd);
+        }
+    } catch {
+        return null;
+    }
+}
+
+function resolveRealPath(value: string): string {
+    try { return fs.realpathSync(value); } catch { return value; }
+}
+
+function resolveAntigravityPath(workspace: string, sessionId: string): string | null {
+    void workspace;
+    const agyRoot = path.join(os.homedir(), '.gemini', 'antigravity-cli');
+
+    // (1) Exact session bind: current antigravity writes a per-session SQLite db
+    //     at conversations/<uuid>.db. If the caller knows the session id and the
+    //     db exists, bind straight to it — this is the authoritative source and
+    //     carries the assistant answers the brain/pty path was losing.
+    if (sessionId && isUuidLikeSessionId(sessionId)) {
+        const dbPath = path.join(agyRoot, 'conversations', `${sessionId}.db`);
+        if (fs.existsSync(dbPath)) return dbPath;
+    }
+
+    // (2) brain/<uuid>/.system_generated/logs/transcript.jsonl (legacy full source).
+    //     Only bind to a brain transcript that is NON-EMPTY: current antigravity
+    //     writes this file but leaves it 0 bytes (all real conversation data now
+    //     lives in the per-session .db), so an empty transcript here would
+    //     otherwise shadow the .db fallback below and return no messages. Skip
+    //     empty transcripts so an unbound read still reaches the .db.
+    const brainRoot = path.join(agyRoot, 'brain');
+    if (fs.existsSync(brainRoot)) {
+        const cutoff = Date.now() - RECENT_WINDOW_MS;
+        const entries = fs.readdirSync(brainRoot, { withFileTypes: true })
+            .filter(e => e.isDirectory())
+            .map(e => ({ p: path.join(brainRoot, e.name), mtime: safeMtime(path.join(brainRoot, e.name)) }))
+            .filter(e => e.mtime >= cutoff)
+            .sort((a, b) => b.mtime - a.mtime);
+        for (const e of entries) {
+            const t = path.join(e.p, '.system_generated', 'logs', 'transcript.jsonl');
+            if (fs.existsSync(t) && safeSize(t) > 0) return t;
+        }
+    }
+
+    // (3) No brain transcript and no bound session id: fall back to the most
+    //     recently touched conversations/<uuid>.db (within the recency window).
+    const convRoot = path.join(agyRoot, 'conversations');
+    const newestDb = newestRecentFile(convRoot, /^[0-9a-f-]+\.db$/i);
+    if (newestDb) return newestDb;
+
+    return null;
+}
+
+function resolveHermesPath(workspace: string, sessionId: string): string | null {
+    void workspace; void sessionId;
+    // Hermes ≥ 0.14 persists all chat to ~/.hermes/state.db (SQLite). The
+    // db file is the "path" we hand to the reader — it pulls the newest
+    // source='cli' session inside readSession.
+    const dbPath = path.join(os.homedir(), '.hermes', 'state.db');
+    if (fs.existsSync(dbPath)) return dbPath;
+    // Legacy fallback: pre-db hermes wrote per-session JSON dumps.
+    const dir = path.join(os.homedir(), '.hermes', 'sessions');
+    if (!fs.existsSync(dir)) return null;
+    return newestRecentFile(dir, /^session_.*\.json$/);
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Reader dispatch
+// ────────────────────────────────────────────────────────────────────────────
+
+function readByReader(
+    reader: ReaderId,
+    sourcePath: string,
+    sessionId: string,
+    workspace: string,
+    requestedProviderSid: string,
+): any | null {
+    switch (reader) {
+        case 'claude-cli':      return readClaudeCliSession(sourcePath);
+        case 'codex-cli':       return readCodexCliSession(sourcePath);
+        case 'antigravity-cli': return readAntigravityCliSession(sourcePath, sessionId || undefined, workspace || undefined);
+        // hermes reads a *shared* state.db and would otherwise pick the newest
+        // source='cli' session, which drifts every read (hermes ≥0.14 writes a
+        // fresh row per internal sub-session). Pass the bound id so it reads
+        // THAT session directly instead of newest-wins. claude/codex resolve a
+        // per-session file upstream, so they need no equivalent pin here.
+        case 'hermes-cli':      return readHermesCliSession(sourcePath, requestedProviderSid || undefined);
+    }
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ────────────────────────────────────────────────────────────────────────────
+
+function cwdAsDashes(cwd: string): string {
+    if (!cwd) return '';
+    return cwd.replace(/\//g, '-');
+}
+
+function codexSessionsRoot(): string {
+    return path.join(os.homedir(), '.codex', 'sessions');
+}
+
+function isUuidLikeSessionId(sessionId: string): boolean {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId);
+}
+
+function isSafeFilename(name: string): boolean {
+    return /^[A-Za-z0-9._:-]+$/.test(name) && !name.includes('..');
+}
+
+function newestFile(dir: string, pattern: RegExp): string | null {
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true })
+            .filter(e => e.isFile() && pattern.test(e.name))
+            .map(e => ({ p: path.join(dir, e.name), mtime: safeMtime(path.join(dir, e.name)) }))
+            .sort((a, b) => b.mtime - a.mtime);
+        return entries[0]?.p ?? null;
+    } catch { return null; }
+}
+
+/**
+ * Like newestFile but only returns a candidate when its mtime is within
+ * the recent activity window. Prevents the dashboard from surfacing a
+ * prior session's transcript when the daemon's sessionId doesn't match
+ * any file on disk (e.g. claude allocates its own uuid; daemon and
+ * agent disagree about what the "current" session is).
+ */
+const RECENT_WINDOW_MS = 5 * 60 * 1000;
+function newestRecentFile(dir: string, pattern: RegExp): string | null {
+    try {
+        const cutoff = Date.now() - RECENT_WINDOW_MS;
+        const entries = fs.readdirSync(dir, { withFileTypes: true })
+            .filter(e => e.isFile() && pattern.test(e.name))
+            .map(e => ({ p: path.join(dir, e.name), mtime: safeMtime(path.join(dir, e.name)) }))
+            .filter(e => e.mtime >= cutoff)
+            .sort((a, b) => b.mtime - a.mtime);
+        return entries[0]?.p ?? null;
+    } catch { return null; }
+}
+
+function safeMtime(p: string): number {
+    try { return Math.floor(fs.statSync(p).mtimeMs); } catch { return 0; }
+}
+
+function safeSize(p: string): number {
+    try { return fs.statSync(p).size; } catch { return 0; }
+}
+
+function normalizeRole(r: any): 'user' | 'assistant' | 'system' {
+    const s = String(r ?? '').toLowerCase();
+    if (s === 'user' || s === 'human') return 'user';
+    if (s === 'assistant' || s === 'ai' || s === 'model') return 'assistant';
+    // daemon's chat schema rejects 'tool'/'function' — surface as assistant.
+    if (s === 'tool' || s === 'tool_result' || s === 'function') return 'assistant';
+    return 'system';
+}

package/src/providers/native-history/hermes-cli-transcript.ts

@@ -0,0 +1,260 @@
+/**
+ * Hermes Agent — native history adapter.
+ *
+ * Hermes persists state in ~/.hermes/state.db (SQLite, better-sqlite3):
+ *   sessions(id, source, started_at, ended_at, message_count, ...)
+ *   messages(id, session_id, role, content, timestamp, ...)
+ *
+ * Earlier releases dumped per-session JSON files under ~/.hermes/sessions/;
+ * recent hermes (≥ 0.14) writes only to state.db. We read straight from
+ * the db when available and fall back to scanning legacy JSON dumps for
+ * archived sessions.
+ *
+ * The dispatcher hands us a sourcePath (the file the resolveHermesPath
+ * function picks). For the SQLite case the "path" is the db file itself
+ * and we resolve the most recent cli-source session inside readSession.
+ */
+'use strict';
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { loadBetterSqlite3 } from '../../system/load-better-sqlite3.js';
+
+export interface NativeHistoryMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    receivedAt: number;
+    kind?: string;
+}
+
+export interface NativeHistorySession {
+    messages: NativeHistoryMessage[];
+    providerSessionId: string;
+    source: 'provider-native';
+    sourcePath: string;
+    sourceMtimeMs: number;
+    nativeHistoryCoverage: 'full';
+    workspace?: string;
+}
+
+export interface NativeHistorySessionMeta {
+    historySessionId: string;
+    sessionId: string;
+    sourcePath: string;
+    sourceMtimeMs: number;
+    messageCount: number;
+    firstMessageAt: number;
+    lastMessageAt: number;
+    sessionTitle?: string;
+    preview?: string;
+    workspace?: string;
+}
+
+const HERMES_STATE_DB = path.join(os.homedir(), '.hermes', 'state.db');
+const HERMES_LEGACY_SESSIONS_DIR = path.join(os.homedir(), '.hermes', 'sessions');
+
+function statMtimeMs(p: string): number {
+    try { return Math.floor(fs.statSync(p).mtimeMs); } catch { return 0; }
+}
+
+function openDb(): any | null {
+    if (!fs.existsSync(HERMES_STATE_DB)) return null;
+    try {
+        const Database = loadBetterSqlite3();
+        return new Database(HERMES_STATE_DB, { readonly: true, fileMustExist: true });
+    } catch {
+        return null;
+    }
+}
+
+function loadMessagesForSession(db: any, sessionId: string): NativeHistoryMessage[] {
+    // Assistant turns whose finish_reason='tool_calls' persist an EMPTY
+    // `content` — their payload lives in the `tool_calls` column. Filtering on
+    // `content != ''` alone drops those rows, so a turn whose terminal message
+    // is a tool call surfaces zero assistant bubbles. Accept a row when either
+    // `content` OR `tool_calls` is non-empty, and project `tool_calls` into the
+    // content slot when `content` is empty so the bubble still carries text.
+    const rows: any[] = db.prepare(
+        `SELECT id, role, COALESCE(NULLIF(content, ''), tool_calls) AS content, timestamp
+         FROM messages
+         WHERE session_id = ?
+           AND ((content IS NOT NULL AND content != '') OR (tool_calls IS NOT NULL AND tool_calls != ''))
+         ORDER BY timestamp ASC, id ASC`,
+    ).all(sessionId);
+    const out: NativeHistoryMessage[] = [];
+    for (const r of rows) {
+        const role = normalizeHermesRole(r.role);
+        // Hermes stores some tool/system rows under role='tool'; surface as
+        // 'assistant' so they don't get dropped on the daemon's chat schema
+        // validation (role must be user/assistant/system).
+        out.push({
+            id: String(r.id),
+            role,
+            content: String(r.content),
+            receivedAt: Math.floor(Number(r.timestamp) * 1000),
+            kind: 'standard',
+        });
+    }
+    return out;
+}
+
+export function readSession(sessionPath: string, requestedSessionId?: string): NativeHistorySession | null {
+    if (!sessionPath) return null;
+
+    // Path mode A: SQLite — sourcePath is the state.db path.
+    if (sessionPath === HERMES_STATE_DB) {
+        const db = openDb();
+        if (!db) return null;
+        try {
+            const pinned = String(requestedSessionId || '').trim();
+            let sessionId: string;
+            if (pinned) {
+                // Session pin: the caller is already bound to a specific
+                // provider session, so read THAT session directly instead of
+                // the newest-wins pick below. hermes ≥0.14 writes a fresh
+                // `sessions` row per internal sub-session, so an unpinned
+                // `ORDER BY started_at DESC LIMIT 1` drifts to a different id
+                // on every read → re-bind churn + reading completion evidence
+                // from the wrong session. loadMessagesForSession returning
+                // rows validates the id exists.
+                sessionId = pinned;
+            } else {
+                // No bound id yet (discovery): pick the newest source='cli'
+                // session that has at least one persisted message. Use an
+                // EXISTS check against `messages` rather than the denormalized
+                // `message_count` column — a freshly-started session already
+                // has message rows while `message_count` (DEFAULT 0) can still
+                // lag at 0, and the old predicate excluded exactly that
+                // just-created session, resolving to nothing.
+                const row: any = db.prepare(
+                    `SELECT id, started_at FROM sessions
+                     WHERE source = 'cli'
+                       AND EXISTS (SELECT 1 FROM messages m WHERE m.session_id = sessions.id)
+                     ORDER BY started_at DESC LIMIT 1`,
+                ).get();
+                if (!row) return null;
+                sessionId = String(row.id);
+            }
+            const messages = loadMessagesForSession(db, sessionId);
+            if (messages.length === 0) return null;
+            return {
+                messages,
+                providerSessionId: sessionId,
+                source: 'provider-native',
+                sourcePath: sessionPath,
+                sourceMtimeMs: statMtimeMs(sessionPath),
+                nativeHistoryCoverage: 'full',
+            };
+        } finally {
+            try { db.close(); } catch { /* ignore */ }
+        }
+    }
+
+    // Path mode B: legacy JSON dump — keep the old reader for archived
+    // sessions that pre-date the db format.
+    if (!path.isAbsolute(sessionPath) || !fs.existsSync(sessionPath)) return null;
+    let raw: any;
+    try { raw = JSON.parse(fs.readFileSync(sessionPath, 'utf8')); } catch { return null; }
+    if (!raw || typeof raw !== 'object') return null;
+    const rawMessages = Array.isArray(raw.messages) ? raw.messages : [];
+    if (rawMessages.length === 0) return null;
+    const sourceMtimeMs = statMtimeMs(sessionPath);
+    const sessionStart = Number(raw.session_start) || sourceMtimeMs - rawMessages.length * 1000;
+    const messages: NativeHistoryMessage[] = [];
+    for (let i = 0; i < rawMessages.length; i += 1) {
+        const m = rawMessages[i];
+        const content = typeof m?.content === 'string' ? m.content : '';
+        if (!content) continue;
+        messages.push({
+            id: typeof m?.id === 'string' ? m.id : `msg_${i}`,
+            role: normalizeHermesRole(m?.role),
+            content,
+            receivedAt: sessionStart + i * 1000,
+            kind: 'standard',
+        });
+    }
+    if (messages.length === 0) return null;
+    const sessionId = typeof raw.session_id === 'string' && raw.session_id
+        ? raw.session_id
+        : path.basename(sessionPath, '.json').replace(/^session_/, '');
+    return {
+        messages,
+        providerSessionId: sessionId,
+        source: 'provider-native',
+        sourcePath: sessionPath,
+        sourceMtimeMs,
+        nativeHistoryCoverage: 'full',
+    };
+}
+
+export async function listSessions(_watchPath: string): Promise<NativeHistorySessionMeta[]> {
+    const out: NativeHistorySessionMeta[] = [];
+
+    const db = openDb();
+    if (db) {
+        try {
+            const rows: any[] = db.prepare(
+                `SELECT id, started_at, ended_at, message_count, title
+                 FROM sessions
+                 WHERE source = 'cli'
+                   AND EXISTS (SELECT 1 FROM messages m WHERE m.session_id = sessions.id)
+                 ORDER BY started_at DESC LIMIT 100`,
+            ).all();
+            const mtime = statMtimeMs(HERMES_STATE_DB);
+            for (const r of rows) {
+                out.push({
+                    historySessionId: String(r.id),
+                    sessionId: String(r.id),
+                    sourcePath: HERMES_STATE_DB,
+                    sourceMtimeMs: mtime,
+                    messageCount: Number(r.message_count) || 0,
+                    firstMessageAt: Math.floor(Number(r.started_at) * 1000),
+                    lastMessageAt: Math.floor(Number(r.ended_at || r.started_at) * 1000),
+                    sessionTitle: typeof r.title === 'string' ? r.title : undefined,
+                });
+            }
+        } finally {
+            try { db.close(); } catch { /* ignore */ }
+        }
+    }
+
+    if (fs.existsSync(HERMES_LEGACY_SESSIONS_DIR)) {
+        for (const name of fs.readdirSync(HERMES_LEGACY_SESSIONS_DIR)) {
+            if (!/^session_.*\.json$/.test(name)) continue;
+            const p = path.join(HERMES_LEGACY_SESSIONS_DIR, name);
+            const mtime = statMtimeMs(p);
+            if (!mtime) continue;
+            let raw: any;
+            try { raw = JSON.parse(fs.readFileSync(p, 'utf8')); } catch { continue; }
+            const msgs = Array.isArray(raw?.messages) ? raw.messages : [];
+            if (msgs.length === 0) continue;
+            const sessionId = typeof raw.session_id === 'string' && raw.session_id
+                ? raw.session_id
+                : name.replace(/^session_/, '').replace(/\.json$/, '');
+            out.push({
+                historySessionId: sessionId,
+                sessionId,
+                sourcePath: p,
+                sourceMtimeMs: mtime,
+                messageCount: msgs.length,
+                firstMessageAt: Number(raw.session_start) || mtime,
+                lastMessageAt: Number(raw.last_updated) || mtime,
+                sessionTitle: typeof raw.title === 'string' ? raw.title : undefined,
+                preview: typeof msgs[0]?.content === 'string' ? String(msgs[0].content).slice(0, 80) : undefined,
+            });
+        }
+    }
+
+    out.sort((a, b) => b.sourceMtimeMs - a.sourceMtimeMs);
+    return out;
+}
+
+function normalizeHermesRole(r: any): 'user' | 'assistant' | 'system' {
+    const s = String(r ?? '').toLowerCase();
+    if (s === 'user' || s === 'human') return 'user';
+    if (s === 'assistant' || s === 'ai' || s === 'model') return 'assistant';
+    if (s === 'tool' || s === 'tool_result' || s === 'function') return 'assistant';
+    return 'system';
+}

package/src/providers/native-history/index.ts

@@ -0,0 +1,30 @@
+/**
+ * native-history — Daemon-side built-in adapters for CLI provider native history.
+ *
+ * Each adapter reads conversation history directly from the CLI tool's on-disk
+ * storage without shelling out to a provider JS override script.
+ *
+ * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
+ */
+
+export {
+  readSession as readClaudeCliSession,
+  listSessions as listClaudeCliSessions,
+} from './claude-cli-transcript.js';
+
+export {
+  readSession as readCodexCliSession,
+  listSessions as listCodexCliSessions,
+} from './codex-cli-transcript.js';
+
+export {
+  readSession as readAntigravityCliSession,
+  listSessions as listAntigravityCliSessions,
+} from './antigravity-cli-transcript.js';
+
+export {
+  readSession as readHermesCliSession,
+  listSessions as listHermesCliSessions,
+} from './hermes-cli-transcript.js';
+
+export { createNativeHistoryDispatcher, type ReaderId } from './dispatcher.js';