@synergenius/flow-weaver-pack-weaver 0.9.140 → 0.9.144

package/src/ui/trace-to-timeline.ts

@@ -68,6 +68,8 @@ export interface HistoricalRun {
   durationMs?: number;
   duration?: number; // fallback
   summary?: string;
+  /** Markdown report for rich UI display. */
+  report?: string;
   outputs?: Record<string, unknown>;
   startedAt?: string;
   finishedAt?: string;

package/src/ui/use-stream-timeline.ts

@@ -42,6 +42,8 @@ export interface StreamTimelineState {
     steps: Array<{ id: string; operation: string; description: string }>;
   } | null;
   awaitingApproval: boolean;
+  /** Markdown report from bot-completed event. */
+  report: string | null;
 }
 
 export function useStreamTimeline(events: StreamEvent[], isDone: boolean): StreamTimelineState {
@@ -76,6 +78,9 @@ export function useStreamTimeline(events: StreamEvent[], isDone: boolean): Strea
     // Map nodeId → index in entries[] so we can replace start with complete
     const nodeEntryIndex = new Map<string, number>();
     const nodeStarts = new Map<string, number>();
+    // Track completed/failed nodes to skip duplicate completion events
+    // (FW runtime emits 2x STATUS_CHANGED per node transition)
+    const completedNodes = new Set<string>();
     let idCounter = 0;
 
     for (const event of events) {
@@ -95,6 +100,17 @@ export function useStreamTimeline(events: StreamEvent[], isDone: boolean): Strea
         case 'node-start': {
           const nodeId = d.nodeId as string;
           if (nodeId) nodeStarts.set(nodeId, event.timestamp);
+
+          // If we already have an in-flight entry for this node (duplicate
+          // STATUS_CHANGED from the FW runtime), skip the duplicate.
+          const existingStartIdx = nodeEntryIndex.get(nodeId);
+          if (existingStartIdx != null && entries[existingStartIdx]?.type === 'node-started') {
+            break;
+          }
+
+          // Clear completed tracking so retry loops work (node can re-enter)
+          completedNodes.delete(nodeId);
+
           const idx = entries.length;
           nodeEntryIndex.set(nodeId, idx);
           entries.push({
@@ -111,65 +127,91 @@ export function useStreamTimeline(events: StreamEvent[], isDone: boolean): Strea
 
         case 'node-complete': {
           const nodeId = d.nodeId as string;
+          // Skip duplicate completion events for the same node
+          if (completedNodes.has(nodeId)) break;
+
           const startTs = nodeStarts.get(nodeId);
           const duration =
             (d.durationMs as number) ?? (startTs ? event.timestamp - startTs : undefined);
           if (nodeId) nodeStarts.delete(nodeId);
-
-          const rawOutputs = d.outputs as Array<{ portLabel: string; value: unknown }> | undefined;
-
-          const completed: TimelineEntry = {
-            id: `s-${idCounter++}`,
-            timestamp: new Date(startTs ?? event.timestamp),
-            type: 'node-completed',
-            nodeId,
-            label: (d.label as string) ?? (d.nodeType as string) ?? nodeId ?? 'Node',
-            duration,
-            color: d.color as string | undefined,
-            icon: d.icon as string | undefined,
-            outputs: rawOutputs && rawOutputs.length > 0 ? rawOutputs : undefined,
-          };
+          completedNodes.add(nodeId);
 
           // Replace the node-started entry in-place
           const existingIdx = nodeEntryIndex.get(nodeId);
           if (existingIdx != null && entries[existingIdx]) {
-            entries[existingIdx] = completed;
+            const rawOutputs = d.outputs as Array<{ portLabel: string; value: unknown }> | undefined;
+            entries[existingIdx] = {
+              id: entries[existingIdx]!.id,
+              timestamp: new Date(startTs ?? event.timestamp),
+              type: 'node-completed',
+              nodeId,
+              label: (d.label as string) ?? (d.nodeType as string) ?? nodeId ?? 'Node',
+              duration,
+              color: d.color as string | undefined,
+              icon: d.icon as string | undefined,
+              outputs: rawOutputs && rawOutputs.length > 0 ? rawOutputs : undefined,
+            };
             nodeEntryIndex.delete(nodeId);
           } else {
-            entries.push(completed);
+            // No matching start entry — standalone complete (e.g. Start node)
+            const rawOutputs = d.outputs as Array<{ portLabel: string; value: unknown }> | undefined;
+            entries.push({
+              id: `s-${idCounter++}`,
+              timestamp: new Date(startTs ?? event.timestamp),
+              type: 'node-completed',
+              nodeId,
+              label: (d.label as string) ?? (d.nodeType as string) ?? nodeId ?? 'Node',
+              duration,
+              color: d.color as string | undefined,
+              icon: d.icon as string | undefined,
+              outputs: rawOutputs && rawOutputs.length > 0 ? rawOutputs : undefined,
+            });
           }
           break;
         }
 
         case 'node-error': {
           const nodeId = d.nodeId as string;
+          if (completedNodes.has(nodeId)) break; // skip duplicate
+
           const startTs = nodeStarts.get(nodeId);
           const duration =
             (d.durationMs as number) ?? (startTs ? event.timestamp - startTs : undefined);
           if (nodeId) nodeStarts.delete(nodeId);
-
-          const rawOutputs = d.outputs as Array<{ portLabel: string; value: unknown }> | undefined;
-
-          const failed: TimelineEntry = {
-            id: `s-${idCounter++}`,
-            timestamp: new Date(startTs ?? event.timestamp),
-            type: 'node-failed',
-            nodeId,
-            label: (d.label as string) ?? (d.nodeType as string) ?? nodeId ?? 'Node',
-            detail: d.error as string | undefined,
-            duration,
-            color: d.color as string | undefined,
-            icon: d.icon as string | undefined,
-            outputs: rawOutputs && rawOutputs.length > 0 ? rawOutputs : undefined,
-          };
+          completedNodes.add(nodeId);
 
           // Replace the node-started entry in-place
           const existingIdx = nodeEntryIndex.get(nodeId);
           if (existingIdx != null && entries[existingIdx]) {
-            entries[existingIdx] = failed;
+
+            const rawOutputs = d.outputs as Array<{ portLabel: string; value: unknown }> | undefined;
+            entries[existingIdx] = {
+              id: entries[existingIdx]!.id,
+              timestamp: new Date(startTs ?? event.timestamp),
+              type: 'node-failed',
+              nodeId,
+              label: (d.label as string) ?? (d.nodeType as string) ?? nodeId ?? 'Node',
+              detail: d.error as string | undefined,
+              duration,
+              color: d.color as string | undefined,
+              icon: d.icon as string | undefined,
+              outputs: rawOutputs && rawOutputs.length > 0 ? rawOutputs : undefined,
+            };
             nodeEntryIndex.delete(nodeId);
           } else {
-            entries.push(failed);
+            const rawOutputs = d.outputs as Array<{ portLabel: string; value: unknown }> | undefined;
+            entries.push({
+              id: `s-${idCounter++}`,
+              timestamp: new Date(startTs ?? event.timestamp),
+              type: 'node-failed',
+              nodeId,
+              label: (d.label as string) ?? (d.nodeType as string) ?? nodeId ?? 'Node',
+              detail: d.error as string | undefined,
+              duration,
+              color: d.color as string | undefined,
+              icon: d.icon as string | undefined,
+              outputs: rawOutputs && rawOutputs.length > 0 ? rawOutputs : undefined,
+            });
           }
           break;
         }
@@ -204,12 +246,13 @@ export function useStreamTimeline(events: StreamEvent[], isDone: boolean): Strea
   }, [events]);
 
   // Extract metadata from events
-  const { phase, instruction, cost, plan, awaitingApproval } = useMemo(() => {
+  const { phase, instruction, cost, plan, awaitingApproval, report } = useMemo(() => {
     let phase: StreamTimelineState['phase'] = 'idle';
     let instruction: string | null = null;
     let cost: number | null = null;
     let plan: StreamTimelineState['plan'] = null;
     let awaitingApproval = false;
+    let report: string | null = null;
 
     for (const event of events) {
       const d = event.data ?? {};
@@ -221,12 +264,12 @@ export function useStreamTimeline(events: StreamEvent[], isDone: boolean): Strea
         phase = 'executing';
       } else if (event.type === 'bot-completed') {
         phase = (d.success as boolean) ? 'completed' : 'failed';
+        if (typeof d.report === 'string') report = d.report;
       } else if (event.type === 'bot-failed') {
         phase = 'failed';
       } else if (event.type === 'cost-update') {
         cost = (d.totalCost as number) ?? cost;
       } else if (event.type === 'audit:plan-created' || event.type === 'plan-created') {
-        // Plan data may be at d.plan (structured) or directly on d (audit event)
         const planData = (d.plan as Record<string, unknown>) ?? d;
         const summary = (planData.summary as string) ?? '';
         const steps =
@@ -242,11 +285,11 @@ export function useStreamTimeline(events: StreamEvent[], isDone: boolean): Strea
     }
 
     if (isDone && phase !== 'completed' && phase !== 'failed') {
-      phase = 'completed'; // Stream ended but no explicit completion event
+      phase = 'completed';
     }
 
-    return { phase, instruction, cost, plan, awaitingApproval };
+    return { phase, instruction, cost, plan, awaitingApproval, report };
   }, [events, isDone]);
 
-  return { timeline, phase, instruction, elapsed, cost, plan, awaitingApproval };
+  return { timeline, phase, instruction, elapsed, cost, plan, awaitingApproval, report };
 }