@adhdev/daemon-core 0.9.82-rc.49 → 0.9.82-rc.491

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

@@ -0,0 +1,312 @@
+/**
+ * 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;
+    }
+}
+
+/**
+ * Expand an anchor session id to every session id in its logical cluster.
+ *
+ * hermes ≥0.14 splits a SINGLE logical turn across several `sessions` rows
+ * linked by `parent_session_id` (a 0-message intermediate row is common), and
+ * the turn's final assistant message lands in a DIFFERENT row than the one the
+ * daemon pins. A bidirectional walk — up the parent chain to the cluster root,
+ * then down through every descendant — returns the complete set from ANY anchor
+ * (root, middle, or leaf), mirroring the declarative executor's
+ * `session_cluster_query`. Falls back to the anchor alone if the schema has no
+ * `parent_session_id` column (older hermes) or the walk fails.
+ */
+function resolveClusterSessionIds(db: any, anchorId: string): string[] {
+    if (!anchorId) return [];
+    try {
+        const rows: any[] = db.prepare(
+            `WITH RECURSIVE
+               up(id) AS (
+                 SELECT id FROM sessions WHERE id = ?
+                 UNION
+                 SELECT s.parent_session_id FROM sessions s JOIN up ON s.id = up.id
+                   WHERE s.parent_session_id IS NOT NULL
+               ),
+               cluster(id) AS (
+                 SELECT id FROM up
+                 UNION
+                 SELECT s.id FROM sessions s JOIN cluster ON s.parent_session_id = cluster.id
+               )
+             SELECT id FROM cluster`,
+        ).all(anchorId);
+        const ids = new Set<string>([anchorId]);
+        for (const r of rows) {
+            if (r && r.id != null && String(r.id)) ids.add(String(r.id));
+        }
+        return Array.from(ids);
+    } catch {
+        // No parent_session_id column (older hermes) or a walk failure — the
+        // single anchor is still a valid (degenerate) cluster.
+        return [anchorId];
+    }
+}
+
+function loadMessagesForSession(db: any, sessionId: string): NativeHistoryMessage[] {
+    // Read the WHOLE sub-session cluster, not just the pinned anchor. hermes
+    // ≥0.14 writes a turn's final assistant into a descendant sub-session row,
+    // so an anchor-only read misses it → read_chat shows zero assistant bubbles
+    // and the completion gate false-fires missing_final_assistant. Gather every
+    // cluster member (parent-chain walk) and merge; the SQL `ORDER BY timestamp`
+    // re-interleaves bubbles from different sub-sessions into true chronological
+    // order so the final assistant lands last.
+    const clusterIds = resolveClusterSessionIds(db, sessionId);
+    if (clusterIds.length === 0) return [];
+    const placeholders = clusterIds.map(() => '?').join(', ');
+    // 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 IN (${placeholders})
+           AND ((content IS NOT NULL AND content != '') OR (tool_calls IS NOT NULL AND tool_calls != ''))
+         ORDER BY timestamp ASC, id ASC`,
+    ).all(...clusterIds);
+    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';

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

@@ -306,6 +306,77 @@ 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 `{ stamped: true }` when the stamp was
+     *  applied, or `{ stamped: false, reason }` when it was refused — the instance
+     *  was missing / has no attach method, or the DOUBLE-DISPATCH idempotence guard
+     *  fired (the same task is already running on another live session here). */
+    attachMeshAssignmentToInstance(instanceId: string, assignment: { meshId: string; nodeId?: string; taskId?: string; dispatchNonce?: number; coordinatorDaemonId?: string; coordinatorSessionId?: string }): { stamped: boolean; reason?: string } {
+        const inst = this.instances.get(instanceId);
+        if (!inst || typeof inst.attachMeshAssignment !== 'function') {
+            LOG.warn('MeshDispatch', `attachMeshAssignment skipped: instance ${instanceId} ${inst ? 'has no attach method' : 'not found'}`);
+            return { stamped: false, reason: inst ? 'instance_has_no_attach_method' : 'instance_not_found' };
+        }
+        // DOUBLE-DISPATCH stamp idempotence guard (defense in depth): refuse to stamp this
+        // (meshId, taskId) onto a SECOND instance when a DIFFERENT, still-live and actively
+        // working instance already holds the exact same task. Two sessions carrying one taskId
+        // double-execute the work (the auto-launch race RCA: a delayed claim by the original
+        // session plus the new session's post-boot claim sequentially stamp the same task —
+        // the atomic claim only blocks SIMULTANEOUS claims). A stale/dead/idle prior holder is
+        // NOT a conflict — a legitimate re-dispatch after a dispatch failure must still stamp.
+        if (assignment.taskId) {
+            const conflict = this.findLiveWorkingTaskHolder(assignment.meshId, assignment.taskId, instanceId);
+            if (conflict) {
+                LOG.warn('MeshDispatch', `attachMeshAssignment refused: task ${assignment.taskId} (mesh ${assignment.meshId}) is already being worked by live session ${conflict} — skipping duplicate stamp on ${instanceId}`);
+                return { stamped: false, reason: 'task_already_stamped_on_live_instance' };
+            }
+        }
+        inst.attachMeshAssignment(assignment);
+        LOG.info('MeshDispatch', `stamped mesh assignment on ${instanceId}: mesh=${assignment.meshId} node=${assignment.nodeId || ''} task=${assignment.taskId || ''} coordinator=${assignment.coordinatorDaemonId || ''}`);
+        return { stamped: true };
+    }
+
+    /**
+     * DOUBLE-DISPATCH support: the id of another LIVE, actively-working instance that already
+     * holds (meshId, taskId), or null. "Live working" = stamped with this exact mesh+task AND
+     * currently mid-turn / booting toward it (generating / waiting on approval-or-choice /
+     * starting) — NOT idle, stopped, or errored. A stale/dead/idle holder is deliberately
+     * ignored so a legitimate re-dispatch (e.g. after a dispatch failure) is never blocked.
+     * The instance being stamped (excludeInstanceId) is skipped so re-stamping the same
+     * session stays idempotent. O(n) over instances — the count is small.
+     */
+    private findLiveWorkingTaskHolder(meshId: string, taskId: string, excludeInstanceId: string): string | null {
+        // Mid-turn / booting statuses (top-level or activeChat). Anything else — idle, stopped,
+        // error — is not a live worker actively holding the task.
+        const working = new Set(['generating', 'waiting_approval', 'waiting_choice', 'starting', 'streaming', 'working', 'no_progress', 'long_generating']);
+        for (const [id, inst] of this.instances) {
+            if (id === excludeInstanceId) continue;
+            let state: ProviderState;
+            try {
+                state = inst.getState();
+            } catch {
+                continue;
+            }
+            const settings = (state.settings as Record<string, unknown>) || {};
+            if (settings.meshNodeFor !== meshId) continue;
+            if (settings.meshActiveTaskId !== taskId) continue;
+            const status = (typeof state.status === 'string' ? state.status : '').toLowerCase();
+            const chatStatus = (typeof state.activeChat?.status === 'string' ? state.activeChat.status : '').toLowerCase();
+            if (working.has(status) || working.has(chatStatus)) return id;
+        }
+        return null;
+    }
+
+    /** 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,9 +217,29 @@ 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; dispatchNonce?: number; coordinatorDaemonId?: string; coordinatorSessionId?: string }): void;
+    detachMeshAssignment?(): void;
+
     /** Refresh static provider definition/scripts without restarting the live runtime. */
     refreshProviderDefinition?(provider: ProviderModule): void;
 
+    /**
+     * Record that a human is actively attending this session by hand right now
+     * (foreground tab selection, controlbar use, manual approval, terminal
+     * input). Provider-common signal that suppresses auto-approve for a short
+     * window so the user can drive the session manually; background mesh worker
+     * sessions never receive it, so their delegated auto-approve is unaffected.
+     *
+     * `opts.passive` marks a view-only action (select_session / open_panel). A
+     * delegated worker session ignores passive stamps so a coordinator merely
+     * watching its panel does not suppress its delegated auto-approve; explicit
+     * input still attends. Foreground sessions attend on passive views too.
+     */
+    noteManualInteraction?(now?: number, opts?: { passive?: boolean }): void;
+
  /** cleanup */
     dispose(): void;
 }