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

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/dist/status/snapshot.d.ts

@@ -65,6 +65,31 @@ export interface RecentReadDebugSnapshot {
 }
 export declare function shouldEmitRecentReadDebugLog(cache: Map<string, string>, snapshot: RecentReadDebugSnapshot): boolean;
 export declare function buildMachineInfo(profile?: 'full' | 'live' | 'metadata'): MachineInfo;
+/**
+ * Resolve the last user-visible (non-system) message for a session as a preview.
+ *
+ * Exported so the cloud coordinator can derive a preview for a LOCAL mesh-owned
+ * worktree session directly from the real provider instance it hosts. A REMOTE
+ * worker session has no local instance (its preview rides the completion event's
+ * finalSummary — see resolveMeshSurfacedSessionPreview), but a LOCAL coordinator
+ * IS the worker, so its hosted instance's transcript holds the assistant reply and
+ * this is the source of truth for that case.
+ */
+export declare function getLastDisplayMessage(session: {
+    activeChat?: {
+        messages?: Array<{
+            role?: string;
+            content?: unknown;
+            receivedAt?: number | string;
+            timestamp?: number | string;
+        }> | null;
+    } | null;
+}): {
+    role: string;
+    preview: string;
+    receivedAt: number;
+    hash: string;
+} | null;
 export { getSessionCurrentNotificationId, applySessionNotificationOverlay } from '../config/recent-activity.js';
 export declare function getSessionCompletionMarker(session: {
     activeChat?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.336",
+  "version": "0.9.82-rc.338",
   "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.338",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/index.ts

@@ -320,7 +320,7 @@ export type {
 // ── Status ──
 export { DaemonStatusReporter } from './status/reporter.js';
 export { buildSessionEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
-export { buildStatusSnapshot, buildMachineInfo } from './status/snapshot.js';
+export { buildStatusSnapshot, buildMachineInfo, getLastDisplayMessage } from './status/snapshot.js';
 export { getDaemonBuildInfo } from './build-info.js';
 export type { DaemonBuildInfo } from './build-info.js';
 export { normalizeManagedStatus, isManagedStatusWorking, isManagedStatusWaiting, normalizeActiveChatData } from './status/normalize.js';

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>

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

@@ -1425,8 +1425,15 @@ export class CliProviderInstance implements ProviderInstance {
                 chatTitle: pending.chatTitle,
                 duration: pending.duration,
                 timestamp: pending.timestamp,
+                // When finalization is forced past the timeout on a `parsed_status:` block
+                // (the parser never confirmed a final assistant turn) we previously rode an
+                // empty `finalSummary` unconditionally. That empty value propagates to the
+                // mesh coordinator's mirror preview (meshSessionLastMessagePreview), leaving a
+                // delegated session's inbox preview blank — or, for a LOCAL worktree session,
+                // stuck on the dispatched user task. If the parser DID surface assistant text,
+                // prefer it; only fall back to '' when no assistant summary can be derived.
                 finalSummary: blockReason.startsWith('parsed_status:')
-                    ? ''
+                    ? (this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages) ?? '')
                     : this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages),
                 completionDiagnostic,
             });

package/src/status/snapshot.ts

@@ -283,7 +283,17 @@ function simplePreviewHash(value: string): string {
     return h.toString(16);
 }
 
-function getLastDisplayMessage(session: {
+/**
+ * Resolve the last user-visible (non-system) message for a session as a preview.
+ *
+ * Exported so the cloud coordinator can derive a preview for a LOCAL mesh-owned
+ * worktree session directly from the real provider instance it hosts. A REMOTE
+ * worker session has no local instance (its preview rides the completion event's
+ * finalSummary — see resolveMeshSurfacedSessionPreview), but a LOCAL coordinator
+ * IS the worker, so its hosted instance's transcript holds the assistant reply and
+ * this is the source of truth for that case.
+ */
+export function getLastDisplayMessage(session: {
     activeChat?: {
         messages?: Array<{
             role?: string;