@adhdev/daemon-core 0.9.77-rc.50 → 0.9.77-rc.52

package/dist/mesh/mesh-events.d.ts

@@ -8,6 +8,10 @@ export interface PendingMeshCoordinatorEvent {
 }
 /** Drain and return all pending coordinator events, clearing the queue. */
 export declare function drainPendingMeshCoordinatorEvents(): PendingMeshCoordinatorEvent[];
+/** Peek at pending coordinator events without draining (non-destructive). */
+export declare function getPendingMeshCoordinatorEvents(): readonly PendingMeshCoordinatorEvent[];
+/** Explicitly clear all pending coordinator events. */
+export declare function clearPendingMeshCoordinatorEvents(): void;
 export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
 /**
  * Triggers a queue check for all nodes in the mesh.

package/dist/mesh/mesh-visualization.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Mesh Visualization — Transform RepoMeshStatus into a graph structure
+ * for SVG/Canvas rendering without external dependencies.
+ */
+import type { RepoMeshStatus, RepoMeshNodeStatus, RepoMeshNodeHealth } from '../repo-mesh-types.js';
+export type MeshGraphNodeType = 'defaultBranchNode' | 'worktreeNode' | 'orphanNode';
+export type MeshGraphEdgeType = 'parentBranch' | 'worktreeLink' | 'sessionLink';
+export interface MeshGraphNode {
+    id: string;
+    type: MeshGraphNodeType;
+    label: string;
+    workspace: string;
+    branch: string | null;
+    health: RepoMeshNodeHealth;
+    ahead: number;
+    behind: number;
+    dirty: boolean;
+    dirtyFiles: number;
+    hasConflicts: boolean;
+    activeSessionCount: number;
+    activeSessions: string[];
+    providers: string[];
+    isOrphan: boolean;
+    orphanReasons: string[];
+    /** Next-step hint from convergence analysis */
+    nextStepHint?: string;
+    /** Original node status for drill-down */
+    source: RepoMeshNodeStatus;
+}
+export interface MeshGraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    type: MeshGraphEdgeType;
+    label?: string;
+}
+export interface MeshGraph {
+    meshId: string;
+    meshName: string;
+    repoIdentity: string;
+    refreshedAt: string;
+    nodes: MeshGraphNode[];
+    edges: MeshGraphEdge[];
+    /** Summary statistics */
+    stats: {
+        totalNodes: number;
+        onlineNodes: number;
+        dirtyNodes: number;
+        orphanNodes: number;
+        errorNodes: number;
+        offlineNodes: number;
+        totalActiveSessions: number;
+    };
+    /** Global orphan / stale warnings */
+    warnings: string[];
+}
+/**
+ * Build a visualization graph from RepoMeshStatus.
+ *
+ * Nodes:
+ *   - defaultBranchNode: the mesh's default branch (aggregated from nodes on that branch)
+ *   - worktreeNode: a node on a feature / worktree branch
+ *   - orphanNode: a node with orphanReasons (upstream missing, detached HEAD, etc.)
+ *
+ * Edges:
+ *   - parentBranch: default branch → worktree branch (when branch name differs)
+ *   - worktreeLink: links nodes that share the same branch (clustering hint)
+ *   - sessionLink: node → session (lightweight, optional; not rendered as primary edge)
+ */
+export declare function buildMeshGraph(status: RepoMeshStatus): MeshGraph;

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

@@ -32,6 +32,8 @@ export interface MeshWorkQueueEntry {
         sessionId?: string;
         updatedAt: string;
     };
+    /** ISO timestamp when the task was dispatched (assigned) to a node/session. Used for precise matching on completion. */
+    dispatchTimestamp?: string;
     createdAt: string;
     updatedAt: string;
 }

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

@@ -1,4 +1,5 @@
 import type { ChatMessage } from '../types.js';
+export declare function extractFinalSummaryFromMessages(messages: ChatMessage[] | null | undefined, maxChars?: number): 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.77-rc.50",
+  "version": "0.9.77-rc.52",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -159,8 +159,13 @@ export type { MeshLedgerReconciliationEvidence, MeshLedgerReplicaEvidence, MeshL
 export { enqueueTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats } from './mesh/mesh-work-queue.js';
 export type { MeshWorkQueueEntry, MeshTaskStatus, MeshWorkQueueStats } from './mesh/mesh-work-queue.js';
 
+// ── Mesh Visualization ──
+export { buildMeshGraph } from './mesh/mesh-visualization.js';
+export type { MeshGraph, MeshGraphNode, MeshGraphEdge, MeshGraphNodeType, MeshGraphEdgeType } from './mesh/mesh-visualization.js';
+
 // ── Mesh Events ──
-export { triggerMeshQueue } from './mesh/mesh-events.js';
+export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents } from './mesh/mesh-events.js';
+export type { PendingMeshCoordinatorEvent } from './mesh/mesh-events.js';
 
 // ── Mesh P2P Relay Failure Classification ──
 export {

package/src/mesh/mesh-events.ts

@@ -44,6 +44,16 @@ export function drainPendingMeshCoordinatorEvents(): PendingMeshCoordinatorEvent
     return pendingMeshCoordinatorEvents.splice(0);
 }
 
+/** Peek at pending coordinator events without draining (non-destructive). */
+export function getPendingMeshCoordinatorEvents(): readonly PendingMeshCoordinatorEvent[] {
+    return pendingMeshCoordinatorEvents.slice();
+}
+
+/** Explicitly clear all pending coordinator events. */
+export function clearPendingMeshCoordinatorEvents(): void {
+    pendingMeshCoordinatorEvents.splice(0);
+}
+
 function readNonEmptyString(value: unknown): string {
     return typeof value === 'string' && value.trim() ? value.trim() : '';
 }

package/src/mesh/mesh-visualization.ts

@@ -0,0 +1,341 @@
+/**
+ * Mesh Visualization — Transform RepoMeshStatus into a graph structure
+ * for SVG/Canvas rendering without external dependencies.
+ */
+
+import type { RepoMeshStatus, RepoMeshNodeStatus, RepoMeshNodeHealth } from '../repo-mesh-types.js';
+import type { GitRepoStatus } from '../git/git-types.js';
+
+// ─── Graph Types ─────────────────────────────────
+
+export type MeshGraphNodeType = 'defaultBranchNode' | 'worktreeNode' | 'orphanNode';
+export type MeshGraphEdgeType = 'parentBranch' | 'worktreeLink' | 'sessionLink';
+
+export interface MeshGraphNode {
+  id: string;
+  type: MeshGraphNodeType;
+  label: string;
+  workspace: string;
+  branch: string | null;
+  health: RepoMeshNodeHealth;
+  ahead: number;
+  behind: number;
+  dirty: boolean;
+  dirtyFiles: number;
+  hasConflicts: boolean;
+  activeSessionCount: number;
+  activeSessions: string[];
+  providers: string[];
+  isOrphan: boolean;
+  orphanReasons: string[];
+  /** Next-step hint from convergence analysis */
+  nextStepHint?: string;
+  /** Original node status for drill-down */
+  source: RepoMeshNodeStatus;
+}
+
+export interface MeshGraphEdge {
+  id: string;
+  source: string;
+  target: string;
+  type: MeshGraphEdgeType;
+  label?: string;
+}
+
+export interface MeshGraph {
+  meshId: string;
+  meshName: string;
+  repoIdentity: string;
+  refreshedAt: string;
+  nodes: MeshGraphNode[];
+  edges: MeshGraphEdge[];
+  /** Summary statistics */
+  stats: {
+    totalNodes: number;
+    onlineNodes: number;
+    dirtyNodes: number;
+    orphanNodes: number;
+    errorNodes: number;
+    offlineNodes: number;
+    totalActiveSessions: number;
+  };
+  /** Global orphan / stale warnings */
+  warnings: string[];
+}
+
+// ─── Helpers ─────────────────────────────────────
+
+function isDirty(git?: GitRepoStatus): boolean {
+  if (!git) return false;
+  return (git.staged + git.modified + git.untracked + git.deleted + git.renamed) > 0;
+}
+
+function dirtyFileCount(git?: GitRepoStatus): number {
+  if (!git) return 0;
+  return git.staged + git.modified + git.untracked + git.deleted + git.renamed;
+}
+
+function detectOrphanReasons(node: RepoMeshNodeStatus, defaultBranch?: string | null): string[] {
+  const reasons: string[] = [];
+  const git = node.git;
+
+  if (!git) {
+    reasons.push('No git status available');
+    return reasons;
+  }
+
+  if (!git.isGitRepo) {
+    reasons.push('Not a git repository');
+    return reasons;
+  }
+
+  // Detached HEAD
+  if (git.branch === null && git.headCommit) {
+    reasons.push('Detached HEAD');
+  }
+
+  // No upstream tracking
+  if (git.branch && !git.upstream) {
+    // Local-only branch — orphan if not default
+    if (defaultBranch && git.branch !== defaultBranch) {
+      reasons.push(`No upstream: ${git.branch}`);
+    }
+  }
+
+  // Worktree branch with no upstream
+  if (git.branch && git.upstream === null && defaultBranch && git.branch !== defaultBranch) {
+    if (!reasons.includes(`No upstream: ${git.branch}`)) {
+      reasons.push(`No upstream: ${git.branch}`);
+    }
+  }
+
+  // Stale assigned tasks would be detected at queue level, not per node git status
+  // We surface node-level errors as orphan indicators
+  if (node.error) {
+    reasons.push(`Error: ${node.error}`);
+  }
+
+  return reasons;
+}
+
+function nodeHealthPriority(health: RepoMeshNodeHealth): number {
+  switch (health) {
+    case 'online': return 0;
+    case 'dirty': return 1;
+    case 'degraded': return 2;
+    case 'wrong_branch': return 3;
+    case 'offline': return 4;
+    case 'unknown': return 5;
+    default: return 5;
+  }
+}
+
+function pickDominantHealth(healths: RepoMeshNodeHealth[]): RepoMeshNodeHealth {
+  if (healths.length === 0) return 'unknown';
+  return healths.reduce((best, h) =>
+    nodeHealthPriority(h) > nodeHealthPriority(best) ? h : best
+  );
+}
+
+// ─── Graph Builder ─────────────────────────────────
+
+/**
+ * Build a visualization graph from RepoMeshStatus.
+ *
+ * Nodes:
+ *   - defaultBranchNode: the mesh's default branch (aggregated from nodes on that branch)
+ *   - worktreeNode: a node on a feature / worktree branch
+ *   - orphanNode: a node with orphanReasons (upstream missing, detached HEAD, etc.)
+ *
+ * Edges:
+ *   - parentBranch: default branch → worktree branch (when branch name differs)
+ *   - worktreeLink: links nodes that share the same branch (clustering hint)
+ *   - sessionLink: node → session (lightweight, optional; not rendered as primary edge)
+ */
+export function buildMeshGraph(status: RepoMeshStatus): MeshGraph {
+  const nodes: MeshGraphNode[] = [];
+  const edges: MeshGraphEdge[] = [];
+  const warnings: string[] = [];
+
+  // Track branch → nodes for edge creation
+  const branchToNodeIds = new Map<string, string[]>();
+
+  for (const nodeStatus of status.nodes) {
+    const git = nodeStatus.git;
+    const branch = git?.branch || null;
+    const orphanReasons = detectOrphanReasons(nodeStatus, null);
+    const dirty = isDirty(git);
+    const dfc = dirtyFileCount(git);
+
+    // Determine node type
+    let type: MeshGraphNodeType = 'worktreeNode';
+    if (orphanReasons.length > 0) {
+      type = 'orphanNode';
+    }
+
+    const graphNode: MeshGraphNode = {
+      id: nodeStatus.nodeId,
+      type,
+      label: nodeStatus.machineLabel || nodeStatus.nodeId.slice(0, 8),
+      workspace: nodeStatus.workspace,
+      branch,
+      health: nodeStatus.health,
+      ahead: git?.ahead ?? 0,
+      behind: git?.behind ?? 0,
+      dirty,
+      dirtyFiles: dfc,
+      hasConflicts: git?.hasConflicts ?? false,
+      activeSessionCount: nodeStatus.activeSessions?.length ?? 0,
+      activeSessions: nodeStatus.activeSessions ?? [],
+      providers: nodeStatus.providers ?? [],
+      isOrphan: orphanReasons.length > 0,
+      orphanReasons,
+      source: nodeStatus,
+    };
+
+    nodes.push(graphNode);
+
+    if (branch) {
+      const list = branchToNodeIds.get(branch) ?? [];
+      list.push(graphNode.id);
+      branchToNodeIds.set(branch, list);
+    }
+  }
+
+  // Create synthetic default branch node if we can infer one
+  // Heuristic: most common branch among nodes with upstream
+  const branchUpstreamCounts = new Map<string, number>();
+  for (const n of status.nodes) {
+    const b = n.git?.branch;
+    const upstream = n.git?.upstream;
+    if (b && upstream) {
+      branchUpstreamCounts.set(b, (branchUpstreamCounts.get(b) ?? 0) + 1);
+    }
+  }
+  let inferredDefaultBranch: string | null = null;
+  let bestCount = 0;
+  for (const [b, count] of branchUpstreamCounts) {
+    if (count > bestCount) {
+      bestCount = count;
+      inferredDefaultBranch = b;
+    }
+  }
+
+  // If we have a clear default branch, create a synthetic node for it
+  const defaultBranchNodeId = inferredDefaultBranch
+    ? `__branch_${inferredDefaultBranch}`
+    : null;
+
+  if (defaultBranchNodeId && inferredDefaultBranch) {
+    const branchNodes = branchToNodeIds.get(inferredDefaultBranch) ?? [];
+    const branchHealths = branchNodes.map(id =>
+      nodes.find(n => n.id === id)!.health
+    );
+
+    const defaultNode: MeshGraphNode = {
+      id: defaultBranchNodeId,
+      type: 'defaultBranchNode',
+      label: inferredDefaultBranch,
+      workspace: '',
+      branch: inferredDefaultBranch,
+      health: pickDominantHealth(branchHealths),
+      ahead: 0,
+      behind: 0,
+      dirty: false,
+      dirtyFiles: 0,
+      hasConflicts: false,
+      activeSessionCount: 0,
+      activeSessions: [],
+      providers: [],
+      isOrphan: false,
+      orphanReasons: [],
+      nextStepHint: branchNodes.length > 0 ? `${branchNodes.length} node(s) on default branch` : undefined,
+      source: {
+        nodeId: defaultBranchNodeId,
+        machineLabel: inferredDefaultBranch,
+        workspace: '',
+        health: 'online',
+        providers: [],
+        activeSessions: [],
+      },
+    };
+    nodes.push(defaultNode);
+
+    // Edge: default branch → each worktree branch that is NOT the default
+    const seenBranches = new Set<string>();
+    for (const n of nodes) {
+      if (n.type === 'defaultBranchNode') continue;
+      if (!n.branch) continue;
+      if (n.branch === inferredDefaultBranch) {
+        // Link worktree nodes on default branch directly to default branch node
+        edges.push({
+          id: `${defaultBranchNodeId}--${n.id}`,
+          source: defaultBranchNodeId,
+          target: n.id,
+          type: 'parentBranch',
+          label: 'default',
+        });
+        continue;
+      }
+      if (seenBranches.has(n.branch)) continue;
+      seenBranches.add(n.branch);
+      edges.push({
+        id: `${defaultBranchNodeId}--branch_${n.branch}`,
+        source: defaultBranchNodeId,
+        target: n.branch,
+        type: 'parentBranch',
+        label: n.branch,
+      });
+    }
+  }
+
+  // worktreeLink edges: connect nodes sharing the same branch
+  for (const [branch, ids] of branchToNodeIds) {
+    if (ids.length < 2) continue;
+    for (let i = 1; i < ids.length; i++) {
+      edges.push({
+        id: `wt_${ids[0]}--${ids[i]}`,
+        source: ids[0],
+        target: ids[i],
+        type: 'worktreeLink',
+        label: branch,
+      });
+    }
+  }
+
+  // Collect warnings
+  const orphanCount = nodes.filter(n => n.isOrphan).length;
+  if (orphanCount > 0) {
+    warnings.push(`${orphanCount} orphan node(s) detected`);
+  }
+  const conflictCount = nodes.filter(n => n.hasConflicts).length;
+  if (conflictCount > 0) {
+    warnings.push(`${conflictCount} node(s) with merge conflicts`);
+  }
+  const offlineCount = nodes.filter(n => n.health === 'offline').length;
+  if (offlineCount > 0) {
+    warnings.push(`${offlineCount} node(s) offline`);
+  }
+
+  // Stats
+  const stats = {
+    totalNodes: status.nodes.length,
+    onlineNodes: status.nodes.filter(n => n.health === 'online').length,
+    dirtyNodes: nodes.filter(n => n.dirty).length,
+    orphanNodes: orphanCount,
+    errorNodes: status.nodes.filter(n => !!n.error).length,
+    offlineNodes: offlineCount,
+    totalActiveSessions: status.nodes.reduce((sum, n) => sum + (n.activeSessions?.length ?? 0), 0),
+  };
+
+  return {
+    meshId: status.meshId,
+    meshName: status.meshName,
+    repoIdentity: status.repoIdentity,
+    refreshedAt: status.refreshedAt,
+    nodes,
+    edges,
+    stats,
+    warnings,
+  };
+}

package/src/mesh/mesh-work-queue.ts

@@ -39,6 +39,8 @@ export interface MeshWorkQueueEntry {
         sessionId?: string;
         updatedAt: string;
     };
+    /** ISO timestamp when the task was dispatched (assigned) to a node/session. Used for precise matching on completion. */
+    dispatchTimestamp?: string;
     createdAt: string;
     updatedAt: string;
 }
@@ -132,6 +134,7 @@ export function claimNextTask(meshId: string, nodeId: string, sessionId: string)
     entry.status = 'assigned';
     entry.assignedNodeId = nodeId;
     entry.assignedSessionId = sessionId;
+    entry.dispatchTimestamp = new Date().toISOString();
     entry.updatedAt = new Date().toISOString();
 
     writeQueue(meshId, queue);
@@ -243,17 +246,27 @@ export function updateSessionTaskStatus(
     status: MeshTaskStatus,
 ): MeshWorkQueueEntry | null {
     const queue = readQueue(meshId);
-    // Find the most recently assigned task for this session that isn't already terminal
-    // (In case multiple tasks were assigned to the same session over time, though rare)
+    // Collect all assigned tasks for this session, then pick the one with the
+    // most recent dispatchTimestamp (or updatedAt fallback for legacy entries).
+    // This prevents completing the wrong task when multiple tasks were assigned
+    // to the same session in rapid succession.
+    let bestIdx = -1;
+    let bestTime = 0;
     for (let i = queue.length - 1; i >= 0; i--) {
         if (queue[i].assignedSessionId === sessionId && queue[i].status === 'assigned') {
-            queue[i].status = status;
-            queue[i].updatedAt = new Date().toISOString();
-            writeQueue(meshId, queue);
-            return queue[i];
+            const time = new Date(queue[i].dispatchTimestamp || queue[i].updatedAt).getTime();
+            if (time > bestTime) {
+                bestTime = time;
+                bestIdx = i;
+            }
         }
     }
-    return null;
+    if (bestIdx === -1) return null;
+
+    queue[bestIdx].status = status;
+    queue[bestIdx].updatedAt = new Date().toISOString();
+    writeQueue(meshId, queue);
+    return queue[bestIdx];
 }
 
 export interface MeshWorkQueueStats {

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;
@@ -841,6 +841,7 @@ export class CliProviderInstance implements ProviderInstance {
             chatTitle: pending.chatTitle,
             duration: pending.duration,
             timestamp: pending.timestamp,
+            finalSummary: extractFinalSummaryFromMessages(this.adapter?.getScriptParsedStatus()?.messages),
         });
         this.completedDebouncePending = null;
         this.completedDebounceTimer = 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);
             }