@adhdev/daemon-core 0.8.83 → 0.8.84

package/dist/providers/cli-provider-instance.d.ts

@@ -8,6 +8,14 @@ import { type ProviderModule } from './contracts.js';
 import type { ProviderInstance, ProviderState, InstanceContext } from './provider-instance.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
+type PersistableCliHistoryMessage = {
+    role: string;
+    content: string;
+    kind?: string;
+    senderName?: string;
+    receivedAt?: number;
+};
+export declare function buildIncrementalHistoryAppendMessages(previousMessages: PersistableCliHistoryMessage[], currentMessages: PersistableCliHistoryMessage[]): PersistableCliHistoryMessage[];
 export declare function getForcedNewSessionScriptName(provider: ProviderModule | undefined, launchMode: 'new' | 'resume' | 'manual'): string | null;
 export declare function waitForCliAdapterReady(adapter: {
     isReady?: () => boolean;
@@ -39,6 +47,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private appliedEffectKeys;
     private historyWriter;
     private runtimeMessages;
+    private lastPersistedHistoryMessages;
     readonly instanceId: string;
     private suppressIdleHistoryReplay;
     private errorMessage;
@@ -99,3 +108,4 @@ export declare class CliProviderInstance implements ProviderInstance {
     private buildSqlPlaceholderList;
     private querySqliteText;
 }
+export {};

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.83",
+  "version": "0.8.84",
   "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.8.83",
+  "version": "0.8.84",
   "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/config/chat-history.ts

@@ -1274,3 +1274,140 @@ export function listSavedHistorySessions(
         return { sessions: [], hasMore: false };
     }
 }
+
+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 readExistingHermesSessionStartRecord(historySessionId: string): HistoryMessage | null {
+    try {
+        const dir = path.join(HISTORY_DIR, 'hermes-cli');
+        if (!fs.existsSync(dir)) return null;
+        const files = listHistoryFiles(dir, historySessionId).sort();
+        for (const file of files) {
+            const lines = fs.readFileSync(path.join(dir, file), 'utf-8').split('\n').filter(Boolean);
+            for (const line of lines) {
+                try {
+                    const parsed = JSON.parse(line) as HistoryMessage;
+                    if (parsed.historySessionId !== historySessionId) continue;
+                    if (parsed.kind === 'session_start' && parsed.role === 'system') {
+                        return parsed;
+                    }
+                } catch {
+                    // Ignore malformed lines while probing for the original session_start marker.
+                }
+            }
+        }
+        return null;
+    } catch {
+        return null;
+    }
+}
+
+export function rebuildHermesSavedHistoryFromCanonicalSession(historySessionId: string): boolean {
+    const normalizedSessionId = normalizeSavedHistorySessionId('hermes-cli', historySessionId);
+    if (!normalizedSessionId) return false;
+
+    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 = readExistingHermesSessionStartRecord(normalizedSessionId);
+        const records: HistoryMessage[] = [];
+        if (existingSessionStart) {
+            records.push({
+                ...existingSessionStart,
+                historySessionId: normalizedSessionId,
+            });
+        }
+
+        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;
+
+            if (role === 'user') {
+                records.push({
+                    ts: new Date(receivedAt).toISOString(),
+                    receivedAt,
+                    role: 'user',
+                    content,
+                    kind: 'standard',
+                    agent: 'hermes-cli',
+                    historySessionId: normalizedSessionId,
+                });
+                continue;
+            }
+
+            if (role === 'assistant') {
+                records.push({
+                    ts: new Date(receivedAt).toISOString(),
+                    receivedAt,
+                    role: 'assistant',
+                    content,
+                    kind: 'standard',
+                    agent: 'hermes-cli',
+                    historySessionId: normalizedSessionId,
+                });
+                continue;
+            }
+
+            if (role === 'tool') {
+                records.push({
+                    ts: new Date(receivedAt).toISOString(),
+                    receivedAt,
+                    role: 'assistant',
+                    content,
+                    kind: 'tool',
+                    senderName: 'Tool',
+                    agent: 'hermes-cli',
+                    historySessionId: normalizedSessionId,
+                });
+            }
+        }
+
+        if (records.length === 0) return false;
+
+        const prefix = `${normalizedSessionId.replace(/[^a-zA-Z0-9_-]/g, '_')}_`;
+        for (const file of fs.readdirSync(dir)) {
+            if (file.startsWith(prefix) && file.endsWith('.jsonl')) {
+                fs.unlinkSync(path.join(dir, file));
+            }
+        }
+
+        const targetDate = new Date(records[records.length - 1].receivedAt || Date.now()).toISOString().slice(0, 10);
+        const filePath = path.join(dir, `${prefix}${targetDate}.jsonl`);
+        fs.writeFileSync(filePath, `${records.map((record) => JSON.stringify(record)).join('\n')}\n`, 'utf-8');
+        invalidatePersistedSavedHistoryIndex('hermes-cli', dir);
+        savedHistorySessionCache.delete('hermes-cli');
+        return true;
+    } catch {
+        return false;
+    }
+}

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

@@ -27,6 +27,51 @@ import { mergeProviderPatchState, resolveProviderStateSurface } from './provider
 import { normalizeProviderSessionId } from './provider-session-id.js';
 import { buildChatMessage, buildRuntimeSystemChatMessage, normalizeChatMessages } from './chat-message-normalization.js';
 
+type PersistableCliHistoryMessage = {
+    role: string;
+    content: string;
+    kind?: string;
+    senderName?: string;
+    receivedAt?: number;
+};
+
+function normalizePersistableCliHistoryContent(content: unknown): string {
+    return flattenContent(content as any).replace(/\s+/g, ' ').trim();
+}
+
+function buildPersistableCliHistorySignature(message: PersistableCliHistoryMessage): string {
+    return [
+        String(message.role || ''),
+        String(message.kind || ''),
+        String(message.senderName || ''),
+        normalizePersistableCliHistoryContent(message.content),
+    ].join('|');
+}
+
+export function buildIncrementalHistoryAppendMessages(
+    previousMessages: PersistableCliHistoryMessage[],
+    currentMessages: PersistableCliHistoryMessage[],
+): PersistableCliHistoryMessage[] {
+    if (!Array.isArray(currentMessages) || currentMessages.length === 0) return [];
+    if (!Array.isArray(previousMessages) || previousMessages.length === 0) return currentMessages;
+
+    const previousSignatures = previousMessages.map(buildPersistableCliHistorySignature);
+    const currentSignatures = currentMessages.map(buildPersistableCliHistorySignature);
+
+    let sharedPrefixLength = 0;
+    while (
+        sharedPrefixLength < previousSignatures.length
+        && sharedPrefixLength < currentSignatures.length
+        && previousSignatures[sharedPrefixLength] === currentSignatures[sharedPrefixLength]
+    ) {
+        sharedPrefixLength += 1;
+    }
+
+    if (sharedPrefixLength === currentSignatures.length) return [];
+    if (sharedPrefixLength === previousSignatures.length) return currentMessages.slice(sharedPrefixLength);
+    return currentMessages;
+}
+
 let CachedDatabaseSync: (new (path: string, options?: { readOnly?: boolean }) => {
     prepare(sql: string): { get(...params: Array<string | number>): unknown };
     close(): void;
@@ -112,6 +157,7 @@ export class CliProviderInstance implements ProviderInstance {
     private appliedEffectKeys = new Set<string>();
     private historyWriter: ChatHistoryWriter;
     private runtimeMessages: Array<{ key: string; message: ChatMessage }> = [];
+    private lastPersistedHistoryMessages: PersistableCliHistoryMessage[] = [];
     readonly instanceId: string;
     private suppressIdleHistoryReplay = false;
     private errorMessage: string | undefined = undefined;
@@ -200,6 +246,13 @@ export class CliProviderInstance implements ProviderInstance {
                 this.providerSessionId,
                 this.instanceId,
             );
+            this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
+                role: message.role,
+                content: message.content,
+                kind: message.kind,
+                senderName: message.senderName,
+                receivedAt: message.receivedAt,
+            }));
             this.suppressIdleHistoryReplay = restoredHistory.messages.length > 0;
             if (restoredHistory.messages.length > 0) {
                 this.adapter.seedCommittedMessages(
@@ -363,15 +416,24 @@ export class CliProviderInstance implements ProviderInstance {
                     messagesToSave = messagesToSave.slice(0, lastIdx);
                 }
             }
-            if (!shouldSkipReplayPersist && messagesToSave.length > 0) {
+            const normalizedMessagesToSave = messagesToSave.map((message: PersistableCliHistoryMessage & { timestamp?: number }) => ({
+                role: message.role,
+                content: flattenContent(message.content),
+                kind: typeof message.kind === 'string' ? message.kind : undefined,
+                senderName: typeof message.senderName === 'string' ? message.senderName : undefined,
+                receivedAt: typeof message.receivedAt === 'number' ? message.receivedAt : message.timestamp,
+            }));
+            if (!shouldSkipReplayPersist && normalizedMessagesToSave.length > 0) {
+                const incrementalMessages = buildIncrementalHistoryAppendMessages(this.lastPersistedHistoryMessages, normalizedMessagesToSave);
                 this.historyWriter.appendNewMessages(
                     this.type,
-                    messagesToSave,
+                    incrementalMessages,
                     parsedStatus?.title || dirName,
                     this.instanceId,
                     this.providerSessionId,
                 );
             }
+            this.lastPersistedHistoryMessages = normalizedMessagesToSave;
         }
 
         this.applyProviderResponse(parsedStatus, { phase: 'immediate' });
@@ -640,6 +702,7 @@ export class CliProviderInstance implements ProviderInstance {
 
         if (data.sessionEvent === 'new_session') {
             this.runtimeMessages = [];
+            this.lastPersistedHistoryMessages = [];
             this.suppressIdleHistoryReplay = false;
             this.adapter.clearHistory();
         }