@adhdev/daemon-core 0.9.82-rc.325 → 0.9.82-rc.327

package/dist/mesh/mesh-work-queue.d.ts

@@ -84,6 +84,8 @@ export declare function buildMeshNodeCapabilityTags(node: {
     isLocalWorktree?: unknown;
     worktreeBranch?: unknown;
     userOverrides?: unknown;
+    reportedPlatform?: unknown;
+    reportedArch?: unknown;
 } | undefined, providerType?: string): string[];
 export declare function nodeSatisfiesRequiredTags(requiredTags: unknown, capabilityTags: unknown): boolean;
 /**

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/dist/repo-mesh-types.d.ts

@@ -418,6 +418,18 @@ export interface LocalMeshNodeEntry {
     /** Operator-defined capability tags used by mesh queue matching. */
     capabilities?: string[];
     userOverrides: Partial<RepoMeshNodeCapabilities>;
+    /**
+     * Live, self-healed platform/arch reported by the daemon that owns this
+     * node's workspace (its own process.platform/process.arch), carried on the
+     * git_status envelope and persisted by the coordinator on each direct git
+     * probe. This is auto-detected truth, kept DISTINCT from `userOverrides`
+     * (operator intent) so capability-tag derivation can prefer an explicit
+     * operator override while still self-correcting auto-detected nodes — and so
+     * a stale value is overwritten by the next report rather than sticking.
+     * Absent until the first direct probe succeeds.
+     */
+    reportedPlatform?: string;
+    reportedArch?: string;
     policy: RepoMeshNodePolicy;
     /**
      * Per-node instruction surfaced in the coordinator prompt so the LLM

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.325",
+  "version": "0.9.82-rc.327",
   "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.325",
+    "@adhdev/mesh-shared": "0.9.82-rc.327",
     "@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

@@ -407,8 +407,10 @@ function recordInlineMeshDirectGitTruth(
     node: any,
     git: Record<string, unknown>,
     source: 'selected_coordinator_local_git' | 'selected_coordinator_mesh_p2p_git',
-): void {
-    if (!node || typeof node !== 'object' || Array.isArray(node)) return;
+): { reporterPlatform: string | null; reporterArch: string | null } {
+    if (!node || typeof node !== 'object' || Array.isArray(node)) {
+        return { reporterPlatform: null, reporterArch: null };
+    }
     const checkedAt = readNumberValue(git.lastCheckedAt) ?? Date.now();
     const updatedAt = new Date(checkedAt).toISOString();
     const nextGit: Record<string, unknown> = {
@@ -426,6 +428,73 @@ 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);
+    // Mirror onto the in-memory node's dedicated reporter fields too (distinct
+    // from userOverrides). For a local_config mesh the caller also persists these
+    // to meshes.json via updateNode so the value survives a coordinator restart;
+    // for an inline/cache mesh this keeps the runtime object self-consistent.
+    if (reporterPlatform) node.reportedPlatform = reporterPlatform;
+    if (reporterArch) node.reportedArch = reporterArch;
+    return { 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;
+}
+
+/**
+ * Persist the live self-reported platform/arch onto the local meshes.json node
+ * record so capability-tag os=/arch= self-heals across coordinator restarts.
+ *
+ * The in-memory stamp done by recordInlineMeshDirectGitTruth lives on the
+ * mesh_status assembly object and is discarded after the response; only a
+ * `local_config` mesh has a backing meshes.json node to write through to. Inline
+ * cache/bootstrap meshes have no local node to update, so we no-op for them.
+ * Fire-and-forget (same pattern as the worktreeBootstrap writer) — a persistence
+ * failure must never block the status response.
+ */
+function persistNodeReporterPlatform(
+    meshSource: 'inline_cache' | 'inline_bootstrap' | 'local_config',
+    mesh: any,
+    nodeId: string | undefined,
+    reporter: { reporterPlatform: string | null; reporterArch: string | null },
+): void {
+    if (meshSource !== 'local_config') return;
+    const meshId = readStringValue(mesh?.id);
+    if (!meshId || !nodeId) return;
+    const reportedPlatform = reporter.reporterPlatform ?? undefined;
+    const reportedArch = reporter.reporterArch ?? undefined;
+    if (!reportedPlatform && !reportedArch) return;
+    void import('../config/mesh-config.js')
+        .then(({ updateNode }) => updateNode(meshId, nodeId, { reportedPlatform, reportedArch }))
+        .catch(() => { /* best-effort self-heal; never block status assembly */ });
 }
 
 function buildCachedInlineMeshGitStatus(node: any): Record<string, unknown> | undefined {
@@ -1101,9 +1170,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. */
@@ -1283,7 +1360,8 @@ async function hydrateInlineMeshDirectTruth(args: {
             try {
                 const localGit = await getGitRepoStatus(workspace, { timeoutMs: 10_000, refreshUpstream: true });
                 if (localGit?.isGitRepo) {
-                    recordInlineMeshDirectGitTruth(node, localGit as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
+                    const reporter = recordInlineMeshDirectGitTruth(node, localGit as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
+                    persistNodeReporterPlatform(args.meshSource, args.mesh, nodeId, reporter);
                     localConfirmedCount += 1;
                     continue;
                 }
@@ -1335,7 +1413,8 @@ async function hydrateInlineMeshDirectTruth(args: {
             ? await args.probeCache.probe(daemonId, workspace, runProbe)
             : await runProbe();
         if (remoteGit) {
-            recordInlineMeshDirectGitTruth(node, remoteGit, 'selected_coordinator_mesh_p2p_git');
+            const reporter = recordInlineMeshDirectGitTruth(node, remoteGit, 'selected_coordinator_mesh_p2p_git');
+            persistNodeReporterPlatform(args.meshSource, args.mesh, nodeId, reporter);
             peerConfirmedCount += 1;
             continue;
         }
@@ -9259,7 +9338,8 @@ export class DaemonCommandRouter {
                                         if (!connectionReported || connectionState === 'unknown') {
                                             status.connection = buildLivePeerGitConnection(connection, refreshedAt);
                                         }
-                                        recordInlineMeshDirectGitTruth(node, remoteGit, 'selected_coordinator_mesh_p2p_git');
+                                        const reporter = recordInlineMeshDirectGitTruth(node, remoteGit, 'selected_coordinator_mesh_p2p_git');
+                                        persistNodeReporterPlatform(meshRecord.source, mesh, nodeId, reporter);
                                         remoteProbeApplied = true;
                                     }
                                 }
@@ -9300,7 +9380,8 @@ export class DaemonCommandRouter {
                                 try {
                                     const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 10_000, refreshUpstream: true });
                                     status.git = gitStatus;
-                                    recordInlineMeshDirectGitTruth(node, gitStatus as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
+                                    const reporter = recordInlineMeshDirectGitTruth(node, gitStatus as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
+                                    persistNodeReporterPlatform(meshRecord.source, mesh, nodeId, reporter);
                                     if (gitStatus.isGitRepo) {
                                         status.health = deriveMeshNodeHealthFromGit(gitStatus as unknown as Record<string, unknown>);
                                     } else {

package/src/config/mesh-config.ts

@@ -604,6 +604,11 @@ export function updateNode(
         /** Per-node instruction surfaced in the coordinator prompt. Pass an
          *  empty string or undefined to clear it. */
         systemPrompt?: string;
+        /** Live self-reported platform/arch from the owning daemon's git_status
+         *  envelope. Persisted distinctly from userOverrides (auto-detected, not
+         *  operator intent) so capability-tag os=/arch= self-heals across loads. */
+        reportedPlatform?: string;
+        reportedArch?: string;
     },
 ): LocalMeshNodeEntry | undefined {
     const config = loadMeshConfig();
@@ -614,6 +619,8 @@ export function updateNode(
     if (!node) return undefined;
 
     if (opts.userOverrides) node.userOverrides = { ...node.userOverrides, ...opts.userOverrides };
+    if (opts.reportedPlatform && opts.reportedPlatform.trim()) node.reportedPlatform = opts.reportedPlatform.trim();
+    if (opts.reportedArch && opts.reportedArch.trim()) node.reportedArch = opts.reportedArch.trim();
     if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
     if (opts.worktreeBootstrap) node.worktreeBootstrap = opts.worktreeBootstrap;
     if (Object.prototype.hasOwnProperty.call(opts, 'systemPrompt')) {

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/mesh/mesh-work-queue.ts

@@ -385,8 +385,20 @@ function readNodeOverride(node: { userOverrides?: unknown } | undefined, key: 'p
     return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
 
+/**
+ * Live, self-reported platform/arch the owning daemon stamped onto the node from
+ * its own process.platform/process.arch via the git_status envelope. Kept on a
+ * field DISTINCT from userOverrides so capability-tag derivation can prefer an
+ * explicit operator override while still self-healing auto-detected nodes — and
+ * so the value reflects the node's real OS rather than the coordinator's.
+ */
+function readNodeReporter(node: { reportedPlatform?: unknown; reportedArch?: unknown } | undefined, key: 'platform' | 'arch'): string | null {
+    const value = key === 'platform' ? node?.reportedPlatform : node?.reportedArch;
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
 export function buildMeshNodeCapabilityTags(
-    node: { capabilities?: unknown; policy?: unknown; isLocalWorktree?: unknown; worktreeBranch?: unknown; userOverrides?: unknown } | undefined,
+    node: { capabilities?: unknown; policy?: unknown; isLocalWorktree?: unknown; worktreeBranch?: unknown; userOverrides?: unknown; reportedPlatform?: unknown; reportedArch?: unknown } | undefined,
     providerType?: string,
 ): string[] {
     const provider = typeof providerType === 'string' && providerType.trim()
@@ -395,17 +407,25 @@ export function buildMeshNodeCapabilityTags(
     const worktreeBranch = typeof node?.worktreeBranch === 'string' && node.worktreeBranch.trim()
         ? node.worktreeBranch.trim()
         : null;
-    // Per-node platform/arch: prefer the value the remote daemon stamped into
-    // its node record (userOverrides.platform/arch) so a Windows member advertises
-    // os=win32 even though the COORDINATOR computing these tags runs on darwin.
-    // Fall back to process.platform/process.arch only when absent — that covers the
-    // local coordinator node and local worktree nodes, where process.* IS correct.
+    // Per-node platform/arch precedence (highest → lowest):
+    //   1. userOverrides.platform/arch — an EXPLICIT operator override always wins.
+    //   2. reportedPlatform/reportedArch — the live OS the owning daemon
+    //      self-reported (its own process.platform/process.arch via the git_status
+    //      envelope), persisted to the node record on each direct probe. This is
+    //      why a Windows member advertises os=win32 even though the COORDINATOR
+    //      computing these tags runs on darwin — without it the consumer reads the
+    //      persistent node (operator userOverrides empty) and would fall straight
+    //      through to the coordinator's own process.platform, mislabeling every
+    //      node os=darwin. We prefer this LIVE value over any stale auto-stamp.
+    //   3. process.platform/process.arch — last-resort fallback, correct only for
+    //      the local coordinator node / local worktree nodes that have not yet
+    //      been probed (their workspace lives on THIS machine anyway).
     // Vocabulary is raw process.platform/process.arch ("darwin"/"win32"/"linux",
     // "arm64"/"x64") on both the advertiser and the required_tags matcher, which
     // compares with plain string equality (nodeSatisfiesRequiredTags) — so this
     // keeps the win32/darwin/linux vocabulary the matcher already expects.
-    const os = readNodeOverride(node, 'platform') ?? process.platform;
-    const arch = readNodeOverride(node, 'arch') ?? process.arch;
+    const os = readNodeOverride(node, 'platform') ?? readNodeReporter(node, 'platform') ?? process.platform;
+    const arch = readNodeOverride(node, 'arch') ?? readNodeReporter(node, 'arch') ?? process.arch;
     return normalizeMeshCapabilityTags([
         ...(Array.isArray(node?.capabilities) ? node.capabilities : []),
         `os=${os}`,

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;

package/src/repo-mesh-types.ts

@@ -533,6 +533,18 @@ export interface LocalMeshNodeEntry {
     /** Operator-defined capability tags used by mesh queue matching. */
     capabilities?: string[];
     userOverrides: Partial<RepoMeshNodeCapabilities>;
+    /**
+     * Live, self-healed platform/arch reported by the daemon that owns this
+     * node's workspace (its own process.platform/process.arch), carried on the
+     * git_status envelope and persisted by the coordinator on each direct git
+     * probe. This is auto-detected truth, kept DISTINCT from `userOverrides`
+     * (operator intent) so capability-tag derivation can prefer an explicit
+     * operator override while still self-correcting auto-detected nodes — and so
+     * a stale value is overwritten by the next report rather than sticking.
+     * Absent until the first direct probe succeeds.
+     */
+    reportedPlatform?: string;
+    reportedArch?: string;
     policy: RepoMeshNodePolicy;
     /**
      * Per-node instruction surfaced in the coordinator prompt so the LLM