@adhdev/daemon-core 0.8.63 → 0.8.65

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

@@ -39,6 +39,7 @@ export declare class AcpProviderInstance implements ProviderInstance {
     private activeToolCalls;
     private stopReason;
     private partialContent;
+    private partialThoughtContent;
     /** Rich content blocks accumulated during streaming */
     private partialBlocks;
     /** Tool calls collected during current turn */
@@ -94,6 +95,10 @@ export declare class AcpProviderInstance implements ProviderInstance {
     private truncateContent;
     /** Build ContentBlock[] from current partial state */
     private buildPartialBlocks;
+    private buildPartialThoughtMessage;
+    private buildToolCallBubbleKind;
+    private summarizeToolCallBubbleContent;
+    private buildTurnToolCallMessages;
     /** Finalize streaming content into an assistant message */
     private finalizeAssistantMessage;
     /** Convert ACP ToolCallContent[] to our ToolCallContent[] */

package/dist/providers/chat-message-normalization.d.ts

@@ -4,6 +4,7 @@ export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];
 export type ChatMessageKind = BuiltinChatMessageKind | (string & {});
 export declare function isBuiltinChatMessageKind(kind: unknown): kind is BuiltinChatMessageKind;
 export declare function normalizeChatMessageKind(kind: unknown, role: unknown): ChatMessageKind;
+export declare function resolveChatMessageKind<T extends ChatMessage>(message: T): ChatMessageKind;
 export declare function buildChatMessage<T extends Omit<ChatMessage, 'kind'> & {
     kind?: ChatMessageKind;
 }>(message: T): T & {
@@ -32,6 +33,27 @@ export declare function buildAssistantChatMessage<T extends Omit<ChatMessage, 'r
     role: 'assistant';
     kind: ChatMessageKind;
 });
+export declare function buildThoughtChatMessage<T extends Omit<ChatMessage, 'role' | 'kind'> & {
+    role?: 'assistant';
+    kind?: ChatMessageKind;
+}>(message: T): (T & {
+    role: 'assistant';
+    kind: ChatMessageKind;
+});
+export declare function buildToolChatMessage<T extends Omit<ChatMessage, 'role' | 'kind'> & {
+    role?: 'assistant';
+    kind?: ChatMessageKind;
+}>(message: T): (T & {
+    role: 'assistant';
+    kind: ChatMessageKind;
+});
+export declare function buildTerminalChatMessage<T extends Omit<ChatMessage, 'role' | 'kind'> & {
+    role?: 'assistant';
+    kind?: ChatMessageKind;
+}>(message: T): (T & {
+    role: 'assistant';
+    kind: ChatMessageKind;
+});
 export declare function buildUserChatMessage<T extends Omit<ChatMessage, 'role' | 'kind'> & {
     role?: 'user';
     kind?: ChatMessageKind;

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

@@ -0,0 +1,15 @@
+export declare const DEFAULT_ACTIVE_CHAT_POLL_STATUSES: Set<string>;
+export declare const DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS = 8000;
+export interface HotChatSessionLike {
+    id?: string | null;
+    status?: unknown;
+    lastMessageAt?: unknown;
+}
+export declare function classifyHotChatSessionsForSubscriptionFlush(sessions: HotChatSessionLike[], previousHotSessionIds: ReadonlySet<string>, options?: {
+    now?: number;
+    recentMessageGraceMs?: number;
+    activeStatuses?: ReadonlySet<string>;
+}): {
+    active: Set<string>;
+    finalizing: Set<string>;
+};

package/dist/status/snapshot.d.ts

@@ -66,6 +66,7 @@ export declare function getSessionCompletionMarker(session: {
             id?: string;
             index?: number;
             receivedAt?: number | string;
+            timestamp?: number | string;
             _turnKey?: string;
         }> | null;
     } | null;

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

@@ -1,7 +1,7 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.63",
-  "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
+  "version": "0.8.65",
+  "description": "ADHDev local session host core — session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {

package/package.json

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

package/src/agent-stream/provider-adapter.ts

@@ -14,6 +14,7 @@ import type {
 import type { ProviderModule, ProviderScripts } from '../providers/contracts.js';
 import { extractProviderControlValues, normalizeProviderEffects } from '../providers/control-effects.js';
 import { resolveProviderStateSurface } from '../providers/provider-patch-state.js';
+import { normalizeChatMessages } from '../providers/chat-message-normalization.js';
 
 export class ProviderStreamAdapter implements IAgentStreamAdapter {
     readonly agentType: string;
@@ -153,7 +154,7 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
                 agentName: this.agentName,
                 extensionId: this.extensionId,
                 status: data.status || 'idle',
-                messages: data.messages || [],
+                messages: normalizeChatMessages(Array.isArray(data.messages) ? data.messages : []) as any,
                 inputContent: data.inputContent || '',
                 activeModal: data.activeModal,
             };

package/src/agent-stream/types.ts

@@ -7,12 +7,21 @@
 
 import type { ProviderEffect } from '../providers/contracts.js';
 import type { ProviderSummaryMetadata } from '../shared-types.js';
+import type { ChatMessageKind } from '../providers/chat-message-normalization.js';
 
 /** Agent chat message */
 export interface AgentChatMessage {
     role: 'user' | 'assistant' | 'system';
     content: string;
+    kind?: ChatMessageKind;
     timestamp?: number;
+    receivedAt?: number;
+    id?: string;
+    index?: number;
+    meta?: Record<string, unknown>;
+    senderName?: string;
+    _type?: string;
+    _sub?: string;
 }
 
 /** Agent chat history item */

package/src/index.ts

@@ -115,6 +115,11 @@ export type { IDEInfo } from './detection/ide-detector.js';
 export { detectCLIs } from './detection/cli-detector.js';
 export { getHostMemorySnapshot } from './system/host-memory.js';
 export type { HostMemorySnapshot } from './system/host-memory.js';
+export {
+  classifyHotChatSessionsForSubscriptionFlush,
+  DEFAULT_ACTIVE_CHAT_POLL_STATUSES,
+  DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS,
+} from './status/chat-tail-hot-sessions.js';
 
 // ── CDP ──
 export { DaemonCdpManager } from './cdp/manager.js';
@@ -204,10 +209,14 @@ export {
   BUILTIN_CHAT_MESSAGE_KINDS,
   isBuiltinChatMessageKind,
   normalizeChatMessageKind,
+  resolveChatMessageKind,
   buildChatMessage,
   buildSystemChatMessage,
   buildRuntimeSystemChatMessage,
   buildAssistantChatMessage,
+  buildThoughtChatMessage,
+  buildToolChatMessage,
+  buildTerminalChatMessage,
   buildUserChatMessage,
   normalizeChatMessage,
   normalizeChatMessages,

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

@@ -51,7 +51,16 @@ import { normalizeContent, flattenContent, normalizeInputEnvelope } from './cont
 import type { ProviderInstance, ProviderState, AcpProviderState, ProviderErrorReason, ProviderEvent, InstanceContext } from './provider-instance.js';
 import { StatusMonitor } from './status-monitor.js';
 import { buildLegacyModelModeSummaryMetadata } from './summary-metadata.js';
-import { buildAssistantChatMessage, buildChatMessage, buildRuntimeSystemChatMessage, buildUserChatMessage, normalizeChatMessages } from './chat-message-normalization.js';
+import {
+    buildAssistantChatMessage,
+    buildChatMessage,
+    buildRuntimeSystemChatMessage,
+    buildTerminalChatMessage,
+    buildThoughtChatMessage,
+    buildToolChatMessage,
+    buildUserChatMessage,
+    normalizeChatMessages,
+} from './chat-message-normalization.js';
 import { LOG } from '../logging/logger.js';
 import type { ChatMessage } from '../types.js';
 
@@ -231,6 +240,7 @@ export class AcpProviderInstance implements ProviderInstance {
     private activeToolCalls: AcpToolCall[] = [];
     private stopReason: string | null = null;
     private partialContent = '';
+    private partialThoughtContent = '';
     /** Rich content blocks accumulated during streaming */
     private partialBlocks: ContentBlock[] = [];
     /** Tool calls collected during current turn */
@@ -300,7 +310,12 @@ export class AcpProviderInstance implements ProviderInstance {
                 ...m,
                 content,
             });
-        }));
+        })) as ChatMessage[];
+
+        if (this.currentStatus === 'generating') {
+            const partialThoughtMessage = this.buildPartialThoughtMessage(Date.now());
+            if (partialThoughtMessage) recentMessages.push(partialThoughtMessage as ChatMessage);
+        }
 
  // generating during partial response add
         if (this.currentStatus === 'generating' && (this.partialContent || this.partialBlocks.length > 0)) {
@@ -980,6 +995,7 @@ export class AcpProviderInstance implements ProviderInstance {
 
         this.currentStatus = 'generating';
         this.partialContent = '';
+        this.partialThoughtContent = '';
         this.partialBlocks = [];
         this.turnToolCalls = [];
         this.detectStatusTransition();
@@ -1076,9 +1092,15 @@ export class AcpProviderInstance implements ProviderInstance {
                 this.currentStatus = 'generating';
                 break;
             }
-            case 'agent_thought_chunk':
+            case 'agent_thought_chunk': {
+                const content = update.content;
+                if (content?.type === 'text' && typeof content.text === 'string') {
+                    this.partialThoughtContent += content.text;
+                }
+                this.currentStatus = 'generating';
+                break;
+            }
             case 'user_message_chunk': {
- // Track but don't display thought chunks as main content
                 break;
             }
             case 'tool_call': {
@@ -1256,8 +1278,101 @@ export class AcpProviderInstance implements ProviderInstance {
         return blocks;
     }
 
+    private buildPartialThoughtMessage(timestamp = Date.now()): AcpMessage | null {
+        const content = this.partialThoughtContent.trim();
+        if (!content) return null;
+        return buildThoughtChatMessage({
+            content,
+            timestamp,
+            meta: {
+                label: 'Thought',
+                isRunning: this.currentStatus === 'generating',
+            },
+        });
+    }
+
+    private buildToolCallBubbleKind(toolCall: ToolCallInfo): 'thought' | 'tool' | 'terminal' {
+        if (toolCall.kind === 'think') return 'thought';
+        if (toolCall.kind === 'execute') return 'terminal';
+        if (Array.isArray(toolCall.content) && toolCall.content.some((entry) => entry?.type === 'terminal')) return 'terminal';
+        return 'tool';
+    }
+
+    private summarizeToolCallBubbleContent(toolCall: ToolCallInfo): string {
+        const rawOutput = typeof toolCall.rawOutput === 'string'
+            ? toolCall.rawOutput.trim()
+            : (toolCall.rawOutput != null ? JSON.stringify(toolCall.rawOutput) : '');
+        if (rawOutput) return rawOutput;
+
+        const contentText = Array.isArray(toolCall.content)
+            ? toolCall.content
+                .map((entry) => {
+                    if (!entry || typeof entry !== 'object') return '';
+                    if (entry.type === 'content') return flattenContent([entry.content]).trim();
+                    if (entry.type === 'diff') return `${entry.path}\n${entry.newText || ''}`.trim();
+                    if (entry.type === 'terminal') return `Terminal: ${entry.terminalId || ''}`.trim();
+                    return '';
+                })
+                .filter(Boolean)
+                .join('\n\n')
+                .trim()
+            : '';
+        if (contentText) return contentText;
+
+        const rawInput = typeof toolCall.rawInput === 'string'
+            ? toolCall.rawInput.trim()
+            : (toolCall.rawInput != null ? JSON.stringify(toolCall.rawInput) : '');
+        if (rawInput) {
+            return toolCall.title ? `${toolCall.title}\n${rawInput}` : rawInput;
+        }
+
+        return toolCall.title || '';
+    }
+
+    private buildTurnToolCallMessages(timestamp = Date.now()): AcpMessage[] {
+        return this.turnToolCalls
+            .map((toolCall) => {
+                const content = this.summarizeToolCallBubbleContent(toolCall);
+                if (!content) return null;
+                const isRunning = toolCall.status === 'pending' || toolCall.status === 'in_progress';
+                const label = toolCall.title || undefined;
+                const kind = this.buildToolCallBubbleKind(toolCall);
+                if (kind === 'thought') {
+                    return buildThoughtChatMessage({
+                        content,
+                        timestamp,
+                        meta: { label: label || 'Thought', isRunning },
+                    });
+                }
+                if (kind === 'terminal') {
+                    return buildTerminalChatMessage({
+                        content,
+                        timestamp,
+                        meta: { label: label || 'Ran command', isRunning },
+                    });
+                }
+                return buildToolChatMessage({
+                    content,
+                    timestamp,
+                    meta: { label: label || 'Tool call', isRunning },
+                });
+            })
+            .filter(Boolean) as AcpMessage[];
+    }
+
     /** Finalize streaming content into an assistant message */
     private finalizeAssistantMessage(): void {
+        const timestamp = Date.now();
+        const thoughtMessage = this.buildPartialThoughtMessage(timestamp);
+        if (thoughtMessage) {
+            this.messages.push(thoughtMessage);
+        }
+
+        const toolCallMessages = this.buildTurnToolCallMessages(timestamp);
+        if (toolCallMessages.length > 0) {
+            this.messages.push(...toolCallMessages);
+        }
+
         const blocks = this.buildPartialBlocks();
         // Remove trailing '...' from text blocks for final message
         const finalBlocks = blocks.map(b => {
@@ -1277,6 +1392,7 @@ export class AcpProviderInstance implements ProviderInstance {
             }));
         }
         this.partialContent = '';
+        this.partialThoughtContent = '';
         this.partialBlocks = [];
         this.turnToolCalls = [];
     }

package/src/providers/chat-message-normalization.ts

@@ -6,23 +6,107 @@ export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];
 export type ChatMessageKind = BuiltinChatMessageKind | (string & {});
 
 const KNOWN_CHAT_MESSAGE_KINDS = new Set<string>(BUILTIN_CHAT_MESSAGE_KINDS);
+const CHAT_MESSAGE_KIND_ALIASES: Record<string, BuiltinChatMessageKind> = {
+  text: 'standard',
+  message: 'standard',
+  assistant: 'standard',
+  thinking: 'thought',
+  think: 'thought',
+  reasoning: 'thought',
+  reason: 'thought',
+  toolcall: 'tool',
+  tool_call: 'tool',
+  tooluse: 'tool',
+  tool_use: 'tool',
+  action: 'tool',
+  command: 'terminal',
+  cmd: 'terminal',
+  shell: 'terminal',
+  console: 'terminal',
+};
+
+function canonicalizeKindHint(value: string): string {
+  return value.trim().toLowerCase().replace(/[\s-]+/g, '_');
+}
+
+function resolveBuiltinOrAliasKind(kind: unknown): BuiltinChatMessageKind | null {
+  if (typeof kind !== 'string') return null;
+  const normalizedKind = canonicalizeKindHint(kind);
+  if (!normalizedKind) return null;
+  if (KNOWN_CHAT_MESSAGE_KINDS.has(normalizedKind)) return normalizedKind as BuiltinChatMessageKind;
+  return CHAT_MESSAGE_KIND_ALIASES[normalizedKind] || null;
+}
+
+function inferHintKind(value: unknown): BuiltinChatMessageKind | null {
+  const direct = resolveBuiltinOrAliasKind(value);
+  if (direct) return direct;
+  if (typeof value !== 'string') return null;
+  const normalized = canonicalizeKindHint(value);
+  if (!normalized) return null;
+  if (/thought|thinking|reasoning/.test(normalized)) return 'thought';
+  if (/tool/.test(normalized)) return 'tool';
+  if (/terminal|command|shell|console/.test(normalized)) return 'terminal';
+  return null;
+}
+
+function inferKindFromToolCalls(message: ChatMessage): BuiltinChatMessageKind | null {
+  const toolCalls = Array.isArray(message?.toolCalls) ? message.toolCalls : [];
+  if (toolCalls.length === 0) return null;
+  if (toolCalls.some((toolCall) => toolCall?.kind === 'think')) return 'thought';
+  if (toolCalls.some((toolCall) => toolCall?.kind === 'execute')) return 'terminal';
+  if (toolCalls.some((toolCall) => Array.isArray(toolCall?.content) && toolCall.content.some((entry) => entry?.type === 'terminal'))) {
+    return 'terminal';
+  }
+  return 'tool';
+}
+
+function inferMissingChatMessageKind(message: ChatMessage): BuiltinChatMessageKind | null {
+  const role = typeof message?.role === 'string' ? message.role.trim().toLowerCase() : '';
+  if (role === 'system') return 'system';
+
+  const meta = message?.meta && typeof message.meta === 'object' ? message.meta as Record<string, unknown> : undefined;
+  const hintCandidates: unknown[] = [
+    message?._sub,
+    message?._type,
+    meta?.label,
+    typeof message?.senderName === 'string' ? message.senderName : undefined,
+  ];
+
+  for (const candidate of hintCandidates) {
+    const inferred = inferHintKind(candidate);
+    if (inferred) return inferred;
+  }
+
+  const inferredFromToolCalls = inferKindFromToolCalls(message);
+  if (inferredFromToolCalls) return inferredFromToolCalls;
+  return null;
+}
 
 export function isBuiltinChatMessageKind(kind: unknown): kind is BuiltinChatMessageKind {
-  return typeof kind === 'string' && KNOWN_CHAT_MESSAGE_KINDS.has(kind.trim().toLowerCase());
+  return resolveBuiltinOrAliasKind(kind) !== null;
 }
 
 export function normalizeChatMessageKind(kind: unknown, role: unknown): ChatMessageKind {
-  const normalizedKind = typeof kind === 'string' ? kind.trim().toLowerCase() : '';
-  if (normalizedKind && KNOWN_CHAT_MESSAGE_KINDS.has(normalizedKind)) return normalizedKind as BuiltinChatMessageKind;
+  const resolvedKind = resolveBuiltinOrAliasKind(kind);
+  if (resolvedKind) return resolvedKind;
 
   const normalizedRole = typeof role === 'string' ? role.trim().toLowerCase() : '';
   return normalizedRole === 'system' ? 'system' : 'standard';
 }
 
+export function resolveChatMessageKind<T extends ChatMessage>(message: T): ChatMessageKind {
+  const explicitKind = resolveBuiltinOrAliasKind(message?.kind);
+  if (explicitKind) return explicitKind;
+
+  const inferredKind = inferMissingChatMessageKind(message);
+  if (inferredKind) return inferredKind;
+  return normalizeChatMessageKind(message?.kind, message?.role);
+}
+
 export function buildChatMessage<T extends Omit<ChatMessage, 'kind'> & { kind?: ChatMessageKind }>(message: T): T & { kind: ChatMessageKind } {
   return {
     ...message,
-    kind: normalizeChatMessageKind(message?.kind, message?.role),
+    kind: resolveChatMessageKind(message as unknown as ChatMessage),
   };
 }
 
@@ -51,6 +135,27 @@ export function buildAssistantChatMessage<T extends Omit<ChatMessage, 'role' | '
   } as T & { role: 'assistant'; kind?: ChatMessageKind }) as T & { role: 'assistant'; kind: ChatMessageKind };
 }
 
+export function buildThoughtChatMessage<T extends Omit<ChatMessage, 'role' | 'kind'> & { role?: 'assistant'; kind?: ChatMessageKind }>(message: T): (T & { role: 'assistant'; kind: ChatMessageKind }) {
+  return buildAssistantChatMessage({
+    ...message,
+    kind: message?.kind || 'thought',
+  } as T & { role?: 'assistant'; kind?: ChatMessageKind }) as T & { role: 'assistant'; kind: ChatMessageKind };
+}
+
+export function buildToolChatMessage<T extends Omit<ChatMessage, 'role' | 'kind'> & { role?: 'assistant'; kind?: ChatMessageKind }>(message: T): (T & { role: 'assistant'; kind: ChatMessageKind }) {
+  return buildAssistantChatMessage({
+    ...message,
+    kind: message?.kind || 'tool',
+  } as T & { role?: 'assistant'; kind?: ChatMessageKind }) as T & { role: 'assistant'; kind: ChatMessageKind };
+}
+
+export function buildTerminalChatMessage<T extends Omit<ChatMessage, 'role' | 'kind'> & { role?: 'assistant'; kind?: ChatMessageKind }>(message: T): (T & { role: 'assistant'; kind: ChatMessageKind }) {
+  return buildAssistantChatMessage({
+    ...message,
+    kind: message?.kind || 'terminal',
+  } as T & { role?: 'assistant'; kind?: ChatMessageKind }) as T & { role: 'assistant'; kind: ChatMessageKind };
+}
+
 export function buildUserChatMessage<T extends Omit<ChatMessage, 'role' | 'kind'> & { role?: 'user'; kind?: ChatMessageKind }>(message: T): (T & { role: 'user'; kind: ChatMessageKind }) {
   return buildChatMessage({
     ...message,

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

@@ -336,11 +336,13 @@ export class IdeProviderInstance implements ProviderInstance {
                 if (pm.receivedAt) prevByHash.set(h, pm.receivedAt);
             }
             const now = Date.now();
-            const messages = chat.messages || [];
-            for (const msg of messages) {
+            const rawMessages = chat.messages || [];
+            for (const msg of rawMessages) {
                 const h = `${msg.role}:${(msg.content || '').slice(0, 100)}`;
                 msg.receivedAt = prevByHash.get(h) || now;
             }
+            chat.messages = normalizeChatMessages(rawMessages as ChatMessage[]) as any;
+            const messages = chat.messages || [];
 
             // Filter messages by provider settings (showThinking, showToolCalls, showTerminal)
             if (messages.length > 0) {

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

@@ -0,0 +1,61 @@
+export const DEFAULT_ACTIVE_CHAT_POLL_STATUSES = new Set([
+  'generating',
+  'waiting_approval',
+  'starting',
+]);
+
+export const DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS = 8_000;
+
+export interface HotChatSessionLike {
+  id?: string | null;
+  status?: unknown;
+  lastMessageAt?: unknown;
+}
+
+function parseMessageTimestamp(value: unknown): number {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string') {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return 0;
+}
+
+export function classifyHotChatSessionsForSubscriptionFlush(
+  sessions: HotChatSessionLike[],
+  previousHotSessionIds: ReadonlySet<string>,
+  options: {
+    now?: number;
+    recentMessageGraceMs?: number;
+    activeStatuses?: ReadonlySet<string>;
+  } = {},
+): { active: Set<string>; finalizing: Set<string> } {
+  const now = options.now ?? Date.now();
+  const recentMessageGraceMs = Math.max(
+    0,
+    Number.isFinite(options.recentMessageGraceMs)
+      ? Number(options.recentMessageGraceMs)
+      : DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS,
+  );
+  const activeStatuses = options.activeStatuses ?? DEFAULT_ACTIVE_CHAT_POLL_STATUSES;
+  const active = new Set<string>();
+
+  for (const session of sessions) {
+    const sessionId = typeof session?.id === 'string' ? session.id : '';
+    if (!sessionId) continue;
+
+    const status = String(session?.status || '').toLowerCase();
+    const lastMessageAt = parseMessageTimestamp(session?.lastMessageAt);
+    const recentlyUpdated = lastMessageAt > 0 && (now - lastMessageAt) <= recentMessageGraceMs;
+
+    if (activeStatuses.has(status) || recentlyUpdated) {
+      active.add(sessionId);
+    }
+  }
+
+  const finalizing = new Set(
+    Array.from(previousHotSessionIds).filter((sessionId) => !active.has(sessionId)),
+  );
+
+  return { active, finalizing };
+}

package/src/status/snapshot.ts

@@ -189,6 +189,10 @@ function parseMessageTime(value: unknown): number {
     return 0;
 }
 
+function getMessageEventTime(message: { receivedAt?: unknown; timestamp?: unknown } | null | undefined): number {
+    return parseMessageTime(message?.receivedAt) || parseMessageTime(message?.timestamp) || 0;
+}
+
 function stringifyPreviewContent(content: unknown): string {
     if (typeof content === 'string') return content;
     if (Array.isArray(content)) {
@@ -233,6 +237,7 @@ function getLastDisplayMessage(session: {
             role?: string;
             content?: unknown;
             receivedAt?: number | string;
+            timestamp?: number | string;
         }> | null
     } | null
 }) {
@@ -247,7 +252,7 @@ function getLastDisplayMessage(session: {
         return {
             role,
             preview,
-            receivedAt: parseMessageTime(candidate?.receivedAt),
+            receivedAt: getMessageEventTime(candidate),
             hash: simplePreviewHash(`${role}:${preview}`),
         };
     }
@@ -256,12 +261,12 @@ function getLastDisplayMessage(session: {
 
 function getSessionMessageUpdatedAt(session: {
     activeChat?: {
-        messages?: Array<{ receivedAt?: number | string }> | null
+        messages?: Array<{ receivedAt?: number | string; timestamp?: number | string }> | null
     } | null
 }) {
     const lastMessage = session.activeChat?.messages?.at?.(-1);
     if (!lastMessage) return 0;
-    return parseMessageTime(lastMessage.receivedAt) || 0;
+    return getMessageEventTime(lastMessage);
 }
 
 export function getSessionCompletionMarker(session: {
@@ -271,6 +276,7 @@ export function getSessionCompletionMarker(session: {
             id?: string;
             index?: number;
             receivedAt?: number | string;
+            timestamp?: number | string;
             _turnKey?: string;
         }> | null
     } | null
@@ -282,13 +288,13 @@ export function getSessionCompletionMarker(session: {
     if (typeof lastMessage._turnKey === 'string' && lastMessage._turnKey) return `turn:${lastMessage._turnKey}`;
     if (typeof lastMessage.id === 'string' && lastMessage.id) return `id:${lastMessage.id}`;
     if (typeof lastMessage.index === 'number' && Number.isFinite(lastMessage.index)) return `idx:${lastMessage.index}`;
-    const timestamp = parseMessageTime(lastMessage.receivedAt);
+    const timestamp = getMessageEventTime(lastMessage);
     return timestamp > 0 ? `ts:${timestamp}` : '';
 }
 
 function getSessionLastUsedAt(session: {
     activeChat?: {
-        messages?: Array<{ receivedAt?: number | string }> | null
+        messages?: Array<{ receivedAt?: number | string; timestamp?: number | string }> | null
     } | null
     lastUpdated?: number
 }) {