@adhdev/daemon-core 0.9.82-rc.335 → 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.335",
+  "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.335",
+    "@adhdev/mesh-shared": "0.9.82-rc.337",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/cli-adapters/provider-cli-adapter.ts

@@ -120,17 +120,29 @@ export function appendBoundedText(current: string, chunk: string, maxChars: numb
 
 // Force-send (mesh coordinator dispatch / reconcile redelivery) writes raw
 // keystrokes straight into the PTY, bypassing the normal echo-wait submit
-// pipeline. Historically it wrote `text + sendKey` in a single PTY write with
-// zero settle time. On TUI input boxes that re-render the pasted text, the
-// trailing submit key could arrive before the input line had stabilized and be
-// swallowed by the input handler — leaving the prompt typed but never submitted
-// ("text injected, Enter not pressed"). We now split inject from submit and let
-// the input settle first. FORCE_SUBMIT_SETTLE_MS is the minimum gap after the
-// text write before the submit key is sent; FORCE_SUBMIT_MAX_WAIT_MS caps the
-// echo-gated wait so the submit always fires even if the echo never appears.
+// pipeline.
+//
+// History of this path's failure modes:
+//   1. Originally it wrote `text + sendKey` in a single PTY write with zero
+//      settle time. Injected into an idle TUI input box that was still entering
+//      its input-accepting state, the trailing submit key could be swallowed —
+//      prompt typed but never submitted ("text injected, Enter not pressed").
+//   2. The first fix split inject from submit: write(text) → echo-gated settle →
+//      write(sendKey) as a *separate* PTY write. That broke win32: ConPTY/TUI
+//      does not recognize a lone '\r' that arrives in its own PTY chunk
+//      150ms+ after the text as a submit key, and the win32 echo gate never
+//      matched (ConPTY echo/parsing differences), so the cap was burned and the
+//      same detached lone CR was emitted — adding latency while the Enter still
+//      got swallowed.
+//
+// Current behavior: keep a fixed settle gap so the input handler is in its
+// input-accepting state, then write `content + sendKey` as a SINGLE atomic PTY
+// write — the same verified mechanism the normal `immediate` submit strategy
+// uses (submitImmediatePrompt). With the Enter in the same write unit as the
+// text, win32 ConPTY always sees it as a submit and the race that the split was
+// trying to solve cannot happen (the Enter can never be separated from the
+// text). FORCE_SUBMIT_SETTLE_MS is that minimum pre-submit gap.
 const FORCE_SUBMIT_SETTLE_MS = 150;
-const FORCE_SUBMIT_MAX_WAIT_MS = 1500;
-const FORCE_SUBMIT_POLL_MS = 50;
 
 // ─── Adapter ────────────────────────────────────────
 
@@ -1312,34 +1324,31 @@ export class ProviderCliAdapter implements CliAdapter {
             return;
         }
         LOG.info('CLI', `[${this.cliType}] force-sending prompt while status=${this.engine.currentStatus}`);
-        // Split inject from submit. Writing `content + sendKey` in one PTY write
-        // can race a TUI input box that is still absorbing/redrawing the pasted
-        // text, so the trailing submit key gets eaten and the prompt sits typed
-        // but unsent. Write the text first, let the input line settle (echo-gated
-        // when we can verify it, otherwise a fixed minimum gap), then write the
-        // submit key separately so it lands as a clean Enter on a stable prompt.
-        await this.writeToPty(content);
-        await this.waitForForceSubmitSettle(content);
-        await this.writeToPty(this.sendKey);
+        // Settle, then submit atomically. The previous split-write fix
+        // (write text → settle → write a separate '\r') regressed win32:
+        // ConPTY does not treat a lone CR arriving in its own PTY chunk after a
+        // delay as a submit key, so the Enter was swallowed and the prompt sat
+        // typed-but-unsent. Instead, honor a fixed settle gap so the TUI input
+        // handler is in its input-accepting state, then write `content + sendKey`
+        // as ONE PTY write — the same atomic submit the normal `immediate`
+        // strategy uses. Keeping the Enter in the same write unit as the text is
+        // the invariant that makes win32 ConPTY recognize the submit, and it
+        // also makes the original inject↔submit race impossible (the Enter can
+        // never be separated from the text it submits). The settle still guards
+        // the original concern — that a force-dispatch injected into a freshly
+        // idle session lands before the TUI is ready to accept input.
+        await this.waitForForceSubmitSettle();
+        await this.writeToPty(content + this.sendKey);
         this.onStatusChange?.();
     }
 
-    private async waitForForceSubmitSettle(content: string): Promise<void> {
-        const startedAt = Date.now();
-        const normalizedPromptSnippet = normalizePromptText(extractPromptRetrySnippet(content));
-        // Always honor a minimum settle so the input handler has time to finish
-        // ingesting the pasted text before the submit key arrives.
+    private async waitForForceSubmitSettle(): Promise<void> {
+        // A fixed minimum gap so the input handler is ready to accept the paste.
+        // We deliberately do NOT echo-gate here: the submit key is written in the
+        // same atomic PTY write as the text (forceSendMessage), so there is no
+        // separate Enter that could race the echo, and on win32 the echo gate
+        // never reliably matched anyway.
         await new Promise<void>(resolve => setTimeout(resolve, FORCE_SUBMIT_SETTLE_MS));
-        if (!normalizedPromptSnippet) return;
-        // Beyond the minimum gap, keep waiting (up to the cap) until the prompt
-        // echo is visible on screen — that is the strongest signal the input line
-        // has stabilized and the Enter will be applied to the typed prompt.
-        while (Date.now() - startedAt < FORCE_SUBMIT_MAX_WAIT_MS) {
-            if (!this.ptyProcess) return;
-            const screenText = this.terminalScreen.getText();
-            if (promptLikelyVisible(screenText, normalizedPromptSnippet)) return;
-            await new Promise<void>(resolve => setTimeout(resolve, FORCE_SUBMIT_POLL_MS));
-        }
     }
 
     private enqueuePendingOutboundMessage(text: string, reason: string): void {

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>