@adhdev/daemon-core 0.9.82-rc.336 → 0.9.82-rc.337

package/dist/mesh/mesh-events-utils.d.ts

@@ -39,6 +39,25 @@ export declare function readRefineJobId(event: {
     metadataEvent?: Record<string, unknown>;
 } | Record<string, unknown>): string;
 export declare function readWorkerResultMetadata(event: Record<string, unknown>): Record<string, unknown> | undefined;
+/**
+ * A coordinator that surfaces a REMOTE worker's mesh session has no local instance for
+ * it, so the status snapshot's getLastDisplayMessage has nothing to read and the only
+ * preview the coordinator-mirrored copy could ever carry comes from the worker's
+ * completion event. The worker's latest assistant reply rides on that event as
+ * `finalSummary` (and as `workerResult.summary` / `result.summary` on some paths).
+ *
+ * This resolves that assistant text into a preview the coordinator can stamp onto its
+ * mirror entry so the mobile inbox shows the worker's latest assistant response instead
+ * of being stuck on the first dispatched user task (which is the only message the
+ * coordinator-side transcript ever holds). Returns undefined when the event carries no
+ * assistant text — non-completion lifecycle events (generating_started / ready without a
+ * summary) must NOT clobber a previously surfaced preview.
+ */
+export declare function resolveMeshSurfacedSessionPreview(metadataEvent: Record<string, unknown>): {
+    preview: string;
+    role: 'assistant';
+    receivedAt: number;
+} | undefined;
 export declare function buildMeshSystemMessage(args: {
     event: string;
     nodeLabel: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.336",
+  "version": "0.9.82-rc.337",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.336",
+    "@adhdev/mesh-shared": "0.9.82-rc.337",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/mesh/mesh-events-coordinator.ts

@@ -30,6 +30,7 @@ import {
     resolveEventSessionId,
     readRefineJobId,
     readWorkerResultMetadata,
+    resolveMeshSurfacedSessionPreview,
 } from './mesh-events-utils.js';
 
 // The set of coordinator-daemon ids this daemon answers to when draining the
@@ -1394,6 +1395,15 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     // across standalone and cloud.
     if (components.onMeshCoordinatorEventForwarded) {
         try {
+            // T: the coordinator surfaces a remote worker's session but holds no local
+            // instance for it, so the status snapshot can't derive a preview and the
+            // mirror would stay stuck on the first dispatched user task. Resolve the
+            // worker's latest assistant reply (carried on the completion event's
+            // finalSummary / workerResult) into a preview the mirror can stamp, so the
+            // mobile inbox reflects the assistant response. Only completion-style events
+            // carry assistant text; for everything else this is undefined and the prior
+            // surfaced preview is preserved downstream (no clobber).
+            const surfacedPreview = resolveMeshSurfacedSessionPreview(args.metadataEvent);
             components.onMeshCoordinatorEventForwarded({
                 event: args.event,
                 meshId: args.meshId,
@@ -1405,6 +1415,11 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                 workspace: readNonEmptyString(args.metadataEvent.workspace)
                     || readNonEmptyString(args.metadataEvent.workspaceName)
                     || undefined,
+                ...(surfacedPreview ? {
+                    meshSessionLastMessagePreview: surfacedPreview.preview,
+                    meshSessionLastMessageRole: surfacedPreview.role,
+                    meshSessionLastMessageAt: surfacedPreview.receivedAt || undefined,
+                } : {}),
             });
         } catch { /* dashboard metadata sync is best-effort */ }
     }

package/src/mesh/mesh-events-utils.ts

@@ -107,6 +107,52 @@ export function readWorkerResultMetadata(event: Record<string, unknown>): Record
     return readRecord(event.workerResult) || readRecord(event.meshWorkerResult) || readRecord(event.structuredResult);
 }
 
+const MESH_SURFACED_PREVIEW_MAX_CHARS = 512;
+
+/**
+ * A coordinator that surfaces a REMOTE worker's mesh session has no local instance for
+ * it, so the status snapshot's getLastDisplayMessage has nothing to read and the only
+ * preview the coordinator-mirrored copy could ever carry comes from the worker's
+ * completion event. The worker's latest assistant reply rides on that event as
+ * `finalSummary` (and as `workerResult.summary` / `result.summary` on some paths).
+ *
+ * This resolves that assistant text into a preview the coordinator can stamp onto its
+ * mirror entry so the mobile inbox shows the worker's latest assistant response instead
+ * of being stuck on the first dispatched user task (which is the only message the
+ * coordinator-side transcript ever holds). Returns undefined when the event carries no
+ * assistant text — non-completion lifecycle events (generating_started / ready without a
+ * summary) must NOT clobber a previously surfaced preview.
+ */
+export function resolveMeshSurfacedSessionPreview(
+    metadataEvent: Record<string, unknown>,
+): { preview: string; role: 'assistant'; receivedAt: number } | undefined {
+    const workerResult = readWorkerResultMetadata(metadataEvent);
+    const resultRecord = readRecord(metadataEvent.result);
+    const summaryText = readNonEmptyString(metadataEvent.finalSummary)
+        || readNonEmptyString(workerResult?.summary)
+        || readNonEmptyString(workerResult?.finalSummary)
+        || readNonEmptyString(resultRecord?.summary)
+        || readNonEmptyString(resultRecord?.finalSummary);
+    if (!summaryText) return undefined;
+    const truncationSuffix = '...[truncated]';
+    const preview = summaryText.length > MESH_SURFACED_PREVIEW_MAX_CHARS
+        ? `${summaryText.slice(0, MESH_SURFACED_PREVIEW_MAX_CHARS - truncationSuffix.length)}${truncationSuffix}`
+        : summaryText;
+    const timestamp = readEventTimestampValue(metadataEvent.timestamp);
+    return { preview, role: 'assistant', receivedAt: timestamp };
+}
+
+function readEventTimestampValue(value: unknown): number {
+    if (typeof value === 'number' && Number.isFinite(value)) return value;
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) return parsed;
+        const dateMs = Date.parse(value);
+        if (Number.isFinite(dateMs)) return dateMs;
+    }
+    return 0;
+}
+
 function formatCompletionMetadata(event: Record<string, unknown>): string {
     const completionDiagnostic = event.completionDiagnostic && typeof event.completionDiagnostic === 'object'
         ? event.completionDiagnostic as Record<string, unknown>