@adhdev/daemon-core 0.8.25 → 0.8.27

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

@@ -41,6 +41,15 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
         return typeof (this.provider.scripts as any)?.[name] === 'function';
     }
 
+    private parseMaybeJson(raw: unknown): any {
+        if (typeof raw !== 'string') return raw;
+        try {
+            return JSON.parse(raw);
+        } catch {
+            return raw;
+        }
+    }
+
     private summarizeRaw(raw: unknown): string {
         try {
             if (typeof raw === 'string') return raw.replace(/\s+/g, ' ').trim().slice(0, 240);
@@ -111,12 +120,32 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
     }
 
     async sendMessage(evaluate: AgentEvaluateFn, text: string): Promise<void> {
-        const script = this.callScript('sendMessage', text);
+        const params = { message: text };
+        const script = this.callScript('sendMessage', params) || this.callScript('sendMessage', text);
         if (!script) throw new Error(`[${this.agentName}] sendMessage script not available`);
         const result = await evaluate(script) as string;
         if (result && typeof result === 'string' && result.startsWith('error:')) {
             throw new Error(`[${this.agentName}] sendMessage failed: ${result}`);
         }
+
+        const parsed = this.parseMaybeJson(result);
+        if (parsed === true) return;
+        if (typeof parsed === 'string') {
+            const normalized = parsed.trim().toLowerCase();
+            if (normalized === 'ok' || normalized === 'sent' || normalized === 'success' || normalized === 'true') {
+                return;
+            }
+        }
+        if (parsed && typeof parsed === 'object') {
+            if (parsed.sent === true || parsed.success === true || parsed.ok === true || parsed.submitted === true || parsed.dispatched === true) {
+                return;
+            }
+            if (typeof parsed.error === 'string' && parsed.error.trim()) {
+                throw new Error(`[${this.agentName}] sendMessage failed: ${parsed.error}`);
+            }
+        }
+
+        throw new Error(`[${this.agentName}] sendMessage was not confirmed`);
     }
 
     async resolveAction(evaluate: AgentEvaluateFn, action: string, button?: string): Promise<boolean> {

package/src/boot/daemon-lifecycle.ts

@@ -12,6 +12,7 @@ import { DaemonCdpInitializer, type CdpInitializerConfig } from '../cdp/initiali
 import { setupIdeInstance, type CdpSetupContext } from '../cdp/setup.js';
 import { DaemonCommandHandler } from '../commands/handler.js';
 import { DaemonCommandRouter, type CommandRouterDeps } from '../commands/router.js';
+import type { SessionHostControlPlane } from '../commands/router.js';
 import {
     DaemonCliManager,
     type CliTransportFactoryParams,
@@ -51,6 +52,7 @@ export interface DaemonInitConfig {
     /** Router transport-specific callbacks */
     onStatusChange?: () => void;
     onPostChatCommand?: () => void;
+    sessionHostControl?: SessionHostControlPlane | null;
     getCdpLogFn?: (ideType: string) => (msg: string) => void;
 
     /** Additional callback after CDP manager created (transport-specific extras) */
@@ -245,6 +247,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         onIdeConnected: () => poller?.start(),
         onStatusChange: config.onStatusChange,
         onPostChatCommand: config.onPostChatCommand,
+        sessionHostControl: config.sessionHostControl,
         getCdpLogFn: config.getCdpLogFn || ((ideType: string) => LOG.forComponent(`CDP:${ideType}`).asLogFn()),
     });
 

package/src/cli-adapters/pty-transport.ts

@@ -42,6 +42,9 @@ export interface PtyRuntimeMetadata {
   workspaceLabel?: string;
   writeOwner?: PtyRuntimeWriteOwner | null;
   attachedClients?: PtyRuntimeClientInfo[];
+  restoredFromStorage?: boolean;
+  recoveryState?: string | null;
+  recoveryError?: string | null;
 }
 
 export interface PtyRuntimeTransport {

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

@@ -305,6 +305,7 @@ class SessionHostRuntimeTransport implements PtyRuntimeTransport {
     }
 
     private handleEvent(event: SessionHostEvent): void {
+        if (!('sessionId' in event)) return;
         if (event.sessionId !== this.options.runtimeId) return;
         if ((event.type === 'session_started' || event.type === 'session_resumed') && typeof event.pid === 'number') {
             this.currentPid = event.pid;
@@ -383,6 +384,13 @@ class SessionHostRuntimeTransport implements PtyRuntimeTransport {
                 type: client.type,
                 readOnly: client.readOnly,
             })),
+            restoredFromStorage: record.meta?.restoredFromStorage === true,
+            recoveryState: typeof record.meta?.runtimeRecoveryState === 'string'
+                ? String(record.meta.runtimeRecoveryState)
+                : null,
+            recoveryError: typeof record.meta?.runtimeRecoveryError === 'string'
+                ? String(record.meta.runtimeRecoveryError)
+                : null,
         };
     }
 

package/src/commands/chat-commands.ts

@@ -303,7 +303,7 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
         _log(`Extension: ${provider?.type || 'unknown_extension'}`);
         // Method 1: provider sendMessage script via evaluateInSession
         try {
-            const evalResult = await h.evaluateProviderScript('sendMessage', { MESSAGE: text }, 30000);
+            const evalResult = await h.evaluateProviderScript('sendMessage', { message: text }, 30000);
             if (evalResult?.result) {
                 const parsed = parseMaybeJson(evalResult.result);
                 if (didProviderConfirmSend(parsed)) {
@@ -338,7 +338,7 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
     }
 
     _log(`Targeting IDE: ${getCurrentManagerKey(h)}`);
-    const sendScript = h.getProviderScript('sendMessage', { MESSAGE: text });
+    const sendScript = h.getProviderScript('sendMessage', { message: text });
     if (sendScript) {
         try {
             const result = await targetCdp.evaluate(sendScript, 30000);

package/src/commands/handler.ts

@@ -215,9 +215,31 @@ export class DaemonCommandHandler implements CommandHelpers {
         if (provider?.scripts) {
             const fn = (provider.scripts as any)[scriptName];
             if (typeof fn === 'function') {
-                const firstVal = params ? Object.values(params)[0] : undefined;
-                const script = firstVal ? fn(firstVal) : fn();
-                if (script) return script;
+                if (params && Object.keys(params).length > 0) {
+                    const firstVal = Object.values(params)[0];
+                    if (scriptName === 'sendMessage' && typeof firstVal === 'string') {
+                        const legacyScript = fn(firstVal);
+                        if (legacyScript) return legacyScript;
+                    }
+                    const script = fn(params);
+                    if (script) {
+                        const likelyLegacyObjectLeak =
+                            typeof script === 'string'
+                            && script.includes('[object Object]')
+                            && typeof firstVal === 'string';
+                        if (!likelyLegacyObjectLeak) return script;
+                    }
+
+                    if (firstVal !== undefined) {
+                        const legacyScript = fn(firstVal);
+                        if (legacyScript) return legacyScript;
+                    }
+
+                    if (script) return script;
+                } else {
+                    const script = fn();
+                    if (script) return script;
+                }
             }
         }
         return null;

package/src/commands/router.ts

@@ -14,6 +14,7 @@ import { registerExtensionProviders } from '../cdp/setup.js';
 import { DaemonCommandHandler } from './handler.js';
 import { DaemonCliManager } from './cli-manager.js';
 import { supportsExplicitSessionResume } from './cli-manager.js';
+import type { HostedCliRuntimeDescriptor } from './cli-manager.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { launchWithCdp, killIdeProcess, isIdeRunning } from '../launch.js';
@@ -35,6 +36,18 @@ import * as fs from 'fs';
 
 // ─── Types ───
 
+export interface SessionHostControlPlane {
+    getDiagnostics(payload?: { includeSessions?: boolean; limit?: number }): Promise<any>;
+    listSessions(): Promise<any[]>;
+    stopSession(sessionId: string): Promise<any>;
+    resumeSession(sessionId: string): Promise<any>;
+    restartSession(sessionId: string): Promise<any>;
+    sendSignal(sessionId: string, signal: string): Promise<any>;
+    forceDetachClient(sessionId: string, clientId: string): Promise<any>;
+    acquireWrite(payload: { sessionId: string; clientId: string; ownerType: 'agent' | 'user'; force?: boolean }): Promise<any>;
+    releaseWrite(payload: { sessionId: string; clientId: string }): Promise<any>;
+}
+
 export interface CommandRouterDeps {
     commandHandler: DaemonCommandHandler;
     cliManager: DaemonCliManager;
@@ -56,6 +69,8 @@ export interface CommandRouterDeps {
     getCdpLogFn?: (ideType: string) => (msg: string) => void;
     /** Package name for upgrade detection ('adhdev' or '@adhdev/daemon-standalone') */
     packageName?: string;
+    /** Session host control plane */
+    sessionHostControl?: SessionHostControlPlane | null;
 }
 
 export interface CommandRouterResult {
@@ -70,6 +85,30 @@ const CHAT_COMMANDS = [
 ];
 const READ_DEBUG_ENABLED = process.argv.includes('--dev') || process.env.ADHDEV_READ_DEBUG === '1';
 
+function toHostedCliRuntimeDescriptor(record: any): HostedCliRuntimeDescriptor | null {
+    if (!record || typeof record !== 'object') return null;
+    const runtimeId = typeof record.sessionId === 'string' ? record.sessionId : '';
+    const cliType = typeof record.providerType === 'string' ? record.providerType : '';
+    const workspace = typeof record.workspace === 'string' ? record.workspace : '';
+    if (!runtimeId || !cliType || !workspace) return null;
+    return {
+        runtimeId,
+        runtimeKey: typeof record.runtimeKey === 'string' ? record.runtimeKey : undefined,
+        displayName: typeof record.displayName === 'string' ? record.displayName : undefined,
+        workspaceLabel: typeof record.workspaceLabel === 'string' ? record.workspaceLabel : undefined,
+        lifecycle: typeof record.lifecycle === 'string' ? record.lifecycle as HostedCliRuntimeDescriptor['lifecycle'] : undefined,
+        recoveryState: typeof record.meta?.runtimeRecoveryState === 'string'
+            ? String(record.meta.runtimeRecoveryState)
+            : null,
+        cliType,
+        workspace,
+        cliArgs: Array.isArray(record.meta?.cliArgs) ? record.meta.cliArgs as string[] : [],
+        providerSessionId: typeof record.meta?.providerSessionId === 'string'
+            ? String(record.meta.providerSessionId)
+            : undefined,
+    };
+}
+
 export class DaemonCommandRouter {
     private deps: CommandRouterDeps;
 
@@ -159,6 +198,99 @@ export class DaemonCommandRouter {
                 }
             }
 
+            case 'session_host_get_diagnostics': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const diagnostics = await this.deps.sessionHostControl.getDiagnostics({
+                    includeSessions: args?.includeSessions !== false,
+                    limit: Number(args?.limit) || undefined,
+                });
+                return { success: true, diagnostics };
+            }
+
+            case 'session_host_list_sessions': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessions = await this.deps.sessionHostControl.listSessions();
+                return { success: true, sessions };
+            }
+
+            case 'session_host_stop_session': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                const record = await this.deps.sessionHostControl.stopSession(sessionId);
+                return { success: true, record };
+            }
+
+            case 'session_host_resume_session': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                const record = await this.deps.sessionHostControl.resumeSession(sessionId);
+                const hosted = toHostedCliRuntimeDescriptor(record);
+                if (hosted) {
+                    await this.deps.cliManager.restoreHostedSessions([hosted]);
+                }
+                return { success: true, record };
+            }
+
+            case 'session_host_restart_session': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                const record = await this.deps.sessionHostControl.restartSession(sessionId);
+                const hosted = toHostedCliRuntimeDescriptor(record);
+                if (hosted) {
+                    await this.deps.cliManager.restoreHostedSessions([hosted]);
+                }
+                return { success: true, record };
+            }
+
+            case 'session_host_send_signal': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                const signal = typeof args?.signal === 'string' ? args.signal : '';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                if (!signal) return { success: false, error: 'signal required' };
+                const record = await this.deps.sessionHostControl.sendSignal(sessionId, signal);
+                return { success: true, record };
+            }
+
+            case 'session_host_force_detach_client': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                const clientId = typeof args?.clientId === 'string' ? args.clientId : '';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                if (!clientId) return { success: false, error: 'clientId required' };
+                const record = await this.deps.sessionHostControl.forceDetachClient(sessionId, clientId);
+                return { success: true, record };
+            }
+
+            case 'session_host_acquire_write': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                const clientId = typeof args?.clientId === 'string' ? args.clientId : '';
+                const ownerType = args?.ownerType === 'agent' ? 'agent' : 'user';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                if (!clientId) return { success: false, error: 'clientId required' };
+                const record = await this.deps.sessionHostControl.acquireWrite({
+                    sessionId,
+                    clientId,
+                    ownerType,
+                    force: args?.force !== false,
+                });
+                return { success: true, record };
+            }
+
+            case 'session_host_release_write': {
+                if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
+                const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
+                const clientId = typeof args?.clientId === 'string' ? args.clientId : '';
+                if (!sessionId) return { success: false, error: 'sessionId required' };
+                if (!clientId) return { success: false, error: 'clientId required' };
+                const record = await this.deps.sessionHostControl.releaseWrite({ sessionId, clientId });
+                return { success: true, record };
+            }
+
             case 'list_saved_sessions': {
                 const providerType = typeof args?.providerType === 'string'
                     ? args.providerType.trim()

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

@@ -14,7 +14,7 @@ import type { ProviderModule } from './contracts.js';
 import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
-import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
+import type { PtyRuntimeMetadata, PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import { StatusMonitor } from './status-monitor.js';
 import { ChatHistoryWriter, readChatHistory } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
@@ -133,6 +133,7 @@ export class CliProviderInstance implements ProviderInstance {
 
  // PTY spawn
         await this.adapter.spawn();
+        this.maybeAppendRuntimeRecoveryMessage(this.adapter.getRuntimeMetadata());
         if (this.providerSessionId) {
             const restoredHistory = readChatHistory(this.type, 0, 200, this.providerSessionId);
             if (restoredHistory.messages.length > 0) {
@@ -246,6 +247,7 @@ export class CliProviderInstance implements ProviderInstance {
             this.promoteProviderSessionId(parsedProviderSessionId);
         }
         const runtime = this.adapter.getRuntimeMetadata();
+        this.maybeAppendRuntimeRecoveryMessage(runtime);
         const parsedMessages = Array.isArray(parsedStatus?.messages) ? parsedStatus.messages : [];
         const controlValues = extractProviderControlValues(this.provider.controls, parsedStatus);
         if (controlValues) {
@@ -603,6 +605,32 @@ export class CliProviderInstance implements ProviderInstance {
         return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
     }
 
+    private maybeAppendRuntimeRecoveryMessage(runtime: PtyRuntimeMetadata | null): void {
+        if (!runtime?.restoredFromStorage || !runtime.runtimeId) return;
+
+        const recoveryState = String(runtime.recoveryState || '').trim();
+        if (!recoveryState) return;
+
+        let content = '';
+        if (recoveryState === 'auto_resumed') {
+            content = 'Session host restored this CLI after restart and reattached it from a saved snapshot.';
+        } else if (recoveryState === 'resume_failed') {
+            const errorSuffix = runtime.recoveryError ? ` Resume failed: ${runtime.recoveryError}` : '';
+            content = `Session host found this CLI after restart, but automatic resume failed.${errorSuffix}`;
+        } else if (recoveryState === 'host_restart_interrupted') {
+            content = 'Session host found this CLI in interrupted state after restart and is attempting to resume it.';
+        } else if (recoveryState === 'orphan_snapshot') {
+            content = 'Session host restored the last snapshot for this CLI, but the original runtime was not resumed automatically.';
+        } else {
+            content = `Session host restored this CLI after restart (${recoveryState}).`;
+        }
+
+        this.appendRuntimeSystemMessage(
+            content,
+            `runtime_recovery:${runtime.runtimeId}:${recoveryState}`,
+        );
+    }
+
     private appendRuntimeSystemMessage(content: string, dedupKey: string, receivedAt = Date.now()): void {
         const normalizedContent = String(content || '').trim();
         if (!normalizedContent) return;

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

@@ -25,6 +25,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
     private currentStatus: string = 'idle';
     private agentStreams: any[] = [];
     private messages: any[] = [];
+    private prevMessageHashes = new Map<string, number>();
     private activeModal: any = null;
     private currentModel: string = '';
     private currentMode: string = '';
@@ -104,7 +105,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
         if (event === 'stream_update') {
  // Reflect data collected from agent-stream-manager
             if (data?.streams) this.agentStreams = data.streams;
-            if (data?.messages) this.messages = data.messages;
+            if (data?.messages) this.messages = this.assignReceivedAt(data.messages);
             if (data?.activeModal !== undefined) this.activeModal = data.activeModal;
             if (data?.model) this.currentModel = data.model;
             if (data?.mode) this.currentMode = data.mode;
@@ -132,6 +133,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
     dispose(): void {
         this.agentStreams = [];
         this.messages = [];
+        this.prevMessageHashes.clear();
         this.monitor.reset();
         this.appliedEffectKeys.clear();
         this.runtimeMessages = [];
@@ -315,6 +317,26 @@ export class ExtensionProviderInstance implements ProviderInstance {
         );
     }
 
+    /**
+     * Assign stable receivedAt to extension messages.
+     * Same pattern as IdeProviderInstance.readChat() prevByHash —
+     * preserves first-seen timestamp across polling cycles.
+     */
+    private assignReceivedAt(messages: any[]): any[] {
+        const now = Date.now();
+        const nextHashes = new Map<string, number>();
+
+        for (const msg of messages) {
+            const hash = `${msg.role}:${(msg.content || '').slice(0, 100)}`;
+            const prevTime = this.prevMessageHashes.get(hash);
+            msg.receivedAt = prevTime || now;
+            nextHashes.set(hash, msg.receivedAt);
+        }
+
+        this.prevMessageHashes = nextHashes;
+        return messages;
+    }
+
     private mergeConversationMessages(messages: any[]): ChatMessage[] {
         if (this.runtimeMessages.length === 0) return messages;
         return [...messages, ...this.runtimeMessages.map((entry) => entry.message)]
@@ -382,6 +404,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
         }
         this.agentStreams = [];
         this.messages = [];
+        this.prevMessageHashes.clear();
         this.activeModal = null;
         this.currentModel = '';
         this.currentMode = '';

package/src/status/normalize.ts

@@ -64,6 +64,23 @@ function trimMessageForStatus(message: unknown, stringLimit: number): unknown {
     return trimStructuredStrings(message, stringLimit);
 }
 
+/**
+ * Collapse timestamp / createdAt into receivedAt so downstream consumers
+ * only ever need to read a single canonical time field.
+ */
+function normalizeMessageTime(message: unknown): unknown {
+    if (!message || typeof message !== 'object') return message;
+    const msg = message as Record<string, unknown>;
+    if (msg.receivedAt == null) {
+        const fallback = msg.timestamp ?? msg.createdAt;
+        if (fallback != null) {
+            const ts = typeof fallback === 'string' ? Date.parse(fallback as string) : Number(fallback);
+            if (Number.isFinite(ts) && ts > 0) msg.receivedAt = ts;
+        }
+    }
+    return msg;
+}
+
 function trimMessagesForStatus(messages: unknown[] | null | undefined): unknown[] {
     if (!Array.isArray(messages) || messages.length === 0) return [];
 
@@ -72,11 +89,11 @@ function trimMessagesForStatus(messages: unknown[] | null | undefined): unknown[
     let totalBytes = 0;
 
     for (let i = recent.length - 1; i >= 0; i -= 1) {
-        let normalized = trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_STRING_LIMIT);
+        let normalized = normalizeMessageTime(trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_STRING_LIMIT));
         let size = estimateBytes(normalized);
 
         if (size > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
-            normalized = trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT);
+            normalized = normalizeMessageTime(trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT));
             size = estimateBytes(normalized);
         }
 

package/src/status/snapshot.ts

@@ -95,17 +95,12 @@ function parseMessageTime(value: unknown): number {
 
 function getSessionMessageUpdatedAt(session: {
     activeChat?: {
-        messages?: Array<{ timestamp?: number | string; receivedAt?: number | string; createdAt?: number | string }> | null
+        messages?: Array<{ receivedAt?: number | string }> | null
     } | null
 }) {
     const lastMessage = session.activeChat?.messages?.at?.(-1);
     if (!lastMessage) return 0;
-    return (
-        parseMessageTime(lastMessage.timestamp)
-        || parseMessageTime(lastMessage.receivedAt)
-        || parseMessageTime(lastMessage.createdAt)
-        || 0
-    );
+    return parseMessageTime(lastMessage.receivedAt) || 0;
 }
 
 export function getSessionCompletionMarker(session: {
@@ -114,9 +109,7 @@ export function getSessionCompletionMarker(session: {
             role?: string;
             id?: string;
             index?: number;
-            timestamp?: number | string;
             receivedAt?: number | string;
-            createdAt?: number | string;
             _turnKey?: string;
         }> | null
     } | null
@@ -124,17 +117,17 @@ export function getSessionCompletionMarker(session: {
     const lastMessage = session.activeChat?.messages?.at?.(-1) as any;
     if (!lastMessage) return '';
     const role = typeof lastMessage.role === 'string' ? lastMessage.role : '';
-    if (role === 'user' || role === 'human') return '';
+    if (role === 'user' || role === 'human' || role === 'system') return '';
     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.timestamp) || parseMessageTime(lastMessage.receivedAt) || parseMessageTime(lastMessage.createdAt);
+    const timestamp = parseMessageTime(lastMessage.receivedAt);
     return timestamp > 0 ? `ts:${timestamp}` : '';
 }
 
 function getSessionLastUsedAt(session: {
     activeChat?: {
-        messages?: Array<{ timestamp?: number | string; receivedAt?: number | string; createdAt?: number | string }> | null
+        messages?: Array<{ receivedAt?: number | string }> | null
     } | null
     lastUpdated?: number
 }) {
@@ -171,7 +164,7 @@ function getUnreadState(
     }
     const unread = completionMarker
         ? completionMarker !== seenCompletionMarker
-        : hasContentChange && lastUsedAt > lastSeenAt && lastRole !== 'user' && lastRole !== 'human';
+        : hasContentChange && lastUsedAt > lastSeenAt && lastRole !== 'user' && lastRole !== 'human' && lastRole !== 'system';
     return { unread, inboxBucket: unread ? 'task_complete' : 'idle' };
 }