@adhdev/daemon-core 0.8.83 → 0.8.85

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.85",
   "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.85",
   "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cli-adapters/provider-cli-adapter.ts

@@ -853,6 +853,58 @@ export class ProviderCliAdapter implements CliAdapter {
         );
     }
 
+    private clearStaleIdleResponseGuard(reason: string): boolean {
+        const screenText = this.terminalScreen.getText() || '';
+        const visibleIdlePrompt = this.looksLikeVisibleIdlePrompt(screenText);
+        const blockingModal = this.activeModal || this.getStartupConfirmationModal(screenText);
+        if (!this.isWaitingForResponse || this.currentStatus !== 'idle' || !visibleIdlePrompt || !!blockingModal) {
+            return false;
+        }
+        if (this.responseTimeout) { clearTimeout(this.responseTimeout); this.responseTimeout = null; }
+        if (this.idleTimeout) { clearTimeout(this.idleTimeout); this.idleTimeout = null; }
+        if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
+        if (this.finishRetryTimer) { clearTimeout(this.finishRetryTimer); this.finishRetryTimer = null; }
+        this.clearIdleFinishCandidate(reason);
+        this.responseBuffer = '';
+        this.isWaitingForResponse = false;
+        this.responseSettleIgnoreUntil = 0;
+        this.submitRetryUsed = false;
+        this.submitRetryPromptSnippet = '';
+        this.finishRetryCount = 0;
+        this.currentTurnScope = null;
+        this.activeModal = null;
+        this.recordTrace('stale_idle_response_cleared', {
+            reason,
+            screenText: summarizeCliTraceText(screenText, 240),
+        });
+        return true;
+    }
+
+    private hasMeaningfulResponseBuffer(promptSnippet: string): boolean {
+        const raw = String(this.responseBuffer || '').trim();
+        if (!raw) return false;
+        const normalizedPrompt = compactPromptText(promptSnippet);
+        if (!normalizedPrompt) return true;
+        const normalizedBuffer = compactPromptText(raw);
+        if (!normalizedBuffer) return false;
+        if (normalizedBuffer === normalizedPrompt) return false;
+        if (normalizedBuffer.startsWith(normalizedPrompt)) {
+            const remainder = normalizedBuffer
+                .slice(normalizedPrompt.length)
+                .replace(/[─═\-]+/g, '')
+                .replace(/⏵⏵accepteditson\([^)]*\)/gi, '')
+                .replace(/accepteditson\([^)]*\)/gi, '')
+                .replace(/(?:◐|◑|◒|◓|◔|◕|◉|●|·)?(?:x?high|medium|low|max)·?\/effort/gi, '')
+                .replace(/updateavailable!run:[a-z0-9:._\-/]+/gi, '')
+                .replace(/esctointerrupt/gi, '')
+                .replace(/❯/g, '')
+                .replace(/^[\s\-–—:;,.!/?]+/, '')
+                .trim();
+            return remainder.length > 0;
+        }
+        return true;
+    }
+
     private evaluateSettled(): void {
         const now = Date.now();
         if (this.submitPendingUntil > now || this.responseSettleIgnoreUntil > now) {
@@ -888,7 +940,11 @@ export class ProviderCliAdapter implements CliAdapter {
                 lastOutputAt: this.lastOutputAt,
             })
             : [];
+        if (this.maybeCommitVisibleIdleTranscript(parsedTranscript)) {
+            return;
+        }
         const lastParsedAssistant = [...parsedMessages].reverse().find((message) => message.role === 'assistant');
+        const normalizedPromptSnippet = normalizePromptText(this.submitRetryPromptSnippet || this.currentTurnScope?.prompt || '');
         this.recordTrace('settled', {
             tail: summarizeCliTraceText(tail, 500),
             screenText: summarizeCliTraceText(screenText, 1200),
@@ -906,6 +962,32 @@ export class ProviderCliAdapter implements CliAdapter {
                 scope: this.currentTurnScope,
             }),
         });
+        if (
+            this.currentTurnScope
+            && !lastParsedAssistant
+            && !this.submitRetryUsed
+            && this.ptyProcess
+            && this.currentStatus !== 'waiting_approval'
+            && promptLikelyVisible(screenText, normalizedPromptSnippet)
+            && !this.hasMeaningfulResponseBuffer(normalizedPromptSnippet)
+        ) {
+            this.submitRetryUsed = true;
+            this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
+            LOG.info('CLI', `[${this.cliType}] Retrying submit key from settled parser (no assistant yet)`);
+            this.recordTrace('submit_write', {
+                mode: 'settled_retry',
+                sendKey: this.sendKey,
+                screenText: summarizeCliTraceText(screenText, 500),
+            });
+            this.ptyProcess.write(this.sendKey);
+            if (this.settleTimer) clearTimeout(this.settleTimer);
+            this.settleTimer = setTimeout(() => {
+                this.settleTimer = null;
+                this.settledBuffer = this.recentOutputBuffer;
+                this.evaluateSettled();
+            }, this.timeouts.outputSettle + 150);
+            return;
+        }
         if (this.currentTurnScope && !lastParsedAssistant) {
             LOG.info(
                 'CLI',
@@ -956,11 +1038,20 @@ export class ProviderCliAdapter implements CliAdapter {
 
         const recentInteractiveActivity = this.hasRecentInteractiveActivity(now);
         const statusActivityHoldMs = this.getStatusActivityHoldMs();
+        const visibleIdlePrompt = this.looksLikeVisibleIdlePrompt(screenText);
+        const visibleAssistantCandidate = this.looksLikeVisibleAssistantCandidate(screenText);
+        if (this.currentTurnScope && this.cliType === 'claude-cli') {
+            LOG.info(
+                'CLI',
+                `[${this.cliType}] settled diagnostics prompt=${JSON.stringify(this.currentTurnScope.prompt).slice(0, 140)} scriptStatus=${String(scriptStatus || '')} parsedStatus=${String(parsedTranscript?.status || '')} parsedMsgCount=${parsedMessages.length} lastParsedAssistant=${JSON.stringify(summarizeCliTraceText(lastParsedAssistant?.content || '', 120)).slice(0, 160)} visibleIdlePrompt=${String(visibleIdlePrompt)} visibleAssistantCandidate=${String(visibleAssistantCandidate)} responseBuffer=${JSON.stringify(summarizeCliTraceText(this.responseBuffer, 160)).slice(0, 220)} screen=${JSON.stringify(summarizeCliTraceText(screenText, 160)).slice(0, 220)}`
+            );
+        }
         const shouldHoldGenerating =
             scriptStatus === 'idle'
             && this.isWaitingForResponse
             && !modal
-            && recentInteractiveActivity;
+            && recentInteractiveActivity
+            && !(visibleIdlePrompt && visibleAssistantCandidate);
 
         if (shouldHoldGenerating) {
             this.clearIdleFinishCandidate('hold_generating_recent_activity');
@@ -1202,6 +1293,70 @@ export class ProviderCliAdapter implements CliAdapter {
         this.onStatusChange?.();
     }
 
+    private maybeCommitVisibleIdleTranscript(
+        parsed: any,
+        options?: { requireVisibleAssistantCandidate?: boolean; screenText?: string },
+    ): boolean {
+        const allowImmediateScriptIdleCommit = this.provider.allowInputDuringGeneration === true;
+        if (!allowImmediateScriptIdleCommit) return false;
+        if (
+            !parsed
+            || !Array.isArray(parsed.messages)
+            || parsed.status !== 'idle'
+            || !this.isWaitingForResponse
+            || !this.currentTurnScope
+            || this.activeModal
+            || parsed.activeModal
+        ) {
+            return false;
+        }
+
+        if (options?.requireVisibleAssistantCandidate) {
+            const candidateText = options.screenText || this.terminalScreen.getText() || '';
+            if (!this.looksLikeVisibleAssistantCandidate(candidateText)) {
+                return false;
+            }
+        }
+
+        const hydratedForIdleCommit = normalizeCliParsedMessages(parsed.messages, {
+            committedMessages: this.committedMessages,
+            scope: this.currentTurnScope,
+            lastOutputAt: this.lastOutputAt,
+        });
+        const visibleAssistant = [...hydratedForIdleCommit].reverse().find((message) => message.role === 'assistant' && message.content.trim());
+        if (!visibleAssistant) return false;
+
+        this.committedMessages = hydratedForIdleCommit;
+        const promptForTrim = this.currentTurnScope?.prompt || getLastUserPromptText(this.committedMessages);
+        if (promptForTrim) {
+            const lastAssistantForTrim = [...this.committedMessages].reverse().find((message) => message.role === 'assistant');
+            if (lastAssistantForTrim) {
+                lastAssistantForTrim.content = trimPromptEchoPrefix(lastAssistantForTrim.content, promptForTrim);
+            }
+        }
+        if (this.responseTimeout) { clearTimeout(this.responseTimeout); this.responseTimeout = null; }
+        if (this.idleTimeout) { clearTimeout(this.idleTimeout); this.idleTimeout = null; }
+        if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
+        if (this.submitRetryTimer) { clearTimeout(this.submitRetryTimer); this.submitRetryTimer = null; }
+        if (this.finishRetryTimer) { clearTimeout(this.finishRetryTimer); this.finishRetryTimer = null; }
+        this.syncMessageViews();
+        this.responseBuffer = '';
+        this.isWaitingForResponse = false;
+        this.responseSettleIgnoreUntil = 0;
+        this.submitRetryUsed = false;
+        this.submitRetryPromptSnippet = '';
+        this.finishRetryCount = 0;
+        this.currentTurnScope = null;
+        this.activeModal = null;
+        this.setStatus('idle', 'script_idle_commit');
+        this.onStatusChange?.();
+        this.recordTrace('script_idle_commit', {
+            messageCount: this.committedMessages.length,
+            lastAssistant: summarizeCliTraceText(visibleAssistant.content, 320),
+        });
+        return true;
+    }
+
     private commitCurrentTranscript(): { hasAssistant: boolean; assistantContent: string } {
         const parsed = this.parseCurrentTranscript(
             this.committedMessages,
@@ -1223,6 +1378,12 @@ export class ProviderCliAdapter implements CliAdapter {
             }
             this.syncMessageViews();
             const lastAssistant = [...this.committedMessages].reverse().find((message) => message.role === 'assistant');
+            if (this.currentTurnScope) {
+                LOG.info(
+                    'CLI',
+                    `[${this.cliType}] commitCurrentTranscript committedMessages=${this.committedMessages.length} finalLastAssistant=${JSON.stringify(summarizeCliTraceText(lastAssistant?.content || '', 220)).slice(0, 260)}`
+                );
+            }
             this.recordTrace('commit_transcript', {
                 parsedStatus: parsed.status || null,
                 messageCount: this.committedMessages.length,
@@ -1242,17 +1403,25 @@ export class ProviderCliAdapter implements CliAdapter {
                     `[${this.cliType}] Commit without assistant turn: prompt=${JSON.stringify(this.currentTurnScope.prompt).slice(0, 140)} responseBuffer=${JSON.stringify(summarizeCliTraceText(this.responseBuffer, 220)).slice(0, 260)} providerDir=${this.providerResolutionMeta.providerDir || '-'} scriptDir=${this.providerResolutionMeta.scriptDir || '-'} scriptsPath=${this.providerResolutionMeta.scriptsPath || '-'}`
                 );
             }
+            const hasAssistant = !!lastAssistant;
             return {
-                hasAssistant: !!lastAssistant,
+                hasAssistant,
                 assistantContent: lastAssistant?.content || '',
             };
         }
+        if (this.currentTurnScope) {
+            LOG.info(
+                'CLI',
+                `[${this.cliType}] commitCurrentTranscript parsed.messages=none responseBufferLen=${this.responseBuffer.length} accumulatedBufferLen=${this.accumulatedBuffer.length} parsedStatus=${parsed?.status || '-'} providerDir=${this.providerResolutionMeta.providerDir || '-'} scriptDir=${this.providerResolutionMeta.scriptDir || '-'}`
+            );
+        }
         return {
             hasAssistant: false,
             assistantContent: '',
         };
     }
 
+
  // ─── Script Execution ──────────────────────────
 
     private runDetectStatus(text: string): string | null {
@@ -1359,26 +1528,35 @@ export class ProviderCliAdapter implements CliAdapter {
             this.currentTurnScope,
             screenText,
         );
+        if (this.maybeCommitVisibleIdleTranscript(parsed)) {
+            return this.getScriptParsedStatus();
+        }
         const shouldPreferCommittedMessages =
             !this.currentTurnScope
-            && this.currentStatus === 'idle'
-            && !this.activeModal;
+            && !this.activeModal
+            && this.currentStatus === 'idle';
         let result: any;
         if (parsed && Array.isArray(parsed.messages)) {
-            const hydratedMessages = shouldPreferCommittedMessages
-                ? this.committedMessages.map((message, index) => buildChatMessage({
-                    ...message,
-                    id: message.id || `msg_${index}`,
-                    index: typeof message.index === 'number' ? message.index : index,
-                    receivedAt: typeof message.receivedAt === 'number'
-                        ? message.receivedAt
-                        : message.timestamp,
-                }))
-                : hydrateCliParsedMessages(parsed.messages, {
-                    committedMessages: this.committedMessages,
-                    scope: this.currentTurnScope,
-                    lastOutputAt: this.lastOutputAt,
-                });
+            const parsedHydratedMessages = hydrateCliParsedMessages(parsed.messages, {
+                committedMessages: this.committedMessages,
+                scope: this.currentTurnScope,
+                lastOutputAt: this.lastOutputAt,
+            });
+            const committedHydratedMessages = this.committedMessages.map((message, index) => buildChatMessage({
+                ...message,
+                id: message.id || `msg_${index}`,
+                index: typeof message.index === 'number' ? message.index : index,
+                receivedAt: typeof message.receivedAt === 'number'
+                    ? message.receivedAt
+                    : message.timestamp,
+            }));
+            const shouldPreferCommittedHistoryReplay =
+                !this.currentTurnScope
+                && !this.activeModal
+                && committedHydratedMessages.length > parsedHydratedMessages.length;
+            const hydratedMessages = (shouldPreferCommittedMessages || shouldPreferCommittedHistoryReplay)
+                ? committedHydratedMessages
+                : parsedHydratedMessages;
             result = {
                 id: parsed.id || 'cli_session',
                 status: parsed.status || this.currentStatus,
@@ -1405,6 +1583,32 @@ export class ProviderCliAdapter implements CliAdapter {
             };
         }
 
+        const hasVisibleAssistantMessage = Array.isArray(result?.messages)
+            && result.messages.some((message: any) => message?.role === 'assistant' && typeof message?.content === 'string' && message.content.trim());
+        const shouldClampStaleGeneratingToIdle =
+            result?.status === 'generating'
+            && this.currentStatus === 'idle'
+            && !this.currentTurnScope
+            && !result?.activeModal
+            && hasVisibleAssistantMessage;
+        if (shouldClampStaleGeneratingToIdle) {
+            result = {
+                ...result,
+                status: 'idle',
+                messages: Array.isArray(result.messages)
+                    ? result.messages.map((message: any) => {
+                        if (message?.role !== 'assistant' || !message?.meta?.streaming) return message;
+                        const nextMeta = { ...(message.meta || {}) };
+                        delete nextMeta.streaming;
+                        return {
+                            ...message,
+                            ...(Object.keys(nextMeta).length > 0 ? { meta: nextMeta } : { meta: undefined }),
+                        };
+                    })
+                    : result.messages,
+            };
+        }
+
         this.parsedStatusCache = {
             committedMessagesRef: this.committedMessages,
             responseBuffer: this.responseBuffer,
@@ -1541,9 +1745,36 @@ export class ProviderCliAdapter implements CliAdapter {
             }
         }
         if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.currentStatus})`);
-        if (this.isWaitingForResponse && !allowInputDuringGeneration) {
+        const parsedStatusBeforeSend = !allowInputDuringGeneration
+            ? (() => {
+                try {
+                    return this.getScriptParsedStatus?.() || null;
+                } catch {
+                    return null;
+                }
+            })()
+            : null;
+        const parsedSessionStatus = typeof parsedStatusBeforeSend?.status === 'string'
+            ? String(parsedStatusBeforeSend.status)
+            : '';
+        const parsedMessagesBeforeSend = Array.isArray(parsedStatusBeforeSend?.messages)
+            ? parsedStatusBeforeSend.messages.filter((message: any) => message && (message.role === 'user' || message.role === 'assistant'))
+            : [];
+        const shouldCommitParsedIdleBeforeSend = !allowInputDuringGeneration
+            && parsedSessionStatus === 'idle'
+            && parsedMessagesBeforeSend.length > this.committedMessages.length
+            && parsedMessagesBeforeSend.some((message: any) => message?.role === 'assistant' && typeof message?.content === 'string' && message.content.trim());
+        if (shouldCommitParsedIdleBeforeSend) {
+            this.commitCurrentTranscript();
+        }
+        if (!allowInputDuringGeneration && (parsedSessionStatus === 'generating' || parsedSessionStatus === 'long_generating')) {
             throw new Error(`${this.cliName} is still processing the previous prompt`);
         }
+        if (this.isWaitingForResponse && !allowInputDuringGeneration) {
+            if (!this.clearStaleIdleResponseGuard('send_message_guard')) {
+                throw new Error(`${this.cliName} is still processing the previous prompt`);
+            }
+        }
         const blockingModal = this.activeModal || this.getStartupConfirmationModal(this.terminalScreen.getText() || '');
         if (blockingModal || this.currentStatus === 'waiting_approval') {
             throw new Error(`${this.cliName} is awaiting confirmation before it can accept a prompt`);
@@ -1622,7 +1853,7 @@ export class ProviderCliAdapter implements CliAdapter {
                     this.submitRetryTimer = null;
                     if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
                     if (this.currentStatus === 'waiting_approval') return;
-                    if ((this.responseBuffer || '').trim()) return;
+                    if (this.hasMeaningfulResponseBuffer(normalizedPromptSnippet)) return;
                     const screenText = this.terminalScreen.getText();
                     if (!promptLikelyVisible(screenText, normalizedPromptSnippet)) return;
                     if (/Esc to interrupt|Do you want to proceed|This command requires approval|Allow Codex to|Approve and run now|Always approve this session|Running…|Running\.\.\./i.test(screenText)) return;
@@ -1660,7 +1891,7 @@ export class ProviderCliAdapter implements CliAdapter {
                     this.submitRetryTimer = null;
                     if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
                     if (this.currentStatus === 'waiting_approval') return;
-                    if ((this.responseBuffer || '').trim()) return;
+                    if (this.hasMeaningfulResponseBuffer(normalizedPromptSnippet)) return;
                     const screenText = this.terminalScreen.getText();
                     if (!promptLikelyVisible(screenText, normalizedPromptSnippet)) return;
                     LOG.info('CLI', `[${this.cliType}] Retrying submit key for stuck prompt (attempt 1)`);

package/src/cli-adapters/session-host-transport.ts

@@ -27,6 +27,14 @@ interface SessionHostRuntimeOptions extends SessionHostPtyTransportFactoryOption
     spawnOptions: PtySpawnOptions;
 }
 
+export function shouldResumeAttachedSession(record: SessionHostRecord | null | undefined): boolean {
+    if (!record) return false;
+    if (record.lifecycle === 'interrupted') return true;
+    if (record.lifecycle !== 'stopped') return false;
+    if (record.meta?.restoredFromStorage === true) return true;
+    return typeof record.meta?.runtimeRecoveryState === 'string' && String(record.meta.runtimeRecoveryState).trim().length > 0;
+}
+
 class SessionHostRuntimeTransport implements PtyRuntimeTransport {
     readonly ready: Promise<void>;
     readonly terminalQueriesHandled = true;
@@ -215,7 +223,7 @@ class SessionHostRuntimeTransport implements PtyRuntimeTransport {
             const existingRecord = existingRecords.success && existingRecords.result
                 ? existingRecords.result.find((item) => item.sessionId === this.options.runtimeId) || null
                 : null;
-            if (existingRecord?.lifecycle === 'interrupted') {
+            if (shouldResumeAttachedSession(existingRecord)) {
                 const resumeResponse = await this.client.request<SessionHostRecord>({
                     type: 'resume_session',
                     payload: {

package/src/commands/chat-commands.ts

@@ -340,6 +340,9 @@ function normalizeReadChatCommandStatus(status: unknown, activeModal: unknown):
 
 function buildReadChatCommandResult(payload: Record<string, any>, args: any): CommandResult {
     let validatedPayload: Record<string, any>;
+    const debugReadChat = payload?.debugReadChat && typeof payload.debugReadChat === 'object'
+        ? payload.debugReadChat
+        : undefined;
     try {
         validatedPayload = validateReadChatResultPayload({
             ...payload,
@@ -361,6 +364,7 @@ function buildReadChatCommandResult(payload: Record<string, any>, args: any): Co
             replaceFrom: 0,
             totalMessages: messages.length,
             lastMessageSignature,
+            ...(debugReadChat ? { debugReadChat } : {}),
         };
     }
     const sync = computeReadChatSync(messages, cursor);
@@ -372,6 +376,7 @@ function buildReadChatCommandResult(payload: Record<string, any>, args: any): Co
         replaceFrom: sync.replaceFrom,
         totalMessages: sync.totalMessages,
         lastMessageSignature: sync.lastMessageSignature,
+        ...(debugReadChat ? { debugReadChat } : {}),
     };
 }
 
@@ -480,16 +485,44 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
             const parsedRecord = parsedStatus && typeof parsedStatus === 'object'
                 ? parsedStatus as Record<string, any>
                 : null;
-            const status = parsedRecord || adapter.getStatus();
+            const adapterStatus = adapter.getStatus();
+            const shouldPreferAdapterMessages =
+                Array.isArray(adapterStatus.messages)
+                && adapterStatus.messages.length > 0
+                && Array.isArray(parsedRecord?.messages)
+                && adapterStatus.messages.length > parsedRecord.messages.length;
+            const status = parsedRecord
+                ? {
+                    ...parsedRecord,
+                    messages: shouldPreferAdapterMessages ? adapterStatus.messages : parsedRecord.messages,
+                    status: adapterStatus.status !== 'idle'
+                        ? adapterStatus.status
+                        : (parsedRecord.status || adapterStatus.status),
+                    activeModal: parsedRecord.activeModal || adapterStatus.activeModal,
+                }
+                : adapterStatus;
+
             const title = typeof parsedRecord?.title === 'string' ? parsedRecord.title : undefined;
             const providerSessionId = typeof parsedRecord?.providerSessionId === 'string'
                 ? parsedRecord.providerSessionId
                 : undefined;
             if (status) {
+                LOG.info('Command', `[read_chat] cli-like resolved provider=${adapter.cliType} target=${String(args?.targetSessionId || '')} adapterStatus=${String(adapterStatus.status || '')} parsedStatus=${String(parsedRecord?.status || '')} shouldPreferAdapterMessages=${String(shouldPreferAdapterMessages)} adapterMsgCount=${Array.isArray(adapterStatus.messages) ? adapterStatus.messages.length : 0} parsedMsgCount=${Array.isArray(parsedRecord?.messages) ? parsedRecord.messages.length : 0} returnedMsgCount=${Array.isArray((status as any).messages) ? (status as any).messages.length : 0}`);
                 return buildReadChatCommandResult({
-                    messages: status.messages || [],
+                    messages: (status as any).messages || [],
                     status: status.status,
                     activeModal: status.activeModal,
+                    debugReadChat: {
+                        provider: adapter.cliType,
+                        targetSessionId: String(args?.targetSessionId || ''),
+                        adapterStatus: String(adapterStatus.status || ''),
+                        parsedStatus: String(parsedRecord?.status || ''),
+                        returnedStatus: String(status.status || ''),
+                        shouldPreferAdapterMessages,
+                        adapterMsgCount: Array.isArray(adapterStatus.messages) ? adapterStatus.messages.length : 0,
+                        parsedMsgCount: Array.isArray(parsedRecord?.messages) ? parsedRecord.messages.length : 0,
+                        returnedMsgCount: Array.isArray((status as any).messages) ? (status as any).messages.length : 0,
+                    },
                     ...(title ? { title } : {}),
                     ...(providerSessionId ? { providerSessionId } : {}),
                 }, args);

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;
+    }
+}