@adhdev/daemon-core 0.9.82-rc.4 → 0.9.82-rc.40

package/src/git/git-commands.ts

@@ -62,7 +62,7 @@ export interface GitPushResult extends GitRepoIdentity {
 }
 
 export interface GitCommandServices {
-  getStatus?: (params: { workspace: string }) => Promise<GitRepoStatus> | GitRepoStatus;
+  getStatus?: (params: { workspace: string; refreshUpstream?: boolean }) => Promise<GitRepoStatus> | GitRepoStatus;
   getDiffSummary?: (params: { workspace: string; staged?: boolean }) => Promise<GitDiffSummary> | GitDiffSummary;
   getDiffFile?: (params: { workspace: string; path: string; staged?: boolean }) => Promise<GitFileDiff> | GitFileDiff;
   createSnapshot?: (params: {
@@ -171,7 +171,7 @@ const defaultSnapshotStore = createGitSnapshotStore({
 
 export function createDefaultGitCommandServices(): GitCommandServices {
   return {
-    getStatus: ({ workspace }) => getGitRepoStatus(workspace),
+    getStatus: ({ workspace, refreshUpstream }) => getGitRepoStatus(workspace, { refreshUpstream }),
     getDiffSummary: ({ workspace }) => getGitDiffSummary(workspace),
     getDiffFile: ({ workspace, path: filePath }) => getGitFileDiff(workspace, filePath),
     createSnapshot: ({ workspace, reason, sessionId, turnId }) => defaultSnapshotStore.create({
@@ -290,7 +290,7 @@ export async function handleGitCommand(
   switch (command) {
     case 'git_status': {
       if (!services.getStatus) return serviceNotImplemented(command);
-      const status = await runService(() => services.getStatus!({ workspace }));
+      const status = await runService(() => services.getStatus!({ workspace, refreshUpstream: optionalBoolean(args?.refreshUpstream) }));
       return 'success' in status ? status : { success: true, status };
     }
 

package/src/git/git-status.ts

@@ -1,12 +1,25 @@
-import type { GitRepoStatus, GitSubmoduleStatus } from './git-types.js';
+import type { GitRepoStatus, GitSubmoduleStatus, GitUpstreamFreshness } from './git-types.js';
 import { GitCommandError, resolveGitRepository, runGit } from './git-executor.js';
 
+type ResolvedGitRepo = { workspace: string; repoRoot: string | null; isGitRepo: boolean };
+
 export interface GitStatusOptions {
   timeoutMs?: number;
   /** When true, include submodule status in the result. Defaults to true. */
   includeSubmodules?: boolean;
   /** Optional filter to exclude specific submodule paths from status */
   submoduleIgnorePaths?: string[];
+  /**
+   * When true, refresh the tracked remote before trusting ahead/behind.
+   * Callers should opt into this only for convergence-critical surfaces.
+   */
+  refreshUpstream?: boolean;
+}
+
+interface GitUpstreamProbe {
+  upstreamStatus: GitUpstreamFreshness;
+  upstreamFetchedAt?: number;
+  upstreamFetchError?: string;
 }
 
 export async function getGitRepoStatus(
@@ -18,8 +31,16 @@ export async function getGitRepoStatus(
 
   try {
     const repo = await resolveGitRepository(workspace, options);
-    const statusOutput = await runGit(repo, ['status', '--porcelain=v2', '--branch'], options);
-    const parsed = parsePorcelainV2Status(statusOutput.stdout);
+    let parsed = await readPorcelainStatus(repo, options);
+    let upstreamProbe: GitUpstreamProbe = getInitialUpstreamProbe(parsed);
+
+    if (options.refreshUpstream) {
+      upstreamProbe = await refreshTrackedUpstream(repo, parsed, options);
+      if (upstreamProbe.upstreamStatus === 'fresh') {
+        parsed = await readPorcelainStatus(repo, options);
+      }
+    }
+
     const head = await readHead(repo, options);
     const stashCount = await readStashCount(repo, options);
 
@@ -36,6 +57,9 @@ export async function getGitRepoStatus(
       headCommit: head.commit,
       headMessage: head.message,
       upstream: parsed.upstream,
+      upstreamStatus: parsed.upstream ? upstreamProbe.upstreamStatus : 'no_upstream',
+      upstreamFetchedAt: upstreamProbe.upstreamFetchedAt,
+      upstreamFetchError: upstreamProbe.upstreamFetchError,
       ahead: parsed.ahead,
       behind: parsed.behind,
       staged: parsed.staged,
@@ -74,6 +98,72 @@ interface ParsedPorcelainStatus {
   conflictFiles: string[];
 }
 
+async function readPorcelainStatus(repo: ResolvedGitRepo, options: GitStatusOptions): Promise<ParsedPorcelainStatus> {
+  const statusOutput = await runGit(repo, ['status', '--porcelain=v2', '--branch'], options);
+  return parsePorcelainV2Status(statusOutput.stdout);
+}
+
+function getInitialUpstreamProbe(parsed: ParsedPorcelainStatus): GitUpstreamProbe {
+  return {
+    upstreamStatus: parsed.upstream ? 'unchecked' : 'no_upstream',
+  };
+}
+
+async function refreshTrackedUpstream(
+  repo: ResolvedGitRepo,
+  parsed: ParsedPorcelainStatus,
+  options: GitStatusOptions,
+): Promise<GitUpstreamProbe> {
+  if (!parsed.upstream || !parsed.branch) {
+    return { upstreamStatus: 'no_upstream' };
+  }
+
+  const remoteName = (await readBranchRemote(repo, parsed.branch, options)) ?? inferRemoteName(parsed.upstream);
+  if (!remoteName) {
+    return {
+      upstreamStatus: 'stale',
+      upstreamFetchError: `Unable to resolve remote for upstream '${parsed.upstream}'`,
+    };
+  }
+
+  try {
+    await runGit(repo, ['fetch', '--quiet', '--prune', '--no-tags', remoteName], options);
+    return {
+      upstreamStatus: 'fresh',
+      upstreamFetchedAt: Date.now(),
+    };
+  } catch (error) {
+    return {
+      upstreamStatus: 'stale',
+      upstreamFetchError: formatGitError(error),
+    };
+  }
+}
+
+async function readBranchRemote(repo: ResolvedGitRepo, branch: string, options: GitStatusOptions): Promise<string | null> {
+  try {
+    const result = await runGit(repo, ['config', '--get', `branch.${branch}.remote`], options);
+    return result.stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function inferRemoteName(upstream: string): string | null {
+  const [remoteName] = upstream.split('/');
+  return remoteName?.trim() || null;
+}
+
+function formatGitError(error: unknown): string {
+  if (error instanceof GitCommandError) {
+    return error.stderr || error.message;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
 export function parsePorcelainV2Status(output: string): ParsedPorcelainStatus {
   const parsed: ParsedPorcelainStatus = {
     branch: null,
@@ -145,7 +235,7 @@ export function parsePorcelainV2Status(output: string): ParsedPorcelainStatus {
 }
 
 async function readHead(
-  repo: { workspace: string; repoRoot: string | null; isGitRepo: boolean },
+  repo: ResolvedGitRepo,
   options: GitStatusOptions,
 ): Promise<{ commit: string | null; message: string | null }> {
   try {
@@ -163,7 +253,7 @@ async function readHead(
 }
 
 async function readStashCount(
-  repo: { workspace: string; repoRoot: string | null; isGitRepo: boolean },
+  repo: ResolvedGitRepo,
   options: GitStatusOptions,
 ): Promise<number> {
   try {
@@ -187,6 +277,7 @@ function emptyStatus(workspace: string, lastCheckedAt: number, error: GitCommand
     headCommit: null,
     headMessage: null,
     upstream: null,
+    upstreamStatus: 'unavailable',
     ahead: 0,
     behind: 0,
     staged: 0,
@@ -206,7 +297,7 @@ function emptyStatus(workspace: string, lastCheckedAt: number, error: GitCommand
 // ─── Submodule Status ───────────────────────────
 
 async function getSubmoduleStatuses(
-  repo: { workspace: string; repoRoot: string | null; isGitRepo: boolean },
+  repo: ResolvedGitRepo,
   options: GitStatusOptions,
 ): Promise<GitSubmoduleStatus[]> {
   if (!repo.repoRoot) return [];

package/src/git/git-summary.ts

@@ -22,6 +22,9 @@ export function createGitCompactSummary(status: GitRepoStatus, diffSummary?: Git
     isGitRepo: status.isGitRepo,
     repoRoot: status.repoRoot,
     branch: status.branch,
+    upstreamStatus: status.upstreamStatus,
+    upstreamFetchedAt: status.upstreamFetchedAt,
+    upstreamFetchError: status.upstreamFetchError,
     dirty:
       status.staged > 0 ||
       status.modified > 0 ||

package/src/git/git-types.ts

@@ -40,11 +40,19 @@ export interface GitSubmoduleStatus {
   error?: string;
 }
 
+export type GitUpstreamFreshness = 'fresh' | 'unchecked' | 'stale' | 'no_upstream' | 'unavailable';
+
 export interface GitRepoStatus extends GitRepoIdentity {
   branch: string | null;
   headCommit: string | null;
   headMessage: string | null;
   upstream: string | null;
+  /** Whether ahead/behind was verified against a freshly fetched upstream ref. */
+  upstreamStatus: GitUpstreamFreshness;
+  /** Timestamp for the fetch that refreshed upstream refs when upstreamStatus === 'fresh'. */
+  upstreamFetchedAt?: number;
+  /** Error from the last refresh attempt when upstreamStatus === 'stale'. */
+  upstreamFetchError?: string;
   ahead: number;
   behind: number;
   staged: number;
@@ -134,6 +142,9 @@ export interface GitCompactSummary {
   isGitRepo: boolean;
   repoRoot: string | null;
   branch: string | null;
+  upstreamStatus: GitUpstreamFreshness;
+  upstreamFetchedAt?: number;
+  upstreamFetchError?: string;
   dirty: boolean;
   changedFiles: number;
   ahead: number;

package/src/index.ts

@@ -103,6 +103,14 @@ export type {
   LocalMeshNodeEntry,
   RepoMeshStatus,
   RepoMeshNodeStatus,
+  RepoMeshSessionStatus,
+  RepoMeshQueueTask,
+  RepoMeshQueueTaskStatus,
+  RepoMeshQueueSummary,
+  RepoMeshQueueStatus,
+  RepoMeshLedgerEntryStatus,
+  RepoMeshLedgerSummaryStatus,
+  RepoMeshLedgerStatus,
 } from './repo-mesh-types.js';
 export { DEFAULT_MESH_POLICY } from './repo-mesh-types.js';
 
@@ -168,7 +176,7 @@ export type { MeshWorkQueueEntry, MeshTaskStatus, MeshWorkQueueStats } from './m
 // export type { MeshGraph, MeshGraphNode, MeshGraphEdge, MeshGraphNodeType, MeshGraphEdgeType } from './mesh/mesh-visualization.js';
 
 // ── Mesh Events ──
-export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents } from './mesh/mesh-events.js';
+export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent } from './mesh/mesh-events.js';
 export type { PendingMeshCoordinatorEvent } from './mesh/mesh-events.js';
 
 // ── Mesh P2P Relay Failure Classification ──

package/src/mesh/mesh-events.ts

@@ -1,57 +1,106 @@
+import { appendFileSync, existsSync, readFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import { loadConfig } from '../config/config.js';
 import { getMesh, getMeshByRepo } from '../config/mesh-config.js';
 import { detectCLI } from '../detection/cli-detector.js';
 import { LOG } from '../logging/logger.js';
-import { appendLedgerEntry, buildTaskCompletionEvidence, getSessionRecoveryContext, isIntentionalCleanupStopEntry, readLedgerEntries } from './mesh-ledger.js';
+import { appendLedgerEntry, buildTaskCompletionEvidence, getLedgerDir, getSessionRecoveryContext, isIntentionalCleanupStopEntry, readLedgerEntries } from './mesh-ledger.js';
 import type { MeshLedgerKind, SessionRecoveryContext } from './mesh-ledger.js';
 import { claimNextTask, updateSessionTaskStatus, enqueueTask, updateTaskStatus, getQueue, recordTaskAutoLaunch } from './mesh-work-queue.js';
 
 // ---------------------------------------------------------------------------
 // Remote Node Idle Session Tracking
 // ---------------------------------------------------------------------------
-// Tracks remote sessions that emitted 'agent:ready' so triggerMeshQueue 
-// can assign tasks to them.
+// Tracks remote sessions that emitted 'agent:ready' so triggerMeshQueue
+// can assign tasks to them. Each entry carries an expiresAt timestamp;
+// entries are swept on insertion to prevent unbounded growth.
 // ---------------------------------------------------------------------------
 interface RemoteIdleSession {
     nodeId: string;
     sessionId: string;
     providerType: string;
+    expiresAt: number;
 }
+const REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes
 const remoteIdleSessions = new Map<string, RemoteIdleSession>(); // key: `${nodeId}:${sessionId}`
 
+function sweepExpiredRemoteIdleSessions(): void {
+    const now = Date.now();
+    for (const [key, session] of remoteIdleSessions) {
+        if (session.expiresAt <= now) remoteIdleSessions.delete(key);
+    }
+}
+
 // ---------------------------------------------------------------------------
-// MCP coordinator pending-event queue
+// MCP coordinator pending-event queue — FILE-BASED PERSISTENCE
 // ---------------------------------------------------------------------------
 // When a mesh event fires but no CLI coordinator session is registered (e.g.
-// the coordinator is Claude Code running via MCP), we buffer the event here.
-// The MCP server drains this queue on every mesh_status / mesh_send_task poll.
+// the coordinator is Claude Code running via MCP), we persist the event to a
+// per-mesh JSONL file so it survives daemon restarts. The 50-entry hard cap
+// is removed; the file is drained atomically on each get_pending_mesh_events
+// call and limited to 100 KB to prevent runaway growth.
+//
+// File: <ledgerDir>/<meshId>.pending-events.jsonl
 // ---------------------------------------------------------------------------
 
 export interface PendingMeshCoordinatorEvent {
     event: string;
     meshId: string;
     nodeLabel: string;
+    nodeId?: string;
+    workspace?: string;
     metadataEvent: Record<string, unknown>;
     queuedAt: number;
 }
 
-const MAX_PENDING_EVENTS = 50;
-const pendingMeshCoordinatorEvents: PendingMeshCoordinatorEvent[] = [];
+function getPendingEventsPath(meshId: string): string {
+    const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return join(getLedgerDir(), `${safe}.pending-events.jsonl`);
+}
+
+export function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEvent): boolean {
+    try {
+        appendFileSync(getPendingEventsPath(event.meshId), JSON.stringify(event) + '\n', 'utf-8');
+        return true;
+    } catch (e: any) {
+        LOG.warn('MeshEvents', `Failed to persist pending coordinator event: ${e?.message || e}`);
+        return false;
+    }
+}
 
-/** Drain and return all pending coordinator events, clearing the queue. */
-export function drainPendingMeshCoordinatorEvents(): PendingMeshCoordinatorEvent[] {
-    return pendingMeshCoordinatorEvents.splice(0);
+/** Drain and return all pending coordinator events for meshId, removing them from disk. */
+export function drainPendingMeshCoordinatorEvents(meshId?: string): PendingMeshCoordinatorEvent[] {
+    if (!meshId) return [];
+    const path = getPendingEventsPath(meshId);
+    if (!existsSync(path)) return [];
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        try { unlinkSync(path); } catch { /* concurrent drain already removed it */ }
+        return raw.split('\n').filter(Boolean).flatMap(line => {
+            try { return [JSON.parse(line) as PendingMeshCoordinatorEvent]; } catch { return []; }
+        });
+    } catch { return []; }
 }
 
 /** Peek at pending coordinator events without draining (non-destructive). */
-export function getPendingMeshCoordinatorEvents(): readonly PendingMeshCoordinatorEvent[] {
-    return pendingMeshCoordinatorEvents.slice();
+export function getPendingMeshCoordinatorEvents(meshId?: string): readonly PendingMeshCoordinatorEvent[] {
+    if (!meshId) return [];
+    const path = getPendingEventsPath(meshId);
+    if (!existsSync(path)) return [];
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        return raw.split('\n').filter(Boolean).flatMap(line => {
+            try { return [JSON.parse(line) as PendingMeshCoordinatorEvent]; } catch { return []; }
+        });
+    } catch { return []; }
 }
 
-/** Explicitly clear all pending coordinator events. */
-export function clearPendingMeshCoordinatorEvents(): void {
-    pendingMeshCoordinatorEvents.splice(0);
+/** Explicitly clear all pending coordinator events for a mesh. */
+export function clearPendingMeshCoordinatorEvents(meshId?: string): void {
+    if (!meshId) return;
+    const path = getPendingEventsPath(meshId);
+    if (existsSync(path)) try { unlinkSync(path); } catch { /* already removed */ }
 }
 
 function readNonEmptyString(value: unknown): string {
@@ -140,6 +189,62 @@ function shouldSuppressIntentionalCleanupStop(args: {
     return hasRecentIntentionalCleanupStop(args.meshId, args.sessionId, args.nodeId);
 }
 
+const RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1000;
+const recentCompletionFingerprints = new Map<string, number>();
+
+function readEventTimestamp(value: unknown): number | null {
+    if (typeof value === 'number' && Number.isFinite(value)) return value;
+    if (typeof value === 'string' && value.trim()) {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric)) return numeric;
+        const parsed = Date.parse(value);
+        if (Number.isFinite(parsed)) return parsed;
+    }
+    return null;
+}
+
+function buildMeshCompletionFingerprint(args: {
+    meshId: string;
+    event: string;
+    sessionId: string;
+    providerType?: string;
+    providerSessionId?: string;
+    timestamp?: number | null;
+    finalSummary?: string;
+}): string {
+    const timestampPart = Number.isFinite(args.timestamp)
+        ? String(args.timestamp)
+        : readNonEmptyString(args.finalSummary).slice(0, 200);
+    return [
+        args.meshId,
+        args.event,
+        args.sessionId,
+        args.providerType || '',
+        args.providerSessionId || '',
+        timestampPart,
+    ].join('::');
+}
+
+function isDuplicateMeshCompletionEvent(args: {
+    meshId: string;
+    event: string;
+    sessionId: string;
+    providerType?: string;
+    providerSessionId?: string;
+    timestamp?: number | null;
+    finalSummary?: string;
+}): boolean {
+    const fingerprint = buildMeshCompletionFingerprint(args);
+    if (!fingerprint) return false;
+    const now = Date.now();
+    for (const [key, seenAt] of recentCompletionFingerprints.entries()) {
+        if (now - seenAt > RECENT_COMPLETION_FINGERPRINT_TTL_MS) recentCompletionFingerprints.delete(key);
+    }
+    if (recentCompletionFingerprints.has(fingerprint)) return true;
+    recentCompletionFingerprints.set(fingerprint, now);
+    return false;
+}
+
 
 export function tryAssignQueueTask(
     components: DaemonComponents,
@@ -170,7 +275,16 @@ export function tryAssignQueueTask(
                 message: task.message,
             }).catch((e: any) => {
                 LOG.error('MeshQueue', `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
-                updateTaskStatus(meshId, task.id, 'failed');
+                // Revert to pending so the task can be retried rather than permanently failing
+                updateTaskStatus(meshId, task.id, 'pending');
+                try {
+                    appendLedgerEntry(meshId, {
+                        kind: 'dispatch_failed' as any,
+                        nodeId,
+                        sessionId,
+                        payload: { taskId: task.id, error: e?.message, retryable: true },
+                    });
+                } catch { /* ledger write is best-effort */ }
             });
             return true;
         }
@@ -593,6 +707,23 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         return { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true };
     }
 
+    const eventTimestamp = readEventTimestamp(args.metadataEvent.timestamp);
+    if (args.event === 'agent:generating_completed' && eventSessionId) {
+        const duplicateCompletion = isDuplicateMeshCompletionEvent({
+            meshId: args.meshId,
+            event: args.event,
+            sessionId: eventSessionId,
+            providerType: readNonEmptyString(args.metadataEvent.providerType) || undefined,
+            providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
+            timestamp: eventTimestamp,
+            finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+        });
+        if (duplicateCompletion) {
+            LOG.info('MeshEvents', `Suppressed duplicate completion for mesh ${args.meshId} session ${eventSessionId}`);
+            return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true };
+        }
+    }
+
     // ── Task Queue & Ledger ──
     let completedTaskForLedger: { id?: string } | null = null;
     if (args.event === 'agent:generating_completed') {
@@ -601,13 +732,16 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
         
         if (sessionId) {
-            const completedTask = updateSessionTaskStatus(args.meshId, sessionId, 'completed');
+            const completedTask = updateSessionTaskStatus(args.meshId, sessionId, 'completed', {
+                occurredAt: eventTimestamp !== null ? new Date(eventTimestamp).toISOString() : undefined,
+            });
             completedTaskForLedger = completedTask ? { id: completedTask.id } : null;
             if (nodeId && providerType) {
-                // Short delay to allow completion event to propagate before pulling next
-                setTimeout(() => {
+                // Queue state is already updated above; setImmediate avoids the
+                // 500 ms artificial delay while still deferring past this call frame.
+                setImmediate(() => {
                     tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-                }, 500);
+                });
             }
         }
     } else if (args.event === 'agent:ready') {
@@ -648,13 +782,15 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         }
         
         if (sessionId && nodeId && providerType) {
-            remoteIdleSessions.set(`${nodeId}:${sessionId}`, { nodeId, sessionId, providerType });
-            setTimeout(() => {
+            sweepExpiredRemoteIdleSessions();
+            remoteIdleSessions.set(`${nodeId}:${sessionId}`, {
+                nodeId, sessionId, providerType,
+                expiresAt: Date.now() + REMOTE_IDLE_SESSION_TTL_MS,
+            });
+            setImmediate(() => {
                 const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-                if (assigned) {
-                    remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
-                }
-            }, 500);
+                if (assigned) remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+            });
         }
     } else if (args.event === 'agent:generating_started') {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
@@ -781,17 +917,18 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
 
     if (coordinatorInstances.length === 0) {
         // No CLI coordinator session found — buffer for MCP-based coordinators.
-        if (pendingMeshCoordinatorEvents.length < MAX_PENDING_EVENTS) {
-            pendingMeshCoordinatorEvents.push({
+        if (queuePendingMeshCoordinatorEvent({
                 event: args.event,
                 meshId: args.meshId,
                 nodeLabel: args.nodeLabel,
+                nodeId: args.nodeId || undefined,
+                workspace: readNonEmptyString(args.metadataEvent.workspace),
                 metadataEvent: {
                     ...args.metadataEvent,
                     ...(recoveryContext ? { recoveryContext } : {}),
                 },
                 queuedAt: Date.now(),
-            });
+            })) {
             LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
         }
         return { success: true, forwarded: 0 };
@@ -834,6 +971,7 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
             providerType: readNonEmptyString(payload.providerType),
             providerSessionId: readNonEmptyString(payload.providerSessionId),
             finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
+            ...(payload.timestamp !== undefined ? { timestamp: payload.timestamp } : {}),
             intentional: payload.intentional === true,
             intentionalStop: payload.intentionalStop === true,
             operatorCleanup: payload.operatorCleanup === true,