@adhdev/daemon-core 0.8.82 → 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/dist/shared-types.d.ts

@@ -270,6 +270,8 @@ export interface SessionEntry {
     unread?: boolean;
     lastSeenAt?: number;
     inboxBucket?: RecentSessionBucket;
+    completionMarker?: string;
+    seenCompletionMarker?: string;
     surfaceHidden?: boolean;
 }
 /**

package/dist/status/chat-tail-hot-sessions.d.ts

@@ -3,6 +3,8 @@ export declare const DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS = 8000;
 export interface HotChatSessionLike {
     id?: string | null;
     status?: unknown;
+    unread?: unknown;
+    inboxBucket?: unknown;
     lastMessageAt?: unknown;
     runtimeLifecycle?: unknown;
     runtimeSurfaceKind?: unknown;

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

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.82",
+  "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.82",
+  "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/cli-adapters/provider-cli-adapter.ts

@@ -17,6 +17,7 @@
 import * as os from 'os';
 import type { CliAdapter } from '../cli-adapter-types.js';
 import { LOG } from '../logging/logger.js';
+import { getDebugRuntimeConfig } from '../logging/debug-config.js';
 import { TerminalScreen } from './terminal-screen.js';
 import {
     NodePtyTransportFactory,
@@ -182,8 +183,23 @@ export class ProviderCliAdapter implements CliAdapter {
     private currentTurnScope: TurnParseScope | null = null;
     private traceEntries: CliTraceEntry[] = [];
     private traceSeq = 0;
-    private traceSessionId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    private traceSessionId = '';
+    private parsedStatusCache: {
+        committedMessagesRef: CliChatMessage[];
+        responseBuffer: string;
+        currentTurnScope: TurnParseScope | null;
+        recentOutputBuffer: string;
+        accumulatedBuffer: string;
+        accumulatedRawBuffer: string;
+        screenText: string;
+        currentStatus: CliSessionStatus['status'];
+        activeModal: { message: string; buttons: string[] } | null;
+        cliName: string;
+        lastOutputAt: number;
+        result: any;
+    } | null = null;
     private static readonly MAX_TRACE_ENTRIES = 250;
+
     private readonly providerResolutionMeta: ProviderResolutionMeta;
     private static readonly FINISH_RETRY_DELAY_MS = 300;
     private static readonly MAX_FINISH_RETRIES = 2;
@@ -323,7 +339,19 @@ export class ProviderCliAdapter implements CliAdapter {
                 `[${this.cliType}] Provider resolution: providerDir=${this.providerResolutionMeta.providerDir || '-'} scriptDir=${this.providerResolutionMeta.scriptDir || '-'} scriptsPath=${this.providerResolutionMeta.scriptsPath || '-'} source=${this.providerResolutionMeta.scriptsSource || '-'} version=${this.providerResolutionMeta.resolvedVersion || '-'}`
             );
         } else {
-            LOG.warn('CLI', `[${this.cliType}] ⚠ No CLI scripts loaded! Provider needs scripts/{version}/scripts.js`);
+            const resolutionSummary = `providerDir=${this.providerResolutionMeta.providerDir || '-'} scriptDir=${this.providerResolutionMeta.scriptDir || '-'} scriptsPath=${this.providerResolutionMeta.scriptsPath || '-'} source=${this.providerResolutionMeta.scriptsSource || '-'} version=${this.providerResolutionMeta.resolvedVersion || '-'}`;
+            const hasResolvedProviderScripts = Boolean(
+                this.providerResolutionMeta.providerDir
+                || this.providerResolutionMeta.scriptDir
+                || this.providerResolutionMeta.scriptsPath
+                || this.providerResolutionMeta.scriptsSource
+                || this.providerResolutionMeta.resolvedVersion,
+            );
+            if (hasResolvedProviderScripts) {
+                LOG.warn('CLI', `[${this.cliType}] ⚠ No CLI scripts loaded! Provider needs scripts/{version}/scripts.js (${resolutionSummary})`);
+            } else {
+                LOG.info('CLI', `[${this.cliType}] CLI scripts not yet resolved (${resolutionSummary})`);
+            }
         }
     }
 
@@ -485,7 +513,8 @@ export class ProviderCliAdapter implements CliAdapter {
         this.terminalScreen.write(rawData);
         const cleanData = sanitizeTerminalText(rawData);
         const now = Date.now();
-        const normalizedScreenSnapshot = normalizeScreenSnapshot(this.terminalScreen.getText());
+        const screenText = this.terminalScreen.getText();
+        const normalizedScreenSnapshot = normalizeScreenSnapshot(screenText);
         this.lastOutputAt = now;
         if (cleanData.trim()) this.lastNonEmptyOutputAt = now;
         if (normalizedScreenSnapshot !== this.lastScreenSnapshot) {
@@ -498,13 +527,14 @@ export class ProviderCliAdapter implements CliAdapter {
         if (this.idleFinishCandidate && (rawData.length > 0 || cleanData.length > 0)) {
             this.clearIdleFinishCandidate('new_output');
         }
-        this.recordTrace('output', {
-            rawLength: rawData.length,
-            cleanLength: cleanData.length,
-            rawPreview: summarizeCliTraceText(rawData, 300),
-            cleanPreview: summarizeCliTraceText(cleanData, 300),
-            screenText: summarizeCliTraceText(this.terminalScreen.getText(), 1200),
-        });
+        if (getDebugRuntimeConfig().collectDebugTrace) {
+            this.recordTrace('output', {
+                rawLength: rawData.length,
+                cleanLength: cleanData.length,
+                rawPreview: summarizeCliTraceText(rawData, 300),
+                cleanPreview: summarizeCliTraceText(cleanData, 300),
+            });
+        }
 
         if (this.startupParseGate) {
             this.scheduleStartupSettleCheck();
@@ -1304,15 +1334,36 @@ export class ProviderCliAdapter implements CliAdapter {
      * Called by command handler / dashboard for rich content rendering.
      */
     getScriptParsedStatus(): any {
+        const screenText = this.terminalScreen.getText();
+        const cached = this.parsedStatusCache;
+        if (
+            cached
+            && cached.committedMessagesRef === this.committedMessages
+            && cached.responseBuffer === this.responseBuffer
+            && cached.currentTurnScope === this.currentTurnScope
+            && cached.recentOutputBuffer === this.recentOutputBuffer
+            && cached.accumulatedBuffer === this.accumulatedBuffer
+            && cached.accumulatedRawBuffer === this.accumulatedRawBuffer
+            && cached.screenText === screenText
+            && cached.currentStatus === this.currentStatus
+            && cached.activeModal === this.activeModal
+            && cached.cliName === this.cliName
+            && cached.lastOutputAt === this.lastOutputAt
+        ) {
+            return cached.result;
+        }
+
         const parsed = this.parseCurrentTranscript(
             this.committedMessages,
             this.responseBuffer,
             this.currentTurnScope,
+            screenText,
         );
         const shouldPreferCommittedMessages =
             !this.currentTurnScope
             && this.currentStatus === 'idle'
             && !this.activeModal;
+        let result: any;
         if (parsed && Array.isArray(parsed.messages)) {
             const hydratedMessages = shouldPreferCommittedMessages
                 ? this.committedMessages.map((message, index) => buildChatMessage({
@@ -1328,7 +1379,7 @@ export class ProviderCliAdapter implements CliAdapter {
                     scope: this.currentTurnScope,
                     lastOutputAt: this.lastOutputAt,
                 });
-            return {
+            result = {
                 id: parsed.id || 'cli_session',
                 status: parsed.status || this.currentStatus,
                 title: parsed.title || this.cliName,
@@ -1336,23 +1387,39 @@ export class ProviderCliAdapter implements CliAdapter {
                 activeModal: parsed.activeModal ?? this.activeModal,
                 providerSessionId: typeof parsed.providerSessionId === 'string' ? parsed.providerSessionId : undefined,
             };
+        } else {
+            const messages = [...this.committedMessages];
+            result = {
+                id: 'cli_session',
+                status: this.currentStatus,
+                title: this.cliName,
+                messages: messages.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,
+                })),
+                activeModal: this.activeModal,
+            };
         }
 
-        const messages = [...this.committedMessages];
-        return {
-            id: 'cli_session',
-            status: this.currentStatus,
-            title: this.cliName,
-            messages: messages.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,
-            })),
+        this.parsedStatusCache = {
+            committedMessagesRef: this.committedMessages,
+            responseBuffer: this.responseBuffer,
+            currentTurnScope: this.currentTurnScope,
+            recentOutputBuffer: this.recentOutputBuffer,
+            accumulatedBuffer: this.accumulatedBuffer,
+            accumulatedRawBuffer: this.accumulatedRawBuffer,
+            screenText,
+            currentStatus: this.currentStatus,
             activeModal: this.activeModal,
+            cliName: this.cliName,
+            lastOutputAt: this.lastOutputAt,
+            result,
         };
+        return result;
     }
 
     async invokeScript(scriptName: string, args?: Record<string, any>): Promise<any> {
@@ -1377,17 +1444,18 @@ export class ProviderCliAdapter implements CliAdapter {
         }));
     }
 
-    private parseCurrentTranscript(baseMessages: CliChatMessage[], partialResponse: string, scope?: TurnParseScope | null): any {
+    private parseCurrentTranscript(baseMessages: CliChatMessage[], partialResponse: string, scope?: TurnParseScope | null, screenTextOverride?: string): any {
         if (!this.cliScripts?.parseOutput) {
             this.parseErrorMessage = null;
             return null;
         }
         try {
+            const screenText = typeof screenTextOverride === 'string' ? screenTextOverride : this.terminalScreen.getText();
             const input = buildCliParseInput({
                 accumulatedBuffer: this.accumulatedBuffer,
                 accumulatedRawBuffer: this.accumulatedRawBuffer,
                 recentOutputBuffer: this.recentOutputBuffer,
-                terminalScreenText: this.terminalScreen.getText(),
+                terminalScreenText: screenText,
                 baseMessages,
                 partialResponse,
                 isWaitingForResponse: this.isWaitingForResponse,

package/src/cli-adapters/terminal-screen.ts

@@ -67,10 +67,12 @@ function logTerminalBackendSelection(
     if (loggedTerminalBackends.has(key)) return;
     loggedTerminalBackends.add(key);
     if (backendKind === 'xterm' && preference !== 'xterm' && !ghosttyAvailable) {
-        LOG.warn(
-            'Terminal',
-            `[terminal-screen] ghostty-vt unavailable; using xterm fallback (preference=${preference})`,
-        );
+        const message = `[terminal-screen] ghostty-vt unavailable; using xterm fallback (preference=${preference})`;
+        if (preference === 'auto') {
+            LOG.info('Terminal', message);
+        } else {
+            LOG.warn('Terminal', message);
+        }
         return;
     }
     LOG.info(

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(
@@ -231,6 +284,7 @@ export class CliProviderInstance implements ProviderInstance {
 
     async onTick(): Promise<void> {
         if (this.providerSessionId) return;
+        if (this.type === 'hermes-cli' && this.launchMode === 'new') return;
 
         let probedSessionId: string | null = null;
 
@@ -362,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' });
@@ -639,6 +702,7 @@ export class CliProviderInstance implements ProviderInstance {
 
         if (data.sessionEvent === 'new_session') {
             this.runtimeMessages = [];
+            this.lastPersistedHistoryMessages = [];
             this.suppressIdleHistoryReplay = false;
             this.adapter.clearHistory();
         }

package/src/shared-types.d.ts

@@ -190,10 +190,13 @@ export interface SessionEntry {
     summaryMetadata?: ProviderSummaryMetadata;
     errorMessage?: string;
     errorReason?: _ProviderErrorReason;
+    lastMessageHash?: string;
     lastUpdated?: number;
     unread?: boolean;
     lastSeenAt?: number;
     inboxBucket?: RecentSessionBucket;
+    completionMarker?: string;
+    seenCompletionMarker?: string;
     surfaceHidden?: boolean;
 }
 /**

package/src/shared-types.ts

@@ -339,6 +339,8 @@ export interface SessionEntry {
     unread?: boolean;
     lastSeenAt?: number;
     inboxBucket?: RecentSessionBucket;
+    completionMarker?: string;
+    seenCompletionMarker?: string;
     surfaceHidden?: boolean;
 }
 

package/src/status/chat-tail-hot-sessions.ts

@@ -13,6 +13,8 @@ const LIVE_RUNTIME_LIFECYCLES = new Set(['starting', 'running', 'stopping', 'int
 export interface HotChatSessionLike {
   id?: string | null;
   status?: unknown;
+  unread?: unknown;
+  inboxBucket?: unknown;
   lastMessageAt?: unknown;
   runtimeLifecycle?: unknown;
   runtimeSurfaceKind?: unknown;
@@ -79,10 +81,22 @@ export function classifyHotChatSessionsForSubscriptionFlush(
     }
 
     const status = String(session?.status || '').toLowerCase();
+    const unread = session?.unread === true;
+    const inboxBucket = String(session?.inboxBucket || '').toLowerCase();
+    const runtimeSurfaceKind = String(session?.runtimeSurfaceKind || '').toLowerCase();
+    const runtimeLifecycle = String(session?.runtimeLifecycle || '').toLowerCase();
+    const isLiveRuntime = runtimeSurfaceKind === 'live_runtime' || LIVE_RUNTIME_LIFECYCLES.has(runtimeLifecycle);
     const lastMessageAt = parseMessageTimestamp(session?.lastMessageAt);
     const recentlyUpdated = lastMessageAt > 0 && (now - lastMessageAt) <= recentMessageGraceMs;
+    const shouldKeepRecentTailHot = recentlyUpdated && (
+      unread
+      || inboxBucket === 'task_complete'
+      || inboxBucket === 'needs_attention'
+      || isLiveRuntime
+      || activeStatuses.has(status)
+    );
 
-    if (activeStatuses.has(status) || recentlyUpdated) {
+    if (activeStatuses.has(status) || shouldKeepRecentTailHot) {
       active.add(sessionId);
     }
   }

package/src/status/snapshot.ts

@@ -408,6 +408,8 @@ export function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnaps
         session.lastSeenAt = lastSeenAt;
         session.unread = overlayUnread;
         session.inboxBucket = overlayInboxBucket;
+        session.completionMarker = completionMarker;
+        session.seenCompletionMarker = seenCompletionMarker;
         if (READ_DEBUG_ENABLED && (session.unread || session.inboxBucket !== 'idle' || session.providerType.includes('codex'))) {
             const recentReadSnapshot: RecentReadDebugSnapshot = {
                 sessionId: session.id,