@adhdev/daemon-core 0.9.82-rc.324 → 0.9.82-rc.326

package/dist/providers/chat-message-normalization.d.ts

@@ -1,6 +1,18 @@
 import type { ChatMessage } from '../types.js';
 export declare const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4000;
 export declare function extractFinalSummaryFromMessages(messages: ChatMessage[] | null | undefined, maxChars?: number): string;
+/**
+ * Like extractFinalSummaryFromMessages but also returns the ISO timestamp of the
+ * selected final assistant/model message. Completion reconciliation needs the
+ * timestamp to prove the transcript was produced AFTER the dispatch — without it
+ * reconcileDirectDispatchCompletionFromTranscript rejects non-JSON summaries as
+ * "transcript_not_proven_after_dispatch". The summary selection is identical so the
+ * timestamp always belongs to the message whose text became the summary.
+ */
+export declare function extractFinalAssistantSummaryEvidence(messages: ChatMessage[] | null | undefined, maxChars?: number): {
+    finalSummary: string;
+    transcriptMessageAt?: string;
+};
 export declare const BUILTIN_CHAT_MESSAGE_KINDS: readonly ["standard", "thought", "tool", "terminal", "system"];
 export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];
 export type ChatMessageKind = BuiltinChatMessageKind | (string & {});

package/package.json

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

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

@@ -952,6 +952,8 @@ export class ProviderCliAdapter implements CliAdapter {
             errorMessage: this.parseErrorMessage || this.engine.providerErrorMessage || undefined,
             errorReason: this.parseErrorMessage ? 'parse_error' : (this.engine.providerErrorReason || undefined),
             providerSessionId: this.providerSessionId || undefined,
+            lastOutputAt: this.lastOutputAt,
+            lastScreenChangeAt: this.lastScreenChangeAt,
             ...(bufferState ? { bufferState } : {}),
         };
     }

package/src/cli-adapters/provider-cli-shared.d.ts

@@ -18,6 +18,8 @@ export interface CliSessionStatus {
     activeModal: { message: string; buttons: string[] } | null;
     errorMessage?: string;
     errorReason?: string;
+    lastOutputAt?: number;
+    lastScreenChangeAt?: number;
 }
 export interface CliScripts {
     detectStatus?: (input: CliStatusInput) => string | null;

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

@@ -50,6 +50,21 @@ export interface CliSessionStatus {
     errorMessage?: string;
     errorReason?: string;
     providerSessionId?: string;
+    /**
+     * Timestamp (ms) of the most recent raw PTY output chunk. Advances on every
+     * byte the process emits, including tool/build output that produces no
+     * parsed assistant text. Liveness watchdogs use this to distinguish a real
+     * stall (no output at all) from an active turn whose assistant buffer is
+     * momentarily static while a tool runs.
+     */
+    lastOutputAt?: number;
+    /**
+     * Timestamp (ms) of the most recent *visible* terminal screen change.
+     * Stricter than lastOutputAt — only advances when the rendered screen
+     * content actually differs, so repeated keepalive bytes do not register as
+     * progress. Preferred liveness signal for the long-generating watchdog.
+     */
+    lastScreenChangeAt?: number;
     bufferState?: {
         responseBuffer?: { truncated: boolean; droppedChars: number; maxChars: number };
         recentOutputBuffer?: { truncated: boolean; droppedChars: number; maxChars: number };

package/src/commands/router.ts

@@ -426,6 +426,38 @@ function recordInlineMeshDirectGitTruth(
     node.lastSeenAt = updatedAt;
     const repoRoot = readStringValue(nextGit.repoRoot);
     if (repoRoot && !readStringValue(node.repoRoot)) node.repoRoot = repoRoot;
+    // Self-heal per-node platform/arch from the live probe. For a remote member
+    // this is the platform the member daemon reported in its git_status envelope
+    // (threaded through as reporter*); for the local coordinator's own / worktree
+    // nodes the git was computed locally (source 'selected_coordinator_local_git'
+    // ⇒ the workspace lives on THIS machine), so process.platform/process.arch is
+    // the correct value. Stamp into userOverrides — the exact fields
+    // buildMeshNodeCapabilityTags reads — only when absent, so an operator's
+    // explicit override is preserved and the value is corrected once per reconnect
+    // without any migration.
+    const isLocalSource = source === 'selected_coordinator_local_git';
+    const reporterPlatform = readStringValue(git.reporterPlatform) ?? (isLocalSource ? process.platform : null);
+    const reporterArch = readStringValue(git.reporterArch) ?? (isLocalSource ? process.arch : null);
+    stampNodeReporterPlatform(node, reporterPlatform, reporterArch);
+}
+
+/**
+ * Fill node.userOverrides.platform/arch from a live report, but never overwrite a
+ * value that is already present (an operator override or an earlier report). Used
+ * by both the remote-member probe path and the local self-stamp path so the
+ * coordinator advertises each node's real OS instead of falling back to the
+ * coordinator's own process.platform.
+ */
+function stampNodeReporterPlatform(node: any, platform: string | null, arch: string | null): void {
+    if (!node || typeof node !== 'object' || Array.isArray(node)) return;
+    if (!platform && !arch) return;
+    const overrides = (node.userOverrides && typeof node.userOverrides === 'object' && !Array.isArray(node.userOverrides))
+        ? node.userOverrides as Record<string, unknown>
+        : {};
+    let changed = false;
+    if (platform && !readStringValue(overrides.platform)) { overrides.platform = platform; changed = true; }
+    if (arch && !readStringValue(overrides.arch)) { overrides.arch = arch; changed = true; }
+    if (changed) node.userOverrides = overrides;
 }
 
 function buildCachedInlineMeshGitStatus(node: any): Record<string, unknown> | undefined {
@@ -1101,9 +1133,17 @@ async function probeRemoteMeshGitStatus(args: {
         new Promise<never>((_, reject) => setTimeout(() => reject(new Error('timeout')), args.timeoutMs)),
     ]) as any;
     const remoteGit = remoteResult?.status ?? remoteResult?.git ?? remoteResult;
-    return remoteGit && typeof remoteGit === 'object' && typeof remoteGit.isGitRepo === 'boolean'
-        ? remoteGit as Record<string, unknown>
-        : null;
+    if (!remoteGit || typeof remoteGit !== 'object' || typeof remoteGit.isGitRepo !== 'boolean') return null;
+    // The member daemon stamps its own platform/arch onto the git_status result
+    // envelope (see git-commands.ts). Reflect them onto the returned git object
+    // under non-colliding reporter* keys so recordInlineMeshDirectGitTruth can
+    // persist them to node.userOverrides without touching the git status shape.
+    const reporterPlatform = readStringValue(remoteResult?.reporterPlatform);
+    const reporterArch = readStringValue(remoteResult?.reporterArch);
+    const git = remoteGit as Record<string, unknown>;
+    if (reporterPlatform) git.reporterPlatform = reporterPlatform;
+    if (reporterArch) git.reporterArch = reporterArch;
+    return git;
 }
 
 /** Number of bounded retries after the initial direct-peer git probe attempt. */

package/src/git/git-commands.ts

@@ -110,7 +110,10 @@ type GitCommandFailure = {
 };
 
 type GitCommandSuccess =
-  | { success: true; status: GitRepoStatus }
+  // reporterPlatform/reporterArch carry the responding daemon's process.platform/
+  // process.arch so a mesh coordinator probing this node over P2P can self-heal the
+  // node's userOverrides.platform/arch (the fields capability-tag routing reads).
+  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string }
   | { success: true; diffSummary: GitDiffSummary }
   | { success: true; diff: GitFileDiff }
   | { success: true; snapshot: GitSnapshot }
@@ -304,7 +307,15 @@ export async function handleGitCommand(
       if (includeSubmodules !== undefined) statusParams.includeSubmodules = includeSubmodules;
       if (submoduleIgnorePaths && submoduleIgnorePaths.length > 0) statusParams.submoduleIgnorePaths = submoduleIgnorePaths;
       const status = await runService(() => services.getStatus!(statusParams));
-      return 'success' in status ? status : { success: true, status };
+      if ('success' in status) return status;
+      // Carry the responding daemon's real platform/arch alongside the git
+      // status. A mesh coordinator dispatches `git_status` to each member over
+      // P2P on every explicit graph refresh, so this is the recurring live
+      // channel that lets a member self-report its OS to the coordinator — which
+      // stamps it onto the node's userOverrides.platform/arch (the fields
+      // buildMeshNodeCapabilityTags reads). These are siblings of `status`, not
+      // part of GitRepoStatus, so the git payload shape is untouched.
+      return { success: true, status, reporterPlatform: process.platform, reporterArch: process.arch };
     }
 
     case 'git_diff_summary': {

package/src/mesh/mesh-reconcile-loop.ts

@@ -55,6 +55,10 @@ import {
     expireStaleUnresolvedDelegateForwards,
 } from './mesh-unresolved-forward-outbox.js';
 import { readNonEmptyString } from './mesh-events-utils.js';
+import { getActiveDirectDispatches } from './mesh-work-queue.js';
+import { reconcileDirectDispatchCompletionFromTranscript } from './mesh-events-stale.js';
+import { extractFinalAssistantSummaryEvidence } from '../providers/chat-message-normalization.js';
+import type { ChatMessage } from '../types.js';
 
 // Default reconcile cadence. approval/completion notifications to a live CLI
 // coordinator land within at most one interval. Overridable via env for tuning.
@@ -281,6 +285,31 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         }
     }
 
+    // ── PHASE 4: synthesize lost completions for unterminated direct dispatches ─
+    // Symmetric to PHASE 3 (which recovers a *lost claim* for a newly-idle session)
+    // but for the opposite gap: a worker that ALREADY completed, went idle, and
+    // whose terminal completion event was never persisted (dropped before reaching
+    // the queue/outbox, or its forward was lost). PHASE 1/2/3 can only deliver an
+    // event that exists in a queue — they cannot recover a completion that was
+    // never recorded, so the coordinator keeps believing the worker is generating.
+    //
+    // reconcileDirectDispatchCompletionFromTranscript already synthesizes the
+    // missing terminal event from the worker's transcript, but until now it ran
+    // ONLY when an LLM coordinator polled mesh_status (mcp_mesh_status_transcript_
+    // reconciliation). This phase pulls that same correction onto the daemon timer
+    // so it no longer depends on the LLM polling. The reconcile is idempotent
+    // (hasTerminalLedgerAfterDispatch guards against re-synthesis), so attempting it
+    // every tick for the same dispatch is safe — once a terminal exists it no-ops.
+    for (const mesh of listMeshes()) {
+        const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
+        if (!daemonHostsMesh(mesh, selfIds)) continue;
+        try {
+            await reconcileUnterminatedDirectDispatches(components, mesh, selfIds, localDaemonId);
+        } catch (e: any) {
+            LOG.warn('MeshReconcile', `Completion reconcile failed for mesh ${mesh.id}: ${e?.message || e}`);
+        }
+    }
+
     // ── PHASE 2: inject into live CLI coordinators on this daemon ──────────────
     const coordinators = findLiveCoordinators(components);
     if (coordinators.length === 0) {
@@ -445,6 +474,124 @@ async function pullRemoteNodeQueues(
     }
 }
 
+// Pull the read_chat payload out of whatever envelope the transport returned.
+// A local commandHandler.handle() returns the CommandResult directly; a remote
+// dispatchMeshCommand returns it possibly wrapped in { payload } / { result }.
+function unwrapReadChatPayload(raw: unknown): Record<string, unknown> | null {
+    let cursor: unknown = raw;
+    for (let depth = 0; depth < 4 && cursor && typeof cursor === 'object'; depth++) {
+        const record = cursor as Record<string, unknown>;
+        if (Array.isArray(record.messages)) return record;
+        if (record.payload && typeof record.payload === 'object') { cursor = record.payload; continue; }
+        if (record.result && typeof record.result === 'object') { cursor = record.result; continue; }
+        if (record.data && typeof record.data === 'object') { cursor = record.data; continue; }
+        break;
+    }
+    return cursor && typeof cursor === 'object' ? cursor as Record<string, unknown> : null;
+}
+
+function readChatPayloadStatus(payload: Record<string, unknown> | null): string {
+    return readNonEmptyString(payload?.status).toLowerCase();
+}
+
+// PHASE 4 helper. For every active (non-terminal) direct dispatch this daemon
+// hosts, confirm the worker session is idle via a read_chat and — if a final
+// assistant summary is present but no terminal ledger exists for that dispatch —
+// synthesize the missing completion through reconcileDirectDispatchCompletionFromTranscript.
+//
+// read_chat is resolved against the target node: a node on THIS daemon is read
+// through the local commandHandler; a remote node is read over P2P via
+// dispatchMeshCommand. Both yield the same { messages, status, providerSessionId }
+// shape. We only synthesize when the session reports idle AND a final assistant
+// message exists — the same evidence bar the MCP poll path uses — so an actively
+// generating worker is never falsely completed. The reconcile itself is idempotent.
+async function reconcileUnterminatedDirectDispatches(
+    components: DaemonComponents,
+    mesh: LocalMeshEntry,
+    selfIds: string[],
+    localDaemonId: string | undefined,
+): Promise<void> {
+    const dispatches = getActiveDirectDispatches(mesh.id);
+    if (dispatches.length === 0) return; // cheap exit — nothing dispatched, nothing to reconcile
+
+    const dispatchMeshCommand = components.dispatchMeshCommand;
+    const nodeById = new Map(mesh.nodes.map(n => [n.id, n] as const));
+
+    for (const dispatch of dispatches) {
+        const sessionId = readNonEmptyString(dispatch.sessionId);
+        const nodeId = readNonEmptyString(dispatch.nodeId);
+        const taskId = readNonEmptyString(dispatch.taskId);
+        if (!sessionId || !nodeId || !taskId) continue;
+
+        const node = nodeById.get(nodeId);
+        const nodeDaemonId = readNonEmptyString(node?.daemonId);
+        // A node is local when it has no daemonId, names this daemon, or actually
+        // has a live instance here. Anything else is reached over P2P.
+        const isLocalNode = !nodeDaemonId
+            || selfIds.includes(nodeDaemonId)
+            || (localDaemonId !== undefined && nodeDaemonId === localDaemonId)
+            || !!components.instanceManager.getInstance(sessionId);
+
+        const providerType = readNonEmptyString(dispatch.providerType);
+        const readArgs: Record<string, unknown> = {
+            sessionId,
+            targetSessionId: sessionId,
+            tailLimit: 10,
+            ...(node?.workspace ? { workspace: node.workspace } : {}),
+            ...(providerType ? { agentType: providerType, providerType } : {}),
+        };
+
+        let payload: Record<string, unknown> | null = null;
+        try {
+            if (isLocalNode) {
+                const result = await components.commandHandler.handle('read_chat', readArgs);
+                if (result && (result as { success?: boolean }).success === false) continue;
+                payload = unwrapReadChatPayload(result);
+            } else if (dispatchMeshCommand) {
+                const result = await dispatchMeshCommand(nodeDaemonId, 'read_chat', readArgs);
+                payload = unwrapReadChatPayload(result);
+                if (payload && (payload as { success?: boolean }).success === false) continue;
+            } else {
+                continue; // remote node but no P2P transport — can't read; retry next tick
+            }
+        } catch {
+            continue; // best-effort; session may be gone or node offline — retry next tick
+        }
+        if (!payload) continue;
+
+        // Only act on a session that has actually settled to idle. A generating /
+        // waiting_approval session is mid-turn — synthesizing a completion now would
+        // be wrong. (idle is the only status the MCP poll path reconciles too.)
+        if (readChatPayloadStatus(payload) !== 'idle') continue;
+
+        const messages = Array.isArray(payload.messages) ? payload.messages as ChatMessage[] : [];
+        const evidence = extractFinalAssistantSummaryEvidence(messages);
+        if (!evidence.finalSummary) continue; // no assistant result yet — nothing to attribute
+
+        const providerSessionId = readNonEmptyString(payload.providerSessionId);
+        const coordinatorDaemonId = selfIds.find(id => !!id);
+        try {
+            const result = reconcileDirectDispatchCompletionFromTranscript({
+                meshId: mesh.id,
+                nodeId,
+                sessionId,
+                providerType: providerType || undefined,
+                providerSessionId: providerSessionId || undefined,
+                taskId,
+                finalSummary: evidence.finalSummary,
+                ...(evidence.transcriptMessageAt ? { transcriptMessageAt: evidence.transcriptMessageAt } : {}),
+                ...(coordinatorDaemonId ? { targetCoordinatorDaemonId: coordinatorDaemonId } : {}),
+                source: 'daemon_reconcile_transcript_completion',
+            });
+            if (result.reconciled) {
+                LOG.info('MeshReconcile', `Synthesized missing completion (${result.kind}) for task ${taskId} on node ${nodeId} (mesh ${mesh.id})`);
+            }
+        } catch (e: any) {
+            LOG.warn('MeshReconcile', `Transcript completion reconcile threw for task ${taskId}: ${e?.message || e}`);
+        }
+    }
+}
+
 function extractPendingEvents(raw: unknown): any[] {
     if (Array.isArray(raw)) return raw;
     if (raw && typeof raw === 'object') {

package/src/providers/chat-message-normalization.ts

@@ -27,6 +27,53 @@ export function extractFinalSummaryFromMessages(
   return '';
 }
 
+function readChatMessageTimestampIso(message: ChatMessage | null | undefined): string | undefined {
+  if (!message) return undefined;
+  const record = message as ChatMessage & Record<string, unknown>;
+  for (const value of [record.timestamp, record.createdAt, record.created_at, record.updatedAt, record.time]) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+      // Heuristic seconds-vs-ms detection mirrors the mesh transcript reader.
+      const ms = value > 10_000_000_000 ? value : value * 1000;
+      return new Date(ms).toISOString();
+    }
+    if (typeof value === 'string' && value.trim()) {
+      const ms = new Date(value.trim()).getTime();
+      if (Number.isFinite(ms)) return new Date(ms).toISOString();
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Like extractFinalSummaryFromMessages but also returns the ISO timestamp of the
+ * selected final assistant/model message. Completion reconciliation needs the
+ * timestamp to prove the transcript was produced AFTER the dispatch — without it
+ * reconcileDirectDispatchCompletionFromTranscript rejects non-JSON summaries as
+ * "transcript_not_proven_after_dispatch". The summary selection is identical so the
+ * timestamp always belongs to the message whose text became the summary.
+ */
+export function extractFinalAssistantSummaryEvidence(
+  messages: ChatMessage[] | null | undefined,
+  maxChars: number = DEFAULT_FINAL_SUMMARY_MAX_CHARS,
+): { finalSummary: string; transcriptMessageAt?: string } {
+  if (!Array.isArray(messages) || messages.length === 0) return { finalSummary: '' };
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg) continue;
+    const classification = classifyChatMessageVisibility(msg);
+    if (classification.isUserFacing && (msg.role === 'assistant' || msg.role === 'model')) {
+      const text = flattenContent(msg.content).trim();
+      if (text) {
+        return {
+          finalSummary: text.slice(0, maxChars),
+          transcriptMessageAt: readChatMessageTimestampIso(msg),
+        };
+      }
+    }
+  }
+  return { finalSummary: '' };
+}
+
 export const BUILTIN_CHAT_MESSAGE_KINDS = ['standard', 'thought', 'tool', 'terminal', 'system'] as const;
 
 export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];

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

@@ -1545,8 +1545,16 @@ export class CliProviderInstance implements ProviderInstance {
         const dirName = workingDirBasename(this.workingDir);
         const chatTitle = `${this.provider.name} · ${dirName}`;
         const partial = this.adapter.getPartialResponse();
+        // Liveness fingerprint for the long-generating watchdog. The parsed
+        // assistant buffer (`partial`) alone goes static while a tool/build runs
+        // — the assistant emits no tokens even though the PTY is actively
+        // printing tool output — which made the watchdog false-fire a "stuck"
+        // alert mid-turn. Fold in the adapter's raw-activity timestamps so any
+        // visible terminal progress (lastScreenChangeAt) or raw PTY byte
+        // (lastOutputAt) keeps the fingerprint moving. The watchdog then only
+        // survives a genuine stall where nothing at all is happening.
         const progressFingerprint = newStatus === 'generating'
-            ? `${partial || ''}`.slice(-2000)
+            ? `${`${partial || ''}`.slice(-2000)}::scr=${adapterStatus.lastScreenChangeAt ?? 0}::out=${adapterStatus.lastOutputAt ?? 0}`
             : undefined;
 
         const previousStatus = this.lastStatus;