@adhdev/daemon-core 0.9.44 → 0.9.46

package/src/config/chat-history.ts

@@ -13,7 +13,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { buildRuntimeSystemChatMessage } from '../providers/chat-message-normalization.js';
-import type { ProviderHistoryBehavior } from '../providers/contracts.js';
+import type { ProviderCanonicalHistoryConfig, ProviderHistoryBehavior } from '../providers/contracts.js';
 
 const HISTORY_DIR = path.join(os.homedir(), '.adhdev', 'history');
 const RETAIN_DAYS = 30;
@@ -170,6 +170,9 @@ export interface SavedHistorySessionSummary {
     lastMessageAt: number;
     preview?: string;
     workspace?: string;
+    source?: 'adhdev-mirror' | 'provider-native';
+    sourcePath?: string;
+    sourceMtimeMs?: number;
 }
 
 function sortSavedHistorySessionSummaries(summaries: SavedHistorySessionSummary[]): SavedHistorySessionSummary[] {
@@ -1138,6 +1141,37 @@ export class ChatHistoryWriter {
  * the newest N messages are skipped so older-history pagination can avoid
  * duplicating the live transcript tail already shown in the UI.
  */
+function pageHistoryRecords(
+    agentType: string,
+    records: HistoryMessage[],
+    offset: number = 0,
+    limit: number = 30,
+    excludeRecentCount: number = 0,
+    historyBehavior?: ProviderHistoryBehavior,
+): { messages: HistoryMessage[]; hasMore: boolean } {
+    const allMessages = records
+        .map((message) => sanitizeHistoryMessage(agentType, message))
+        .filter(Boolean) as HistoryMessage[];
+    allMessages.sort((a, b) => a.receivedAt - b.receivedAt);
+    const chronological: HistoryMessage[] = [];
+    let lastTurn: HistoryMessage | null = null;
+    for (const message of allMessages) {
+        const previous = chronological[chronological.length - 1];
+        if (isAdjacentHistoryDuplicate(agentType, previous, message)) continue;
+        if (message.role !== 'system' && isAdjacentHistoryDuplicate(agentType, lastTurn, message)) continue;
+        chronological.push(message);
+        if (message.role !== 'system') lastTurn = message;
+    }
+    const collapsed = collapseReplayAssistantTurns(chronological, historyBehavior);
+    const boundedLimit = Math.max(1, limit);
+    const boundedOffset = Math.max(0, offset);
+    const boundedExclude = Math.max(0, Math.min(excludeRecentCount, collapsed.length));
+    const endExclusive = Math.max(0, collapsed.length - boundedExclude - boundedOffset);
+    const startInclusive = Math.max(0, endExclusive - boundedLimit);
+    const sliced = collapsed.slice(startInclusive, endExclusive);
+    return { messages: sliced, hasMore: startInclusive > 0 };
+}
+
 export function readChatHistory(
     agentType: string,
     offset: number = 0,
@@ -1175,29 +1209,7 @@ export function readChatHistory(
             }
         }
 
-        allMessages.sort((a, b) => a.receivedAt - b.receivedAt);
-        const chronological: HistoryMessage[] = [];
-        let lastTurn: HistoryMessage | null = null;
-        for (const message of allMessages) {
-            const previous = chronological[chronological.length - 1];
-            if (isAdjacentHistoryDuplicate(agentType, previous, message)) continue;
-            if (message.role !== 'system' && isAdjacentHistoryDuplicate(agentType, lastTurn, message)) continue;
-            chronological.push(message);
-            if (message.role !== 'system') lastTurn = message;
-        }
-        const collapsed = collapseReplayAssistantTurns(chronological, historyBehavior);
-
- // Page backwards from the newest saved messages while keeping the returned
- // slice in chronological order for prepend-based UI rendering.
-        const boundedLimit = Math.max(1, limit);
-        const boundedOffset = Math.max(0, offset);
-        const boundedExclude = Math.max(0, Math.min(excludeRecentCount, collapsed.length));
-        const endExclusive = Math.max(0, collapsed.length - boundedExclude - boundedOffset);
-        const startInclusive = Math.max(0, endExclusive - boundedLimit);
-        const sliced = collapsed.slice(startInclusive, endExclusive);
-        const hasMore = startInclusive > 0;
-
-        return { messages: sliced, hasMore };
+        return pageHistoryRecords(agentType, allMessages, offset, limit, excludeRecentCount, historyBehavior);
     } catch {
         return { messages: [], hasMore: false };
     }
@@ -1276,34 +1288,6 @@ export function listSavedHistorySessions(
     }
 }
 
-function normalizeCanonicalHermesMessageContent(content: unknown): string {
-    if (typeof content === 'string') return content.trim();
-    if (content == null) return '';
-    try {
-        return JSON.stringify(content).trim();
-    } catch {
-        return String(content).trim();
-    }
-}
-
-function extractCanonicalHermesMessageTimestamp(message: Record<string, unknown>, fallbackTs: number): number {
-    const numericTimestamp = Number(message.receivedAt || message.timestamp || message.ts || 0);
-    if (Number.isFinite(numericTimestamp) && numericTimestamp > 0) return numericTimestamp;
-    const stringTimestamp = typeof message.ts === 'string'
-        ? Date.parse(message.ts)
-        : (typeof message.timestamp === 'string' ? Date.parse(message.timestamp) : NaN);
-    if (Number.isFinite(stringTimestamp) && stringTimestamp > 0) return stringTimestamp;
-    return fallbackTs;
-}
-
-function extractTimestampValue(value: unknown): number {
-    const numericTimestamp = Number(value || 0);
-    if (Number.isFinite(numericTimestamp) && numericTimestamp > 0) return numericTimestamp;
-    const stringTimestamp = typeof value === 'string' ? Date.parse(value) : NaN;
-    if (Number.isFinite(stringTimestamp) && stringTimestamp > 0) return stringTimestamp;
-    return 0;
-}
-
 function readExistingSessionStartRecord(agentType: string, historySessionId: string): HistoryMessage | null {
     try {
         const dir = path.join(HISTORY_DIR, agentType);
@@ -1351,257 +1335,271 @@ function rewriteCanonicalSavedHistory(agentType: string, historySessionId: strin
     }
 }
 
-export function rebuildHermesSavedHistoryFromCanonicalSession(historySessionId: string): boolean {
+export type ProviderNativeHistoryScripts = Record<string, ((input: any) => any) | undefined>;
+
+type ProviderNativeHistoryReadResult = { records: HistoryMessage[]; sourcePath: string; sourceMtimeMs: number };
+
+function getNativeHistoryScriptName(canonicalHistory: ProviderCanonicalHistoryConfig | undefined, key: 'readSession' | 'listSessions'): string {
+    const configured = canonicalHistory?.scripts?.[key];
+    if (typeof configured === 'string' && configured.trim()) return configured.trim();
+    return key === 'readSession' ? 'readNativeHistory' : 'listNativeHistory';
+}
+
+function getProviderNativeHistoryScript(
+    scripts: ProviderNativeHistoryScripts | undefined,
+    canonicalHistory: ProviderCanonicalHistoryConfig | undefined,
+    key: 'readSession' | 'listSessions',
+): ((input: any) => any) | null {
+    if (!canonicalHistory?.scripts) return null;
+    const fn = scripts?.[getNativeHistoryScriptName(canonicalHistory, key)];
+    return typeof fn === 'function' ? fn : null;
+}
+
+function normalizeProviderNativeHistoryRecords(agentType: string, historySessionId: string, records: unknown): HistoryMessage[] {
+    if (!Array.isArray(records)) return [];
     const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId);
-    if (!normalizedSessionId) return false;
+    return records
+        .map((record: any) => sanitizeHistoryMessage(agentType, {
+            ts: typeof record?.ts === 'string' ? record.ts : new Date(Number(record?.receivedAt) || Date.now()).toISOString(),
+            receivedAt: Number(record?.receivedAt) || Date.parse(record?.ts || '') || Date.now(),
+            role: record?.role,
+            content: String(record?.content || ''),
+            kind: record?.kind || (record?.role === 'system' ? 'session_start' : 'standard'),
+            senderName: record?.senderName,
+            agent: agentType,
+            instanceId: record?.instanceId,
+            historySessionId: normalizeSavedHistorySessionId(record?.historySessionId || normalizedSessionId),
+            sessionTitle: record?.sessionTitle,
+            workspace: record?.workspace,
+        } as HistoryMessage))
+        .filter(Boolean) as HistoryMessage[];
+}
 
-    try {
-        const sessionFilePath = path.join(os.homedir(), '.hermes', 'sessions', `session_${normalizedSessionId}.json`);
-        if (!fs.existsSync(sessionFilePath)) return false;
-        const raw = JSON.parse(fs.readFileSync(sessionFilePath, 'utf-8')) as {
-            session_start?: string;
-            last_updated?: string;
-            messages?: Array<Record<string, unknown>>;
-        };
-        const canonicalMessages = Array.isArray(raw.messages) ? raw.messages : [];
-        const dir = path.join(HISTORY_DIR, 'hermes-cli');
-        fs.mkdirSync(dir, { recursive: true });
-        const existingSessionStart = readExistingSessionStartRecord('hermes-cli', normalizedSessionId);
-        const records: HistoryMessage[] = [];
-        if (existingSessionStart) {
-            records.push({
-                ...existingSessionStart,
-                historySessionId: normalizedSessionId,
-            });
-        }
+function callProviderNativeHistoryRead(
+    agentType: string,
+    canonicalHistory: ProviderCanonicalHistoryConfig | undefined,
+    scripts: ProviderNativeHistoryScripts | undefined,
+    historySessionId: string,
+    workspace?: string,
+): ProviderNativeHistoryReadResult | null {
+    const fn = getProviderNativeHistoryScript(scripts, canonicalHistory, 'readSession');
+    if (!fn) return null;
+    const result = fn({
+        agentType,
+        sessionId: historySessionId,
+        historySessionId,
+        workspace,
+        format: canonicalHistory?.format,
+        watchPath: canonicalHistory?.watchPath,
+        args: { sessionId: historySessionId, historySessionId, workspace },
+    });
+    if (!result || typeof result !== 'object') return null;
+    const records = normalizeProviderNativeHistoryRecords(agentType, historySessionId, (result as any).messages || (result as any).records);
+    if (records.length === 0) return null;
+    return {
+        records,
+        sourcePath: typeof (result as any).sourcePath === 'string' ? (result as any).sourcePath : '',
+        sourceMtimeMs: Number((result as any).sourceMtimeMs) || 0,
+    };
+}
 
-        let fallbackTs = Date.parse(raw.session_start || raw.last_updated || '') || Date.now();
-        for (const message of canonicalMessages) {
-            const role = String(message.role || '').trim();
-            const content = normalizeCanonicalHermesMessageContent(message.content);
-            if (!content) continue;
-            const receivedAt = extractCanonicalHermesMessageTimestamp(message, fallbackTs);
-            fallbackTs = receivedAt + 1;
+function buildNativeHistoryReadResult(
+    agentType: string,
+    canonicalHistory: ProviderCanonicalHistoryConfig | undefined,
+    scripts: ProviderNativeHistoryScripts | undefined,
+    historySessionId: string | undefined,
+    workspace?: string,
+): ProviderNativeHistoryReadResult | null {
+    const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId || '');
+    if (!canonicalHistory || !normalizedSessionId || !isNativeSourceCanonicalHistory(canonicalHistory)) return null;
+    return callProviderNativeHistoryRead(agentType, canonicalHistory, scripts, normalizedSessionId, workspace);
+}
 
-            if (role === 'user') {
-                records.push({
-                    ts: new Date(receivedAt).toISOString(),
-                    receivedAt,
-                    role: 'user',
-                    content,
-                    kind: 'standard',
-                    agent: 'hermes-cli',
-                    historySessionId: normalizedSessionId,
-                });
-                continue;
-            }
+function materializeNativeHistoryToMirror(
+    agentType: string,
+    canonicalHistory: ProviderCanonicalHistoryConfig,
+    historySessionId: string,
+    workspace?: string,
+    scripts?: ProviderNativeHistoryScripts,
+): boolean {
+    const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId);
+    if (!normalizedSessionId) return false;
+    const nativeResult = callProviderNativeHistoryRead(agentType, canonicalHistory, scripts, normalizedSessionId, workspace);
+    const nativeRecords = nativeResult?.records || [];
+    if (nativeRecords.length === 0) return false;
+    const normalizedRecords = nativeRecords.map((record) => ({
+        ...record,
+        agent: agentType,
+        historySessionId: normalizedSessionId,
+    }));
+    const existingSessionStart = readExistingSessionStartRecord(agentType, normalizedSessionId);
+    const records = existingSessionStart && normalizedRecords[0]?.kind !== 'session_start'
+        ? [{ ...existingSessionStart, historySessionId: normalizedSessionId, agent: agentType }, ...normalizedRecords]
+        : normalizedRecords;
+    return rewriteCanonicalSavedHistory(agentType, normalizedSessionId, records);
+}
 
-            if (role === 'assistant') {
-                records.push({
-                    ts: new Date(receivedAt).toISOString(),
-                    receivedAt,
-                    role: 'assistant',
-                    content,
-                    kind: 'standard',
-                    agent: 'hermes-cli',
-                    historySessionId: normalizedSessionId,
-                });
-                continue;
-            }
+export function materializeProviderNativeHistory(
+    agentType: string,
+    canonicalHistory: ProviderCanonicalHistoryConfig | undefined,
+    historySessionId: string,
+    workspace?: string,
+    scripts?: ProviderNativeHistoryScripts,
+): boolean {
+    if (!canonicalHistory || canonicalHistory.mode !== 'materialized-mirror') return false;
+    return materializeNativeHistoryToMirror(agentType, canonicalHistory, historySessionId, workspace, scripts);
+}
 
-            if (role === 'tool') {
-                records.push({
-                    ts: new Date(receivedAt).toISOString(),
-                    receivedAt,
-                    role: 'assistant',
-                    content,
-                    kind: 'tool',
-                    senderName: 'Tool',
-                    agent: 'hermes-cli',
-                    historySessionId: normalizedSessionId,
-                });
-            }
-        }
+export function isNativeSourceCanonicalHistory(canonicalHistory?: ProviderCanonicalHistoryConfig): boolean {
+    if (!canonicalHistory) return false;
+    if ((canonicalHistory as any).mode === 'disabled') return false;
+    if ((canonicalHistory as any).mode === 'materialized-mirror') return false;
+    return true;
+}
 
-        return rewriteCanonicalSavedHistory('hermes-cli', normalizedSessionId, records);
-    } catch {
-        return false;
+export function readProviderChatHistory(
+    agentType: string,
+    options: {
+        canonicalHistory?: ProviderCanonicalHistoryConfig;
+        historySessionId?: string;
+        workspace?: string;
+        offset?: number;
+        limit?: number;
+        excludeRecentCount?: number;
+        historyBehavior?: ProviderHistoryBehavior;
+        scripts?: ProviderNativeHistoryScripts;
+    } = {},
+): { messages: HistoryMessage[]; hasMore: boolean; source: 'provider-native' | 'adhdev-mirror' | 'native-unavailable'; sourcePath?: string; sourceMtimeMs?: number } {
+    if (isNativeSourceCanonicalHistory(options.canonicalHistory) && options.historySessionId) {
+        const nativeResult = buildNativeHistoryReadResult(agentType, options.canonicalHistory, options.scripts, options.historySessionId, options.workspace);
+        if (!nativeResult) return { messages: [], hasMore: false, source: 'native-unavailable' };
+        return {
+            ...pageHistoryRecords(agentType, nativeResult.records, options.offset || 0, options.limit || 30, options.excludeRecentCount || 0, options.historyBehavior),
+            source: 'provider-native',
+            sourcePath: nativeResult.sourcePath,
+            sourceMtimeMs: nativeResult.sourceMtimeMs,
+        };
     }
+    return {
+        ...readChatHistory(agentType, options.offset || 0, options.limit || 30, options.historySessionId, options.excludeRecentCount || 0, options.historyBehavior),
+        source: 'adhdev-mirror',
+    };
 }
 
-function resolveClaudeProjectTranscriptPath(historySessionId: string, workspace?: string): string | null {
-    const claudeProjectsDir = path.join(os.homedir(), '.claude', 'projects');
-    if (!fs.existsSync(claudeProjectsDir)) return null;
-    const normalizedWorkspace = typeof workspace === 'string' ? workspace.trim() : '';
-    if (normalizedWorkspace) {
-        const directPath = path.join(claudeProjectsDir, normalizedWorkspace.replace(/[\\/]/g, '-'), `${historySessionId}.jsonl`);
-        if (fs.existsSync(directPath)) return directPath;
-    }
-    const stack = [claudeProjectsDir];
-    while (stack.length > 0) {
-        const current = stack.pop();
-        if (!current) continue;
-        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-            const entryPath = path.join(current, entry.name);
-            if (entry.isDirectory()) {
-                stack.push(entryPath);
-                continue;
-            }
-            if (entry.isFile() && entry.name === `${historySessionId}.jsonl`) {
-                return entryPath;
-            }
-        }
-    }
-    return null;
+function buildNativeSessionSummary(
+    agentType: string,
+    historySessionId: string,
+    records: HistoryMessage[],
+    sourcePath: string,
+): SavedHistorySessionSummary | null {
+    const visible = pageHistoryRecords(agentType, records, 0, Number.MAX_SAFE_INTEGER).messages;
+    if (visible.length === 0) return null;
+    let sourceMtimeMs = 0;
+    try { sourceMtimeMs = fs.statSync(sourcePath).mtimeMs; } catch { /* ignore */ }
+    const firstMessageAt = visible[0]?.receivedAt || sourceMtimeMs || Date.now();
+    const lastMessageAt = visible[visible.length - 1]?.receivedAt || firstMessageAt;
+    const lastNonSystem = [...visible].reverse().find((message) => message.role !== 'system') || visible[visible.length - 1];
+    const firstSystem = visible.find((message) => message.kind === 'session_start');
+    return {
+        historySessionId,
+        sessionTitle: lastNonSystem?.content,
+        messageCount: visible.length,
+        firstMessageAt,
+        lastMessageAt,
+        preview: lastNonSystem?.content,
+        workspace: firstSystem?.workspace || (firstSystem?.kind === 'session_start' ? firstSystem.content : undefined),
+        source: 'provider-native',
+        sourcePath,
+        sourceMtimeMs,
+    };
 }
 
-function extractClaudeAssistantContentParts(content: unknown): Array<{ content: string; kind: 'standard' | 'tool'; senderName?: string; role?: 'assistant' }> {
-    if (typeof content === 'string') {
-        const trimmed = content.trim();
-        return trimmed ? [{ content: trimmed, kind: 'standard', role: 'assistant' }] : [];
-    }
-    if (!Array.isArray(content)) return [];
-    const parts: Array<{ content: string; kind: 'standard' | 'tool'; senderName?: string; role?: 'assistant' }> = [];
-    for (const block of content) {
-        if (!block || typeof block !== 'object') continue;
-        const record = block as Record<string, unknown>;
-        const type = String(record.type || '').trim();
-        if (type === 'text') {
-            const text = String(record.text || '').trim();
-            if (text) parts.push({ content: text, kind: 'standard', role: 'assistant' });
-            continue;
-        }
-        if (type === 'tool_use') {
-            const name = String(record.name || '').trim() || 'Tool';
-            const input = record.input && typeof record.input === 'object'
-                ? record.input as Record<string, unknown>
-                : null;
-            const command = input ? String(input.command || '').trim() : '';
-            const summary = command ? `${name}: ${command}` : name;
-            if (summary) parts.push({ content: summary, kind: 'tool', senderName: 'Tool', role: 'assistant' });
-        }
-    }
-    return parts;
+function normalizeProviderNativeHistorySessionSummary(agentType: string, item: any): SavedHistorySessionSummary | null {
+    const historySessionId = normalizeSavedHistorySessionId(item?.historySessionId || item?.sessionId || '');
+    if (!historySessionId) return null;
+    const sourcePath = typeof item?.sourcePath === 'string' ? item.sourcePath : '';
+    const sourceMtimeMs = Number(item?.sourceMtimeMs) || 0;
+    const firstMessageAt = Number(item?.firstMessageAt) || sourceMtimeMs || Date.now();
+    const lastMessageAt = Number(item?.lastMessageAt) || firstMessageAt;
+    const messageCount = Math.max(0, Number(item?.messageCount) || 0);
+    return {
+        historySessionId,
+        sessionTitle: typeof item?.sessionTitle === 'string' ? item.sessionTitle : undefined,
+        messageCount,
+        firstMessageAt,
+        lastMessageAt,
+        preview: typeof item?.preview === 'string' ? item.preview : undefined,
+        workspace: typeof item?.workspace === 'string' ? item.workspace : undefined,
+        source: 'provider-native',
+        sourcePath,
+        sourceMtimeMs,
+    };
 }
 
-function extractClaudeUserContentParts(content: unknown): Array<{ role: 'user' | 'assistant'; content: string; kind: 'standard' | 'tool'; senderName?: string }> {
-    if (typeof content === 'string') {
-        const trimmed = content.trim();
-        return trimmed ? [{ role: 'user', content: trimmed, kind: 'standard' }] : [];
-    }
-    if (!Array.isArray(content)) return [];
-    const parts: Array<{ role: 'user' | 'assistant'; content: string; kind: 'standard' | 'tool'; senderName?: string }> = [];
-    for (const block of content) {
-        if (!block || typeof block !== 'object') continue;
-        const record = block as Record<string, unknown>;
-        const type = String(record.type || '').trim();
-        if (type === 'text') {
-            const text = String(record.text || '').trim();
-            if (text) parts.push({ role: 'user', content: text, kind: 'standard' });
+function collectProviderScriptNativeHistorySessionSummaries(
+    agentType: string,
+    canonicalHistory: ProviderCanonicalHistoryConfig,
+    scripts?: ProviderNativeHistoryScripts,
+): SavedHistorySessionSummary[] | null {
+    const fn = getProviderNativeHistoryScript(scripts, canonicalHistory, 'listSessions');
+    if (!fn) return null;
+    const result = fn({
+        agentType,
+        format: canonicalHistory.format,
+        watchPath: canonicalHistory.watchPath,
+        args: {},
+    });
+    if (!result || typeof result !== 'object') return [];
+    const sessions = Array.isArray((result as any).sessions) ? (result as any).sessions : [];
+    const summaries: SavedHistorySessionSummary[] = [];
+    for (const item of sessions) {
+        if (Array.isArray(item?.messages || item?.records)) {
+            const historySessionId = normalizeSavedHistorySessionId(item?.historySessionId || item?.sessionId || '');
+            if (!historySessionId) continue;
+            const records = normalizeProviderNativeHistoryRecords(agentType, historySessionId, item.messages || item.records);
+            const summary = buildNativeSessionSummary(agentType, historySessionId, records, typeof item?.sourcePath === 'string' ? item.sourcePath : '');
+            if (summary) {
+                if (Number(item?.sourceMtimeMs)) summary.sourceMtimeMs = Number(item.sourceMtimeMs);
+                summaries.push(summary);
+            }
             continue;
         }
-        if (type === 'tool_result') {
-            const rawContent = record.content;
-            const text = typeof rawContent === 'string'
-                ? rawContent.trim()
-                : Array.isArray(rawContent)
-                    ? rawContent
-                        .map((entry) => {
-                            if (typeof entry === 'string') return entry.trim();
-                            if (!entry || typeof entry !== 'object') return '';
-                            const nested = entry as Record<string, unknown>;
-                            if (typeof nested.text === 'string') return nested.text.trim();
-                            if (typeof nested.content === 'string') return nested.content.trim();
-                            return '';
-                        })
-                        .filter(Boolean)
-                        .join('\n')
-                : '';
-            if (text) parts.push({ role: 'assistant', content: text, kind: 'tool', senderName: 'Tool' });
-        }
+        const summary = normalizeProviderNativeHistorySessionSummary(agentType, item);
+        if (summary) summaries.push(summary);
     }
-    return parts;
+    return sortSavedHistorySessionSummaries(summaries);
 }
 
-export function rebuildClaudeSavedHistoryFromNativeProject(historySessionId: string, workspace?: string): boolean {
-    const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId);
-    if (!normalizedSessionId) return false;
-
-    try {
-        const transcriptPath = resolveClaudeProjectTranscriptPath(normalizedSessionId, workspace);
-        if (!transcriptPath) return false;
-        const lines = fs.readFileSync(transcriptPath, 'utf-8').split('\n').filter(Boolean);
-        const records: HistoryMessage[] = [];
-        const existingSessionStart = readExistingSessionStartRecord('claude-cli', normalizedSessionId);
-        if (existingSessionStart) {
-            records.push({
-                ...existingSessionStart,
-                historySessionId: normalizedSessionId,
-            });
-        }
-        let fallbackTs = Date.now();
-        for (const line of lines) {
-            let parsed: Record<string, unknown> | null = null;
-            try {
-                parsed = JSON.parse(line) as Record<string, unknown>;
-            } catch {
-                parsed = null;
-            }
-            if (!parsed) continue;
-            const parsedSessionId = String(parsed.sessionId || '').trim();
-            if (parsedSessionId && parsedSessionId !== normalizedSessionId) continue;
-            const receivedAt = extractTimestampValue(parsed.timestamp) || fallbackTs;
-            fallbackTs = receivedAt + 1;
-            const parsedWorkspace = String(parsed.cwd || workspace || '').trim();
-            if (records.length === 0 && parsedWorkspace) {
-                records.push({
-                    ts: new Date(receivedAt).toISOString(),
-                    receivedAt,
-                    role: 'system',
-                    kind: 'session_start',
-                    content: parsedWorkspace,
-                    agent: 'claude-cli',
-                    historySessionId: normalizedSessionId,
-                    workspace: parsedWorkspace,
-                });
-            }
-            const type = String(parsed.type || '').trim();
-            const message = parsed.message && typeof parsed.message === 'object'
-                ? parsed.message as Record<string, unknown>
-                : null;
-            if (type === 'user' && message) {
-                for (const part of extractClaudeUserContentParts(message.content)) {
-                    records.push({
-                        ts: new Date(receivedAt).toISOString(),
-                        receivedAt,
-                        role: part.role,
-                        content: part.content,
-                        kind: part.kind,
-                        senderName: part.senderName,
-                        agent: 'claude-cli',
-                        historySessionId: normalizedSessionId,
-                    });
-                }
-                continue;
-            }
-            if (type === 'assistant' && message) {
-                for (const part of extractClaudeAssistantContentParts(message.content)) {
-                    records.push({
-                        ts: new Date(receivedAt).toISOString(),
-                        receivedAt,
-                        role: 'assistant',
-                        content: part.content,
-                        kind: part.kind,
-                        senderName: part.senderName,
-                        agent: 'claude-cli',
-                        historySessionId: normalizedSessionId,
-                    });
-                }
-            }
-        }
+function collectNativeHistorySessionSummaries(
+    agentType: string,
+    canonicalHistory: ProviderCanonicalHistoryConfig,
+    scripts?: ProviderNativeHistoryScripts,
+): SavedHistorySessionSummary[] {
+    return collectProviderScriptNativeHistorySessionSummaries(agentType, canonicalHistory, scripts) || [];
+}
 
-        return rewriteCanonicalSavedHistory('claude-cli', normalizedSessionId, records);
-    } catch {
-        return false;
+export function listProviderHistorySessions(
+    agentType: string,
+    options: {
+        canonicalHistory?: ProviderCanonicalHistoryConfig;
+        offset?: number;
+        limit?: number;
+        historyBehavior?: ProviderHistoryBehavior;
+        scripts?: ProviderNativeHistoryScripts;
+    } = {},
+): { sessions: SavedHistorySessionSummary[]; hasMore: boolean; source: 'provider-native' | 'adhdev-mirror' } {
+    if (isNativeSourceCanonicalHistory(options.canonicalHistory)) {
+        const offset = Math.max(0, options.offset || 0);
+        const limit = Math.max(1, options.limit || 30);
+        const summaries = collectNativeHistorySessionSummaries(agentType, options.canonicalHistory!, options.scripts);
+        return {
+            sessions: summaries.slice(offset, offset + limit),
+            hasMore: offset + limit < summaries.length,
+            source: 'provider-native',
+        };
     }
+    return {
+        ...listSavedHistorySessions(agentType, { offset: options.offset, limit: options.limit }, options.historyBehavior),
+        source: 'adhdev-mirror',
+    };
 }