@adhdev/daemon-core 0.9.77-rc.9 → 0.9.77

package/src/mesh/p2p-relay-failure.ts

@@ -0,0 +1,152 @@
+export type P2pRelayFailureCode =
+  | 'p2p_unavailable'
+  | 'p2p_timeout'
+  | 'p2p_not_connected'
+  | 'p2p_datachannel_closed'
+  | 'p2p_no_route'
+  | 'p2p_daemon_offline'
+  | 'mesh_logic_or_provider_failure';
+
+export interface P2pRelayFailureContext {
+  command?: string;
+  targetDaemonId?: string;
+}
+
+export interface P2pRelayFailureClassification {
+  code: P2pRelayFailureCode;
+  reason: string;
+  transport: 'p2p' | 'unknown';
+  recoverable: boolean;
+  retryRecommended: boolean;
+  nextAction: string;
+  noFallbackReason: string;
+}
+
+export interface P2pRelayFailurePayload extends P2pRelayFailureClassification {
+  success: false;
+  error: string;
+  command?: string;
+  targetDaemonId?: string;
+}
+
+const NO_FALLBACK_REASON = 'Repo Mesh command/data-plane is P2P-only; WS/REST command fallback is intentionally disabled to preserve the transport boundary.';
+const P2P_NEXT_ACTION = 'Check daemon/P2P health, wait briefly for connection establishment, then do one bounded retry or requeue the mesh task after clearing stale target session metadata.';
+const NON_P2P_NEXT_ACTION = 'Inspect the provider/command error and fix the underlying logic or configuration before retrying.';
+
+function messageFromError(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  if (typeof error === 'string') return error;
+  if (error && typeof error === 'object') {
+    const candidate = (error as any).error ?? (error as any).message ?? (error as any).reason;
+    if (typeof candidate === 'string') return candidate;
+  }
+  return String(error || 'mesh relay command failed');
+}
+
+export function classifyP2pRelayFailure(error: unknown, _context: P2pRelayFailureContext = {}): P2pRelayFailureClassification {
+  const message = messageFromError(error);
+  const lower = message.toLowerCase();
+
+  const hasP2pSignal = /p2p|datachannel|node-datachannel|webrtc|ice|mesh_relay_command|daemon_mesh_p2p_transport/i.test(message);
+  const hasFailureSignal = /unavailable|missing|failed|failure|timeout|timed out|not connected|closed|disconnected|offline|no route|route unavailable|cannot send|cannot establish/i.test(message);
+
+  // Validation errors that merely mention mesh_relay_command are not transport failures.
+  if (/requires targetdaemonid and command|providerpriority|no inference provider|permission denied|read-only|not a member/i.test(message)) {
+    return {
+      code: 'mesh_logic_or_provider_failure',
+      reason: 'mesh_logic_or_provider_failure',
+      transport: 'unknown',
+      recoverable: false,
+      retryRecommended: false,
+      nextAction: NON_P2P_NEXT_ACTION,
+      noFallbackReason: NO_FALLBACK_REASON,
+    };
+  }
+
+  let code: P2pRelayFailureCode | null = null;
+  let reason = '';
+
+  if (/timeout|timed out/i.test(message) && (hasP2pSignal || /mesh transport/i.test(message))) {
+    code = 'p2p_timeout';
+    reason = 'daemon_mesh_p2p_timeout';
+  } else if (/no route|route unavailable/i.test(message)) {
+    code = 'p2p_no_route';
+    reason = 'daemon_mesh_p2p_no_route';
+  } else if (/offline|not owned|not found|not connected to server/i.test(message) && /daemon|peer|target/i.test(message)) {
+    code = 'p2p_daemon_offline';
+    reason = 'daemon_mesh_target_offline';
+  } else if (/closed|disconnected/i.test(message) && (hasP2pSignal || /state changed/i.test(message))) {
+    code = 'p2p_datachannel_closed';
+    reason = 'daemon_mesh_p2p_datachannel_closed';
+  } else if (/not connected|cannot send|cannot establish/i.test(message) && hasP2pSignal) {
+    code = 'p2p_not_connected';
+    reason = 'daemon_mesh_p2p_not_connected';
+  } else if (hasP2pSignal && hasFailureSignal) {
+    code = 'p2p_unavailable';
+    reason = 'daemon_mesh_p2p_transport_unavailable';
+  }
+
+  if (!code) {
+    return {
+      code: 'mesh_logic_or_provider_failure',
+      reason: 'mesh_logic_or_provider_failure',
+      transport: 'unknown',
+      recoverable: false,
+      retryRecommended: false,
+      nextAction: NON_P2P_NEXT_ACTION,
+      noFallbackReason: NO_FALLBACK_REASON,
+    };
+  }
+
+  return {
+    code,
+    reason,
+    transport: 'p2p',
+    recoverable: true,
+    retryRecommended: true,
+    nextAction: P2P_NEXT_ACTION,
+    noFallbackReason: NO_FALLBACK_REASON,
+  };
+}
+
+export function isP2pRelayTransportFailure(error: unknown): boolean {
+  return classifyP2pRelayFailure(error).recoverable === true;
+}
+
+export function buildP2pRelayFailurePayload(error: unknown, context: P2pRelayFailureContext = {}): P2pRelayFailurePayload {
+  const classification = classifyP2pRelayFailure(error, context);
+  return {
+    success: false,
+    ...classification,
+    error: messageFromError(error),
+    ...(context.command ? { command: context.command } : {}),
+    ...(context.targetDaemonId ? { targetDaemonId: context.targetDaemonId } : {}),
+  };
+}
+
+export class P2pRelayFailureError extends Error {
+  code: P2pRelayFailureCode;
+  reason: string;
+  transport: 'p2p' | 'unknown';
+  recoverable: boolean;
+  retryRecommended: boolean;
+  nextAction: string;
+  noFallbackReason: string;
+  command?: string;
+  targetDaemonId?: string;
+
+  constructor(message: string, context: P2pRelayFailureContext = {}) {
+    super(message);
+    this.name = 'P2pRelayFailureError';
+    const payload = buildP2pRelayFailurePayload(message, context);
+    this.code = payload.code;
+    this.reason = payload.reason;
+    this.transport = payload.transport;
+    this.recoverable = payload.recoverable;
+    this.retryRecommended = payload.retryRecommended;
+    this.nextAction = payload.nextAction;
+    this.noFallbackReason = payload.noFallbackReason;
+    this.command = context.command;
+    this.targetDaemonId = context.targetDaemonId;
+  }
+}

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

@@ -61,6 +61,7 @@ import {
     buildToolChatMessage,
     buildUserChatMessage,
     normalizeChatMessages,
+    extractFinalSummaryFromMessages,
 } from './chat-message-normalization.js';
 import { LOG } from '../logging/logger.js';
 import type { ChatMessage } from '../types.js';
@@ -1507,7 +1508,7 @@ export class AcpProviderInstance implements ProviderInstance {
                 });
             } else if (newStatus === 'idle' && (this.lastStatus === 'generating' || this.lastStatus === 'waiting_approval')) {
                 const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1000) : 0;
-                this.pushEvent({ event: 'agent:generating_completed', chatTitle, duration, timestamp: now });
+                this.pushEvent({ event: 'agent:generating_completed', chatTitle, duration, timestamp: now, finalSummary: extractFinalSummaryFromMessages(this.messages) });
                 this.generatingStartedAt = 0;
             } else if (newStatus === 'stopped') {
                 this.pushEvent({ event: 'agent:stopped', chatTitle, timestamp: now });

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

@@ -1,4 +1,36 @@
 import type { ChatMessage } from '../types.js';
+import { flattenContent } from './contracts.js';
+
+export function extractFinalSummaryFromMessages(
+  messages: ChatMessage[] | null | undefined,
+  maxChars: number = 500,
+): string {
+  if (!Array.isArray(messages) || messages.length === 0) return '';
+
+  // Find last user-facing assistant message
+  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 text.slice(0, maxChars);
+    }
+  }
+
+  // Fallback: last user-facing message of any role
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg) continue;
+    const classification = classifyChatMessageVisibility(msg);
+    if (classification.isUserFacing) {
+      const text = flattenContent(msg.content).trim();
+      if (text) return text.slice(0, maxChars);
+    }
+  }
+
+  return '';
+}
 
 export const BUILTIN_CHAT_MESSAGE_KINDS = ['standard', 'thought', 'tool', 'terminal', 'system'] as const;
 

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

@@ -25,7 +25,7 @@ import { formatAutoApprovalMessage, pickApprovalButton } from './approval-utils.
 import { getCliScriptCommand, parseCliScriptResult } from './cli-script-results.js';
 import { mergeProviderPatchState, resolveProviderStateSurface } from './provider-patch-state.js';
 import { normalizeProviderSessionId } from './provider-session-id.js';
-import { buildChatMessage, buildRuntimeSystemChatMessage, isUserFacingChatMessage, normalizeChatMessages, resolveChatMessageKind } from './chat-message-normalization.js';
+import { buildChatMessage, buildRuntimeSystemChatMessage, isUserFacingChatMessage, normalizeChatMessages, resolveChatMessageKind, extractFinalSummaryFromMessages } from './chat-message-normalization.js';
 
 type PersistableCliHistoryMessage = {
     role: string;
@@ -35,6 +35,17 @@ type PersistableCliHistoryMessage = {
     receivedAt?: number;
 };
 
+type CompletedDebouncePending = {
+    chatTitle: string;
+    duration: number;
+    timestamp: number;
+    firstObservedAt: number;
+    loggedBlockReason?: string;
+};
+
+const COMPLETED_FINALIZATION_RETRY_MS = 1000;
+const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30_000;
+
 const IMAGE_MIME_EXTENSIONS: Record<string, string> = {
     'image/png': '.png',
     'image/jpeg': '.jpg',
@@ -103,6 +114,15 @@ function cleanupStaleMaterializedImages(dir: string): void {
     } catch { /* dir may not exist or be inaccessible */ }
 }
 
+function hasNonEmptyCliModalButtons(activeModal: unknown): boolean {
+    const buttons = (activeModal as any)?.buttons;
+    return Array.isArray(buttons) && buttons.some((button) => String(button || '').trim().length > 0);
+}
+
+function isCliGeneratingLikeStatus(status: unknown): boolean {
+    return status === 'generating' || status === 'streaming' || status === 'long_generating' || status === 'starting';
+}
+
 export function buildCliStructuredInputPrompt(
     input: InputEnvelope,
     options: { materializeDir?: string } = {},
@@ -511,6 +531,10 @@ export class CliProviderInstance implements ProviderInstance {
         const canonicalBackedHistory = this.syncCanonicalSavedHistoryIfNeeded();
 
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
+        const parsedChatStatus = typeof parsedStatus?.status === 'string' && parsedStatus.status.trim()
+            ? parsedStatus.status.trim()
+            : undefined;
+        const suppressStaleParsedBusyStatus = this.shouldSuppressStaleParsedBusyStatus(parsedStatus, adapterStatus);
 
         if (parsedMessages.length > 0) {
             const shouldSkipReplayPersist =
@@ -518,7 +542,7 @@ export class CliProviderInstance implements ProviderInstance {
                 && adapterStatus.status === 'idle'
                 && parsedStatus?.status === 'idle';
             let messagesToSave = parsedMessages;
-            if ((parsedStatus?.status === 'generating' || parsedStatus?.status === 'long_generating')) {
+            if (!suppressStaleParsedBusyStatus && (parsedChatStatus === 'generating' || parsedChatStatus === 'long_generating')) {
                 const lastIdx = messagesToSave.length - 1;
                 if (lastIdx >= 0 && messagesToSave[lastIdx]?.role === 'assistant') {
                     messagesToSave = messagesToSave.slice(0, lastIdx);
@@ -553,6 +577,13 @@ export class CliProviderInstance implements ProviderInstance {
             summaryMetadata: this.summaryMetadata as any,
             controlValues: this.controlValues,
         });
+        const activeChatStatus = parseErrorMessage
+            ? 'error'
+            : autoApproveActive && parsedStatus?.status === 'waiting_approval'
+            ? 'generating'
+            : (adapterStatus.status !== 'idle'
+                ? visibleStatus
+                : (suppressStaleParsedBusyStatus ? visibleStatus : (parsedChatStatus || visibleStatus)));
 
         return {
             type: this.type,
@@ -563,13 +594,7 @@ export class CliProviderInstance implements ProviderInstance {
             activeChat: {
                 id: `${this.type}_${this.workingDir}`,
                 title: parsedStatus?.title || dirName,
-                status: parseErrorMessage
-                    ? 'error'
-                    : autoApproveActive && parsedStatus?.status === 'waiting_approval'
-                    ? 'generating'
-                    : (adapterStatus.status !== 'idle'
-                        ? visibleStatus
-                        : (parsedStatus?.status || visibleStatus)),
+                status: activeChatStatus,
                 messages: mergedMessages,
                 activeModal: autoApproveActive ? null : (parsedStatus?.activeModal ?? adapterStatus.activeModal),
                 inputContent: '',
@@ -680,7 +705,7 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     private completedDebounceTimer: NodeJS.Timeout | null = null;
-    private completedDebouncePending: { chatTitle: string; duration: number; timestamp: number } | null = null;
+    private completedDebouncePending: CompletedDebouncePending | null = null;
 
     private async enforceFreshSessionLaunchIfNeeded(): Promise<void> {
         const scriptName = getForcedNewSessionScriptName(this.provider, this.launchMode);
@@ -709,6 +734,120 @@ export class CliProviderInstance implements ProviderInstance {
         this.applyProviderResponse(parsed.payload, { phase: 'immediate' });
     }
 
+    private completionHasFinalAssistantMessage(messages: unknown): boolean {
+        const visibleMessages = (Array.isArray(messages) ? messages : [])
+            .filter((message: any) => isUserFacingChatMessage(message as ChatMessage));
+        const lastVisible = visibleMessages[visibleMessages.length - 1] as ChatMessage | undefined;
+        const role = typeof lastVisible?.role === 'string' ? lastVisible.role.trim().toLowerCase() : '';
+        const content = lastVisible ? flattenContent(lastVisible.content).trim() : '';
+        return role === 'assistant' && !!content;
+    }
+
+    private hasAdapterPendingResponse(): boolean {
+        const adapterAny = this.adapter as any;
+        if (adapterAny?.isWaitingForResponse === true) return true;
+        if (adapterAny?.currentTurnScope) return true;
+        try {
+            if (typeof this.adapter.isProcessing === 'function' && this.adapter.isProcessing()) return true;
+        } catch { /* defensive: status rendering must not fail because of adapter diagnostics */ }
+        try {
+            const partial = typeof this.adapter.getPartialResponse === 'function'
+                ? this.adapter.getPartialResponse()
+                : '';
+            if (typeof partial === 'string' && partial.trim()) return true;
+        } catch { /* defensive: missing partial means no pending response evidence */ }
+        return false;
+    }
+
+    private shouldSuppressStaleParsedBusyStatus(parsedStatus: any, adapterStatus: any): boolean {
+        const parsedRawStatus = typeof parsedStatus?.status === 'string' ? parsedStatus.status.trim() : '';
+        const adapterRawStatus = typeof adapterStatus?.status === 'string' ? adapterStatus.status.trim() : '';
+        if (!isCliGeneratingLikeStatus(parsedRawStatus)) return false;
+        if (adapterRawStatus !== 'idle') return false;
+        if (hasNonEmptyCliModalButtons(parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+        return !this.hasAdapterPendingResponse();
+    }
+
+    private getCompletedFinalizationBlockReason(latestVisibleStatus: string): string | null {
+        if (latestVisibleStatus !== 'idle') return `status:${latestVisibleStatus}`;
+
+        const adapterAny = this.adapter as any;
+        if (adapterAny?.isWaitingForResponse === true) return 'adapter_waiting_for_response';
+        if (adapterAny?.currentTurnScope) return 'adapter_turn_scope_active';
+
+        const partial = typeof this.adapter.getPartialResponse === 'function'
+            ? this.adapter.getPartialResponse()
+            : '';
+        if (typeof partial === 'string' && partial.trim()) return 'partial_response_pending';
+
+        let parsed: any;
+        try {
+            parsed = this.adapter.getScriptParsedStatus();
+        } catch (error: any) {
+            return `parse_error:${error?.message || String(error)}`;
+        }
+
+        const parsedStatus = typeof parsed?.status === 'string' ? parsed.status : 'unknown';
+        if (parsedStatus !== 'idle') return `parsed_status:${parsedStatus}`;
+        if (parsed?.activeModal || parsed?.modal) return 'parsed_modal_active';
+        if (!this.completionHasFinalAssistantMessage(parsed?.messages)) return 'missing_final_assistant';
+
+        return null;
+    }
+
+    private scheduleCompletedDebounceFlush(delayMs: number): void {
+        if (this.completedDebounceTimer) clearTimeout(this.completedDebounceTimer);
+        this.completedDebounceTimer = setTimeout(() => this.flushCompletedDebounceIfFinalized(), delayMs);
+    }
+
+    private flushCompletedDebounceIfFinalized(): void {
+        const pending = this.completedDebouncePending;
+        if (!pending) {
+            this.completedDebounceTimer = null;
+            return;
+        }
+
+        const latestStatus = this.adapter.getStatus({ allowParse: false });
+        const latestAutoApproveActive = latestStatus.status === 'waiting_approval' && this.shouldAutoApprove();
+        const latestVisibleStatus = latestAutoApproveActive ? 'generating' : latestStatus.status;
+        if (latestVisibleStatus !== 'idle') {
+            LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
+            this.completedDebouncePending = null;
+            this.completedDebounceTimer = null;
+            return;
+        }
+
+        const blockReason = this.getCompletedFinalizationBlockReason(latestVisibleStatus);
+        if (blockReason) {
+            const waitedMs = Date.now() - pending.firstObservedAt;
+            if (waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS) {
+                if (pending.loggedBlockReason !== blockReason) {
+                    LOG.info('CLI', `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);
+                    pending.loggedBlockReason = blockReason;
+                }
+                this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
+                return;
+            }
+            LOG.warn('CLI', `[${this.type}] suppressed completed event after ${waitedMs}ms without finalized assistant turn (${blockReason})`);
+            this.completedDebouncePending = null;
+            this.completedDebounceTimer = null;
+            this.generatingStartedAt = 0;
+            return;
+        }
+
+        LOG.info('CLI', `[${this.type}] completed in ${pending.duration}s`);
+        this.pushEvent({
+            event: 'agent:generating_completed',
+            chatTitle: pending.chatTitle,
+            duration: pending.duration,
+            timestamp: pending.timestamp,
+            finalSummary: extractFinalSummaryFromMessages(this.adapter?.getScriptParsedStatus()?.messages),
+        });
+        this.completedDebouncePending = null;
+        this.completedDebounceTimer = null;
+        this.generatingStartedAt = 0;
+    }
+
     private maybeAutoApproveStatus(adapterStatus: any, now = Date.now()): boolean {
         const autoApproveActive = adapterStatus?.status === 'waiting_approval' && this.shouldAutoApprove();
         // Guard re-entry: onStatusChange/getState can observe the same modal multiple
@@ -811,28 +950,13 @@ export class CliProviderInstance implements ProviderInstance {
                     this.generatingDebouncePending = null;
                     this.generatingStartedAt = 0;
                 } else {
-                    // Debounce completed — wait 3s, if still idle then emit
-                    if (this.completedDebounceTimer) clearTimeout(this.completedDebounceTimer);
-                    this.completedDebouncePending = { chatTitle, duration, timestamp: now };
-                    this.completedDebounceTimer = setTimeout(() => {
-                        if (this.completedDebouncePending) {
-                            const latestStatus = this.adapter.getStatus({ allowParse: false });
-                            const latestAutoApproveActive = latestStatus.status === 'waiting_approval' && this.shouldAutoApprove();
-                            const latestVisibleStatus = latestAutoApproveActive ? 'generating' : latestStatus.status;
-                            if (latestVisibleStatus !== 'idle') {
-                                LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
-                                this.completedDebouncePending = null;
-                                this.completedDebounceTimer = null;
-                                return;
-                            }
-                            LOG.info('CLI', `[${this.type}] completed in ${this.completedDebouncePending.duration}s`);
-                            this.pushEvent({ event: 'agent:generating_completed', ...this.completedDebouncePending });
-                            this.completedDebouncePending = null;
-                            this.generatingStartedAt = 0;
-                        }
-                        this.completedDebounceTimer = null;
-                    }, 3000);
+                    // Debounce completed, then require the rich transcript path that read_chat
+                    // uses to show an idle turn whose last user-facing message is assistant.
+                    this.completedDebouncePending = { chatTitle, duration, timestamp: now, firstObservedAt: now };
+                    this.scheduleCompletedDebounceFlush(3000);
                 }
+            } else if (newStatus === 'idle' && this.lastStatus === 'starting') {
+                this.pushEvent({ event: 'agent:ready', chatTitle, timestamp: now });
             } else if (newStatus === 'stopped') {
                 // Cancel any pending debounce
                 if (this.generatingDebounceTimer) { clearTimeout(this.generatingDebounceTimer); this.generatingDebounceTimer = null; }

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

@@ -12,7 +12,7 @@ import { buildPersistedProviderEffectMessage, normalizeProviderEffects } from '.
 import { ChatHistoryWriter } from '../config/chat-history.js';
 import type { ChatMessage } from '../types.js';
 import { mergeProviderPatchState, resolveProviderStateSurface } from './provider-patch-state.js';
-import { buildChatMessage, buildRuntimeSystemChatMessage, normalizeChatMessages } from './chat-message-normalization.js';
+import { buildChatMessage, buildRuntimeSystemChatMessage, normalizeChatMessages, extractFinalSummaryFromMessages } from './chat-message-normalization.js';
 import { getProviderSessionCapabilities, EXTENSION_PROVIDER_SESSION_CAPABILITIES_BASE } from './open-panel-support.js';
 
 export class ExtensionProviderInstance implements ProviderInstance {
@@ -234,6 +234,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
                     agentType: this.type,
                     agentName: this.agentName || this.provider.name,
                     extensionId: this.extensionId || this.type,
+                    finalSummary: extractFinalSummaryFromMessages(data?.messages),
                 });
                 this.generatingStartedAt = 0;
             }

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

@@ -22,7 +22,7 @@ import { validateReadChatResultPayload } from './read-chat-contract.js';
 import type { ChatMessage } from '../types.js';
 import { formatAutoApprovalMessage, pickApprovalButton } from './approval-utils.js';
 import { mergeProviderPatchState, resolveProviderStateSurface } from './provider-patch-state.js';
-import { buildChatMessage, buildRuntimeSystemChatMessage, normalizeChatMessages } from './chat-message-normalization.js';
+import { buildChatMessage, buildRuntimeSystemChatMessage, normalizeChatMessages, extractFinalSummaryFromMessages } from './chat-message-normalization.js';
 import { getProviderSessionCapabilities, IDE_PROVIDER_SESSION_CAPABILITIES_BASE } from './open-panel-support.js';
 
 type ReadChatModal = {
@@ -470,7 +470,7 @@ export class IdeProviderInstance implements ProviderInstance {
             } else if (agentStatus === 'idle' && (lastStatus === 'generating' || lastStatus === 'waiting_approval')) {
                 const startedAt = this.generatingStartedAt.get(agentKey);
                 const duration = startedAt ? Math.round((now - startedAt) / 1000) : 0;
-                this.pushEvent({ event: 'agent:generating_completed', chatTitle, duration, timestamp: now, ideType: this.type });
+                this.pushEvent({ event: 'agent:generating_completed', chatTitle, duration, timestamp: now, ideType: this.type, finalSummary: extractFinalSummaryFromMessages(chatData?.messages) });
                 this.generatingStartedAt.delete(agentKey);
             }
 

package/src/repo-mesh-types.ts

@@ -224,6 +224,8 @@ export interface LocalMeshNodeEntry {
     workspace: string;
     repoRoot?: string;
     daemonId?: string;
+    /** Machine registry ID that owns this workspace, when known. */
+    machineId?: string;
     userOverrides: Partial<RepoMeshNodeCapabilities>;
     policy: RepoMeshNodePolicy;
     /** For single-machine mesh: same daemon, different worktree */

package/src/shared-types.ts

@@ -390,10 +390,29 @@ export interface SessionEntry {
     surfaceHidden?: boolean;
     settings?: Record<string, any>;
     meshQueueStats?: {
+        total?: number;
+        active?: number;
+        historical?: number;
         pending: number;
         assigned: number;
         completed: number;
         failed: number;
+        cancelled?: number;
+        activeCounts?: {
+            pending: number;
+            assigned: number;
+        };
+        historicalCounts?: {
+            completed: number;
+            failed: number;
+            cancelled: number;
+        };
+        activeAssignments?: Array<{
+            id: string;
+            nodeId?: string;
+            sessionId?: string;
+            message: string;
+        }>;
     };
 }
 
@@ -435,10 +454,29 @@ export interface CompactSessionEntry {
     summaryMetadata?: ProviderSummaryMetadata;
     settings?: Record<string, any>;
     meshQueueStats?: {
+        total?: number;
+        active?: number;
+        historical?: number;
         pending: number;
         assigned: number;
         completed: number;
         failed: number;
+        cancelled?: number;
+        activeCounts?: {
+            pending: number;
+            assigned: number;
+        };
+        historicalCounts?: {
+            completed: number;
+            failed: number;
+            cancelled: number;
+        };
+        activeAssignments?: Array<{
+            id: string;
+            nodeId?: string;
+            sessionId?: string;
+            message: string;
+        }>;
     };
 }