@adhdev/daemon-core 0.8.36 → 0.8.38

package/dist/shared-types.d.ts

@@ -244,6 +244,10 @@ export interface SessionEntry {
     providerControls?: ProviderControlSchema[];
     errorMessage?: string;
     errorReason?: _ProviderErrorReason;
+    lastMessagePreview?: string;
+    lastMessageRole?: string;
+    lastMessageAt?: number;
+    lastMessageHash?: string;
     lastUpdated?: number;
     unread?: boolean;
     lastSeenAt?: number;

package/dist/status/builders.d.ts

@@ -15,15 +15,12 @@ export interface SessionEntryBuildOptions {
     profile?: SessionEntryProfile;
 }
 /**
- * Find a CDP manager by key, with prefix matching for multi-window support.
+ * Find a CDP manager by key. Supports single-window (`cursor`) and full multi-window keys (`cursor_<targetId>`).
  *
  * Lookup order:
- *   1. Exact match: cdpManagers.get(key)
- *   2. Prefix match: key starts with `${ideType}_` (multi-window: "cursor_remote_vs")
- *   3. null
- *
- * This replaces raw `cdpManagers.get(ideType)` calls that broke when
- * multi-window keys like "cursor_remote_vs" were used.
+ *   1. Exact match when connected
+ *   2. If key has no multi-window suffix: at most **one** connected manager whose key starts with `key_`
+ *   3. If two or more windows share that prefix → **null** (ambiguous — pass full managerKey from `GET /api/cdp/targets`)
  */
 export declare function findCdpManager(cdpManagers: Map<string, DaemonCdpManager>, key: string): DaemonCdpManager | null;
 /**

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

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.36",
+  "version": "0.8.38",
   "description": "ADHDev local session host core — 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.36",
+  "version": "0.8.38",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/daemon/dev-auto-implement.ts

@@ -71,6 +71,16 @@ export function getDefaultAutoImplReference(ctx: DevServerContext, category: str
   if (category === 'cli') {
     return type === 'codex-cli' ? 'claude-cli' : 'codex-cli';
   }
+  if (category === 'extension') {
+    const preferred = ['claude-code-vscode', 'codex', 'cline', 'roo-code'];
+    for (const ref of preferred) {
+      if (ref === type) continue;
+      if (ctx.providerLoader.resolve(ref) || ctx.providerLoader.getMeta(ref)) return ref;
+    }
+    const all = ctx.providerLoader.getAll();
+    const fb = all.find((p: any) => p.category === 'extension' && p.type !== type);
+    if (fb?.type) return fb.type;
+  }
   return 'antigravity';
 }
 
@@ -725,6 +735,9 @@ export function buildAutoImplPrompt(ctx: DevServerContext,
 
   const lines: string[] = [];
 
+  /** CDP connection key: extension scripts use host IDE (default Cursor), not the extension id. */
+  const cdpIdeType = provider.category === 'extension' ? 'cursor' : type;
+
   // ── System instructions ──
   lines.push('You are implementing browser automation scripts for an IDE provider.');
   lines.push('Be concise. Do NOT explain your reasoning. Just edit files directly.');
@@ -734,6 +747,19 @@ export function buildAutoImplPrompt(ctx: DevServerContext,
   lines.push(`# Target: ${provider.name || type} (${type})`);
   lines.push(`Provider directory: \`${providerDir}\``);
   lines.push('');
+  if (provider.category === 'extension') {
+    lines.push('## CDP host (extension providers)');
+    lines.push(
+      `Extension **${type}** runs inside a host IDE. For \`/api/scripts/run\` and \`/api/cdp/evaluate\`, keep \`"type": "${type}"\` (which provider scripts run) but set \`"ideType"\` to the DevServer CDP **managerKey** for that window.`,
+    );
+    lines.push(
+      `Examples use \`"ideType": "${cdpIdeType}"\` (Cursor). If **multiple** IDE windows are connected, run \`GET /api/cdp/targets\` and use the correct \`managerKey\` / \`pageTitle\` — short \`cursor\` or \`vscode\` only works when it uniquely identifies one window.`,
+    );
+    lines.push(
+      'For VS Code hosts, use `vscode` or full `vscode_<targetId>` managerKey in every curl below.',
+    );
+    lines.push('');
+  }
 
   // ── funcToFile mapping (needed early for file classification) ──
   const funcToFile: Record<string, string> = {
@@ -932,14 +958,14 @@ export function buildAutoImplPrompt(ctx: DevServerContext,
   lines.push('```bash');
   lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/cdp/evaluate \\`);
   lines.push(`  -H "Content-Type: application/json" \\`);
-  lines.push(`  -d '{"expression": "document.body.innerHTML.substring(0, 1000)", "ideType": "${type}"}'`);
+  lines.push(`  -d '{"expression": "document.body.innerHTML.substring(0, 1000)", "ideType": "${cdpIdeType}"}'`);
   lines.push('```');
   lines.push('');
   lines.push('### 2. Test your generated function');
   lines.push('Once you save the file, test it by running:');
   lines.push('```bash');
   lines.push(`curl -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/providers/reload`);
-  lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "readChat", "type": "${type}", "ideType": "${type}"}'`);
+  lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "readChat", "type": "${type}", "ideType": "${cdpIdeType}"}'`);
   lines.push('```');
   lines.push('');
   lines.push('### Task Workflow');
@@ -949,10 +975,12 @@ export function buildAutoImplPrompt(ctx: DevServerContext,
   lines.push('4. Reload providers and TEST your script via the API.');
   lines.push('');
   lines.push('### 🔥 Advanced UI Parsing (CRUCIAL for `readChat`)');
-  lines.push('Your `readChat` must flawlessly parse complex UI elements (tables, code blocks, tool calls, and AI thoughts). The quality must match the `antigravity` reference.');
+  lines.push(
+    `Your \`readChat\` must flawlessly parse complex UI elements (tables, code blocks, tool calls, and AI thoughts). Match the depth of the **${referenceType || 'reference'}** scripts above (patterns and structure, not necessarily the same DOM).`,
+  );
   lines.push('To achieve this, you MUST generate a live test scenario:');
   lines.push(`1. Early in your process, send a rich prompt to the IDE using the API:`);
-  lines.push(`   \`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "sendMessage", "type": "${type}", "ideType": "${type}", "args": {"message": "Write a python script, draw a markdown table, use a tool, and show your reasoning/thought process"}}'\``);
+  lines.push(`   \`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "sendMessage", "type": "${type}", "ideType": "${cdpIdeType}", "args": {"message": "Write a python script, draw a markdown table, use a tool, and show your reasoning/thought process"}}'\``);
   lines.push('2. Wait a few seconds for the IDE AI to generate these elements in the UI.');
   lines.push('3. Use CDP evaluate to deeply inspect the DOM structure of the newly generated tables, code blocks, thought blocks, and tool calls.');
   lines.push('4. Ensure `readChat` extracts `content` with precise markdown formatting (especially for tables/code) and assigns correct `kind` tags (`thought`, `tool`, `terminal`).');
@@ -965,27 +993,27 @@ export function buildAutoImplPrompt(ctx: DevServerContext,
   lines.push('### Step 1: Baseline — confirm idle');
   lines.push('```bash');
   lines.push(`curl -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/providers/reload`);
-  lines.push(`RESULT=$(curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "readChat", "type": "${type}", "ideType": "${type}"}')`);
+  lines.push(`RESULT=$(curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "readChat", "type": "${type}", "ideType": "${cdpIdeType}"}')`);
   lines.push(`echo "$RESULT" | python3 -c "import sys,json; d=json.load(sys.stdin); r=d.get('result',d); r=json.loads(r) if isinstance(r,str) else r; assert r.get('status')=='idle', f'Expected idle, got {r.get(chr(34)+chr(115)+chr(116)+chr(97)+chr(116)+chr(117)+chr(115)+chr(34))}'; print('Step 1 PASS: status=idle')"`);
   lines.push('```');
   lines.push('');
   lines.push('### Step 2: Send a LONG message that triggers extended generation (10+ seconds)');
   lines.push('```bash');
-  lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "sendMessage", "type": "${type}", "ideType": "${type}", "args": {"message": "Write an extremely detailed 5000-word essay about the history of artificial intelligence from Alan Turing to 2025. Be very thorough and verbose."}}'`);
+  lines.push(`curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "sendMessage", "type": "${type}", "ideType": "${cdpIdeType}", "args": {"message": "Write an extremely detailed 5000-word essay about the history of artificial intelligence from Alan Turing to 2025. Be very thorough and verbose."}}'`);
   lines.push('sleep 3');
   lines.push('```');
   lines.push('');
   lines.push('### Step 3: Check generating OR completed');
   lines.push('The AI may still be generating OR may have finished already. Either generating or idle is acceptable:');
   lines.push('```bash');
-  lines.push(`RESULT=$(curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "readChat", "type": "${type}", "ideType": "${type}"}')`);
+  lines.push(`RESULT=$(curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "readChat", "type": "${type}", "ideType": "${cdpIdeType}"}')`);
   lines.push(`echo "$RESULT" | python3 -c "import sys,json; d=json.load(sys.stdin); r=d.get('result',d); r=json.loads(r) if isinstance(r,str) else r; s=r.get('status'); assert s in ('generating','idle','waiting_approval'), f'Unexpected: {s}'; print(f'Step 3 PASS: status={s}')"`);
   lines.push('```');
   lines.push('');
   lines.push('### Step 4: Wait for completion and verify new message');
   lines.push('```bash');
   lines.push('sleep 10');
-  lines.push(`RESULT=$(curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "readChat", "type": "${type}", "ideType": "${type}"}')`);
+  lines.push(`RESULT=$(curl -sS -X POST http://127.0.0.1:${DEV_SERVER_PORT}/api/scripts/run -H "Content-Type: application/json" -d '{"script": "readChat", "type": "${type}", "ideType": "${cdpIdeType}"}')`);
   lines.push(`echo "$RESULT" | python3 -c "import sys,json; d=json.load(sys.stdin); r=d.get('result',d); r=json.loads(r) if isinstance(r,str) else r; s=r.get('status'); msgs=r.get('messages',[]); assert s=='idle', f'Expected idle, got {s}'; assert len(msgs)>0, 'No messages'; print(f'Step 4 PASS: status={s}, messages={len(msgs)}')"`);
   lines.push('```');
   lines.push('');

package/src/daemon/dev-cdp-handlers.ts

@@ -295,9 +295,28 @@ export async function handleScriptHints(ctx: DevServerContext, type: string, _re
 }
 
 export async function handleCdpTargets(ctx: DevServerContext, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
-  const targets: { ide: string; connected: boolean; port: number }[] = [];
-  for (const [ide, cdp] of ctx.cdpManagers.entries()) {
-    targets.push({ ide, connected: cdp.isConnected, port: cdp.getPort() });
+  const targets: Array<{
+    managerKey: string;
+    /** @deprecated same as managerKey — kept for older clients */
+    ide: string;
+    ideBase: string;
+    pageTitle: string;
+    targetId: string | null;
+    connected: boolean;
+    port: number;
+  }> = [];
+  for (const [managerKey, cdp] of ctx.cdpManagers.entries()) {
+    const underscore = managerKey.indexOf('_');
+    const ideBase = underscore === -1 ? managerKey : managerKey.slice(0, underscore);
+    targets.push({
+      managerKey,
+      ide: managerKey,
+      ideBase,
+      pageTitle: cdp.pageTitle,
+      targetId: cdp.targetId,
+      connected: cdp.isConnected,
+      port: cdp.getPort(),
+    });
   }
   ctx.json(res, 200, { targets });
 }

package/src/daemon/dev-server.ts

@@ -28,6 +28,7 @@ import type { DaemonCliManager } from '../commands/cli-manager.js';
 import { generateTemplate as genScaffoldTemplate, generateFiles as genScaffoldFiles } from './scaffold-template.js';
 import { VersionArchive, detectAllVersions } from '../providers/version-archive.js';
 import { LOG } from '../logging/logger.js';
+import { findCdpManager } from '../status/builders.js';
 import { handleCdpEvaluate, handleCdpClick, handleCdpDomQuery, handleScreenshot, handleScriptsRun, handleTypeAndSend, handleTypeAndSendAt, handleScriptHints, handleCdpTargets, handleDomInspect, handleDomChildren, handleDomAnalyze, handleFindCommon, handleFindByText, handleDomContext } from './dev-cdp-handlers.js';
 import { handleCliStatus, handleCliLaunch, handleCliSend, handleCliStop, handleCliDebug, handleCliTrace, handleCliExercise, handleCliFixtureCapture, handleCliFixtureList, handleCliFixtureReplay, handleCliResolve, handleCliRaw, handleCliSSE } from './dev-cli-debug.js';
 import { handleAutoImplement, handleAutoImplCancel, handleAutoImplSSE } from './dev-auto-implement.js';
@@ -1590,24 +1591,29 @@ export class DevServer implements DevServerContext {
     }
   }
 
-  /** Get CDP manager — matching IDE when ideType specified, first connected one otherwise.
-   *  DevServer is a debugging tool so first-connected fallback is acceptable,
-   *  but callers should pass ideType when possible. */
+  /**
+   * Resolve a CDP manager for DevServer APIs.
+   * - Pass full **managerKey** from `GET /api/cdp/targets` when multiple Cursor/VS Code windows are open
+   *   (e.g. `cursor_0006DE34…`); short `cursor` only works when it maps to exactly one connected manager.
+   * - With `ideType` omitted: only succeeds when exactly one connected manager exists.
+   */
   public getCdp(ideType?: string): DaemonCdpManager | null {
     if (ideType) {
-      const cdp = this.cdpManagers.get(ideType);
-      if (cdp?.isConnected) return cdp;
-      // Prefix match for multi-window keys
-      for (const [k, m] of this.cdpManagers.entries()) {
-        if (k.startsWith(ideType + '_') && m.isConnected) return m;
-      }
-      LOG.warn('DevServer', `getCdp: no manager found for ideType '${ideType}', available: [${[...this.cdpManagers.keys()].join(', ')}]`);
+      const cdp = findCdpManager(this.cdpManagers, ideType);
+      if (cdp) return cdp;
+      LOG.warn(
+        'DevServer',
+        `getCdp: no unique match for '${ideType}', available: [${[...this.cdpManagers.keys()].join(', ')}] — use managerKey from GET /api/cdp/targets`,
+      );
       return null;
     }
-    // No ideType — return first connected (dev convenience)
-    for (const cdp of this.cdpManagers.values()) {
-      if (cdp.isConnected) return cdp;
-    }
+    const connected = [...this.cdpManagers.entries()].filter(([, m]) => m.isConnected);
+    if (connected.length === 1) return connected[0][1];
+    if (connected.length === 0) return null;
+    LOG.warn(
+      'DevServer',
+      `getCdp: ideType omitted but ${connected.length} CDP windows — pass managerKey from GET /api/cdp/targets`,
+    );
     return null;
   }
 

package/src/installer.ts

@@ -74,6 +74,19 @@ export const EXTENSION_CATALOG: ExtensionInfo[] = [
         requiresApiKey: true,
         apiKeyName: 'Anthropic/OpenAI API key',
     },
+    {
+        id: 'claude-code-vscode',
+        name: 'Claude Code',
+        displayName: 'Claude Code (Anthropic)',
+        marketplaceId: 'anthropic.claude-code',
+        description: 'Anthropic Claude Code agent in VS Code–compatible editors',
+        category: 'ai-agent',
+        icon: '🟠',
+        recommended: true,
+        requiresApiKey: true,
+        apiKeyName: 'Anthropic account',
+        website: 'https://www.anthropic.com/claude-code',
+    },
     {
         id: 'continue',
         name: 'Continue',

package/src/shared-types.ts

@@ -308,6 +308,10 @@ export interface SessionEntry {
     providerControls?: ProviderControlSchema[];
     errorMessage?: string;
     errorReason?: _ProviderErrorReason;
+    lastMessagePreview?: string;
+    lastMessageRole?: string;
+    lastMessageAt?: number;
+    lastMessageHash?: string;
     lastUpdated?: number;
     unread?: boolean;
     lastSeenAt?: number;

package/src/status/builders.ts

@@ -50,30 +50,26 @@ function shouldIncludeRuntimeMetadata(profile: SessionEntryProfile): boolean {
 // ─── CDP Manager lookup helpers ──────────────────────
 
 /**
- * Find a CDP manager by key, with prefix matching for multi-window support.
+ * Find a CDP manager by key. Supports single-window (`cursor`) and full multi-window keys (`cursor_<targetId>`).
  *
  * Lookup order:
- *   1. Exact match: cdpManagers.get(key)
- *   2. Prefix match: key starts with `${ideType}_` (multi-window: "cursor_remote_vs")
- *   3. null
- *
- * This replaces raw `cdpManagers.get(ideType)` calls that broke when
- * multi-window keys like "cursor_remote_vs" were used.
+ *   1. Exact match when connected
+ *   2. If key has no multi-window suffix: at most **one** connected manager whose key starts with `key_`
+ *   3. If two or more windows share that prefix → **null** (ambiguous — pass full managerKey from `GET /api/cdp/targets`)
  */
 export function findCdpManager(
     cdpManagers: Map<string, DaemonCdpManager>,
     key: string,
 ): DaemonCdpManager | null {
-    // 1. Exact match (single-window: "cursor", or full managerKey: "cursor_remote_vs")
+    // 1. Exact match (single-window: "cursor", or full managerKey: "cursor_<targetId>")
     const exact = cdpManagers.get(key);
-    if (exact) return exact;
+    if (exact) return exact.isConnected ? exact : null;
 
-    // 2. Prefix match (key = ideType like "cursor", managerKey = "cursor_remote_vs")
+    // 2. Prefix match only when it resolves to exactly one connected manager
     const prefix = key + '_';
-    for (const [k, m] of cdpManagers.entries()) {
-        if (k.startsWith(prefix) && m.isConnected) return m;
-    }
-
+    const matches = [...cdpManagers.entries()].filter(([k, m]) => m.isConnected && k.startsWith(prefix));
+    if (matches.length === 1) return matches[0][1];
+    // 0 matches → null; 2+ → ambiguous — caller must pass full managerKey (e.g. from /api/cdp/targets)
     return null;
 }
 
@@ -99,8 +95,13 @@ export function isCdpConnected(
     cdpManagers: Map<string, DaemonCdpManager>,
     key: string,
 ): boolean {
-    const m = findCdpManager(cdpManagers, key);
-    return m?.isConnected ?? false;
+    const exact = cdpManagers.get(key);
+    if (exact?.isConnected) return true;
+    const prefix = key + '_';
+    for (const [k, m] of cdpManagers.entries()) {
+        if (m.isConnected && k.startsWith(prefix)) return true;
+    }
+    return false;
 }
 
 /**

package/src/status/snapshot.ts

@@ -146,6 +146,71 @@ function parseMessageTime(value: unknown): number {
     return 0;
 }
 
+function stringifyPreviewContent(content: unknown): string {
+    if (typeof content === 'string') return content;
+    if (Array.isArray(content)) {
+        return content.map((block) => {
+            if (typeof block === 'string') return block;
+            if (block && typeof block === 'object' && 'text' in block) {
+                return String((block as { text?: unknown }).text || '');
+            }
+            return '';
+        }).join(' ');
+    }
+    if (content && typeof content === 'object' && 'text' in content) {
+        return String((content as { text?: unknown }).text || '');
+    }
+    return String(content || '');
+}
+
+function normalizePreviewText(content: unknown): string {
+    return stringifyPreviewContent(content)
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+
+function clampPreviewText(value: string, maxChars = 120): string {
+    if (value.length <= maxChars) return value;
+    if (maxChars <= 1) return value.slice(0, maxChars);
+    return `${value.slice(0, maxChars - 1)}…`;
+}
+
+function simplePreviewHash(value: string): string {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < value.length; i += 1) {
+        h ^= value.charCodeAt(i);
+        h = (h * 0x01000193) >>> 0;
+    }
+    return h.toString(16);
+}
+
+function getLastDisplayMessage(session: {
+    activeChat?: {
+        messages?: Array<{
+            role?: string;
+            content?: unknown;
+            receivedAt?: number | string;
+        }> | null
+    } | null
+}) {
+    const messages = session.activeChat?.messages;
+    if (!Array.isArray(messages) || messages.length === 0) return null;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const candidate = messages[i];
+        const role = typeof candidate?.role === 'string' ? candidate.role : '';
+        if (role === 'system') continue;
+        const preview = clampPreviewText(normalizePreviewText(candidate?.content));
+        if (!preview) continue;
+        return {
+            role,
+            preview,
+            receivedAt: parseMessageTime(candidate?.receivedAt),
+            hash: simplePreviewHash(`${role}:${preview}`),
+        };
+    }
+    return null;
+}
+
 function getSessionMessageUpdatedAt(session: {
     activeChat?: {
         messages?: Array<{ receivedAt?: number | string }> | null
@@ -196,8 +261,7 @@ function getSessionKind(session: SessionEntry): RecentLaunchEntry['kind'] {
 }
 
 function getLastMessageRole(session: { activeChat?: { messages?: Array<{ role?: string }> | null } | null }): string {
-    const role = session.activeChat?.messages?.at?.(-1)?.role;
-    return typeof role === 'string' ? role : '';
+    return getLastDisplayMessage(session)?.role || '';
 }
 
 function getUnreadState(
@@ -286,6 +350,13 @@ export function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnaps
                 `snapshot session id=${session.id} provider=${session.providerType} status=${String(session.status || '')} bucket=${inboxBucket} unread=${String(unread)} lastSeenAt=${lastSeenAt} completionMarker=${completionMarker || '-'} seenMarker=${seenCompletionMarker || '-'} lastUpdated=${String(session.lastUpdated || 0)} lastUsedAt=${lastUsedAt} lastRole=${getLastMessageRole(sourceSession)} msgUpdatedAt=${getSessionMessageUpdatedAt(sourceSession)}`,
             );
         }
+        const lastDisplayMessage = getLastDisplayMessage(sourceSession);
+        if (lastDisplayMessage) {
+            session.lastMessagePreview = lastDisplayMessage.preview;
+            session.lastMessageRole = lastDisplayMessage.role;
+            if (lastDisplayMessage.receivedAt > 0) session.lastMessageAt = lastDisplayMessage.receivedAt;
+            session.lastMessageHash = lastDisplayMessage.hash;
+        }
     }
     const includeMachineMetadata = profile !== 'live';
     const terminalBackend = includeMachineMetadata