@adhdev/daemon-core 0.9.82-rc.35 → 0.9.82-rc.350

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

@@ -0,0 +1,340 @@
+/**
+ * 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';
+
+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);
+        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);
+        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;
+}
+
+const CODEX_SPAWN_BIND_GRACE_MS = 10_000;
+
+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 > CODEX_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): string | null {
+    void workspace;
+    // agy brain/<uuid>/.system_generated/logs/transcript.jsonl
+    const brainRoot = path.join(os.homedir(), '.gemini', 'antigravity-cli', 'brain');
+    if (!fs.existsSync(brainRoot)) return null;
+    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)) return t;
+    }
+    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,
+): 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);
+        case 'hermes-cli':      return readHermesCliSession(sourcePath);
+    }
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// 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 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,230 @@
+/**
+ * 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[] {
+    const rows: any[] = db.prepare(
+        `SELECT id, role, content, timestamp
+         FROM messages
+         WHERE session_id = ? AND content IS NOT NULL AND content != ''
+         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): NativeHistorySession | null {
+    if (!sessionPath) return null;
+
+    // Path mode A: SQLite — sourcePath is the state.db path. Pick the
+    // newest source='cli' session that has at least one persisted message.
+    if (sessionPath === HERMES_STATE_DB) {
+        const db = openDb();
+        if (!db) return null;
+        try {
+            const row: any = db.prepare(
+                `SELECT id, started_at FROM sessions
+                 WHERE source = 'cli' AND message_count > 0
+                 ORDER BY started_at DESC LIMIT 1`,
+            ).get();
+            if (!row) return null;
+            const messages = loadMessagesForSession(db, row.id);
+            if (messages.length === 0) return null;
+            return {
+                messages,
+                providerSessionId: String(row.id),
+                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 message_count > 0
+                 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';

package/src/providers/provider-instance-manager.ts

@@ -306,6 +306,36 @@ export class ProviderInstanceManager {
         return updated;
     }
 
+    /** Stamp a mesh assignment on a single instance (used by mesh_send_task
+     *  --direct so the worker's completion event has a coordinator routing
+     *  marker in state.settings). Returns true if the instance existed and
+     *  the stamp was applied. */
+    attachMeshAssignmentToInstance(instanceId: string, assignment: { meshId: string; nodeId?: string; taskId?: string; coordinatorDaemonId?: string; coordinatorSessionId?: string }): boolean {
+        const inst = this.instances.get(instanceId);
+        if (!inst || typeof inst.attachMeshAssignment !== 'function') {
+            try {
+                const { LOG } = require('../logging/logger.js');
+                LOG.warn?.('MeshDispatch', `attachMeshAssignment skipped: instance ${instanceId} ${inst ? 'has no attach method' : 'not found'}`);
+            } catch { /* noop */ }
+            return false;
+        }
+        inst.attachMeshAssignment(assignment);
+        try {
+            const { LOG } = require('../logging/logger.js');
+            LOG.info?.('MeshDispatch', `stamped mesh assignment on ${instanceId}: mesh=${assignment.meshId} node=${assignment.nodeId || ''} task=${assignment.taskId || ''} coordinator=${assignment.coordinatorDaemonId || ''}`);
+        } catch { /* noop */ }
+        return true;
+    }
+
+    /** Clear a mesh assignment after the dispatched task reaches a terminal
+     *  state (generating_completed / stopped / failed). */
+    detachMeshAssignmentFromInstance(instanceId: string): boolean {
+        const inst = this.instances.get(instanceId);
+        if (!inst || typeof inst.detachMeshAssignment !== 'function') return false;
+        inst.detachMeshAssignment();
+        return true;
+    }
+
     refreshProviderDefinitions(resolveProvider: (providerType: string) => unknown): number {
         let refreshed = 0;
         for (const instance of this.instances.values()) {

package/src/providers/provider-instance.ts

@@ -12,10 +12,11 @@ import type { ProviderModule, ProviderSettingDef, ProviderResumeCapability } fro
 import type { AcpConfigOption, AcpMode, ProviderControlSchema, ProviderSummaryMetadata, SessionCapability } from '../shared-types.js';
 import type { MessageInputSupport } from './provider-input-support.js';
 import type { ChatMessage } from '../types.js';
+import type { InteractivePrompt } from './types/interactive-prompt.js';
 
 // ─── ProviderState — Discriminated union by category ─────────────
 
-export type ProviderStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting';
+export type ProviderStatus = 'idle' | 'generating' | 'waiting_approval' | 'waiting_choice' | 'error' | 'stopped' | 'starting';
 
 export interface ProviderRuntimeWriteOwner {
     clientId: string;
@@ -47,6 +48,7 @@ export interface ActiveChatData {
     status: string;
     messages: ChatMessage[];
     activeModal: { message: string; buttons: string[] } | null;
+    activeInteractivePrompt?: InteractivePrompt | null;
     inputContent?: string;
 }
 
@@ -72,6 +74,7 @@ interface ProviderStateBase {
     status: ProviderStatus;
  /** chat data */
     activeChat: ActiveChatData | null;
+    activeInteractivePrompt?: InteractivePrompt | null;
  /** Workspace — project path or name (all categories) */
     workspace?: string | null;
     /** Runtime info (real-time detection) */
@@ -214,6 +217,12 @@ export interface ProviderInstance {
  /** Update settings at runtime (called when user changes settings from dashboard) */
     updateSettings?(newSettings: Record<string, any>): void;
 
+    /** Stamp a direct-dispatch mesh task assignment so generating_completed
+     *  events route back to the originating coordinator. Cleared by
+     *  detachMeshAssignment when the task reaches a terminal state. */
+    attachMeshAssignment?(assignment: { meshId: string; nodeId?: string; taskId?: string; coordinatorDaemonId?: string; coordinatorSessionId?: string }): void;
+    detachMeshAssignment?(): void;
+
     /** Refresh static provider definition/scripts without restarting the live runtime. */
     refreshProviderDefinition?(provider: ProviderModule): void;