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

package/src/bot/swarm-controller.ts

@@ -14,6 +14,7 @@ import { TaskStore } from './task-store.js';
 import { BotRegistry } from './bot-registry.js';
 import type { BotRegistration } from './bot-registry.js';
 import { SwarmEventLog } from './swarm-event-log.js';
+import { HierarchyEventLog } from './hierarchy-event-log.js';
 import { RunStore } from './run-store.js';
 import { EventLog } from './event-log.js';
 import { runRegistry } from './run-registry.js';
@@ -93,6 +94,7 @@ export class SwarmController {
   private readonly statePath: string;
   private readonly taskStore: TaskStore;
   private readonly eventLog: SwarmEventLog;
+  private readonly hierarchyEventLog: HierarchyEventLog;
   private readonly orchestrator: Orchestrator;
   private readonly instanceManager: InstanceManager;
   private readonly profileStore: ProfileStore;
@@ -137,6 +139,7 @@ export class SwarmController {
     this.statePath = path.join(this.weaverDir, SWARM_STATE_FILE);
     this.taskStore = new TaskStore(projectDir);
     this.eventLog = new SwarmEventLog(projectDir);
+    this.hierarchyEventLog = new HierarchyEventLog(projectDir);
     this.orchestrator = new Orchestrator({ aiRouter: new AIRouterImpl(projectDir) });
     this.instanceManager = new InstanceManager();
     this.profileStore = new ProfileStore(projectDir);
@@ -313,7 +316,7 @@ export class SwarmController {
         });
       } else {
         await this.taskStore.update(task.id, {
-          status: 'failed',
+          status: 'open',
           currentBotId: undefined,
         });
       }
@@ -426,14 +429,22 @@ export class SwarmController {
         await this._checkSteering(inst.instanceId);
       }
 
+      // Route unassigned tasks to orchestrator profile for decomposition
+      const unassignedTasks = await this.taskStore.list({ status: ['open', 'pending'] });
+      for (const t of unassignedTasks) {
+        if (!t.assignedProfile && !t.isParent) {
+          await this.taskStore.update(t.id, { assignedProfile: 'orchestrator' });
+        }
+      }
+
       // Collect pending tasks (and all tasks for dependency checks)
-      const pendingTasks = await this.taskStore.list({ status: ['pending', 'failed'] });
+      const pendingTasks = await this.taskStore.list({ status: ['open', 'pending'] });
       const allTasks = await this.taskStore.list();
       const routableTasks = pendingTasks.filter((t) => {
         // Skip parent tasks
         if (t.isParent) return false;
         // Skip tasks that have exhausted retries
-        if (t.status === 'failed' && t.attempt >= t.maxAttempts) return false;
+        if (t.attempt >= t.maxAttempts) return false;
         // Skip tasks over per-task budget
         if (t.budgetTokens !== undefined && t.tokensUsed >= t.budgetTokens) return false;
         if (t.budgetCost !== undefined && t.costUsed >= t.budgetCost) return false;
@@ -503,12 +514,40 @@ export class SwarmController {
         }
       }
 
+      // Build file conflict map: which files are being modified by currently executing tasks
+      const activeFiles = new Map<string, string>(); // filepath → taskId
+      for (const [instId] of this.executionPromises) {
+        const inst = this.instanceManager.listAll().find(i => i.instanceId === instId);
+        if (inst?.currentTaskId) {
+          const runningTask = await this.taskStore.get(inst.currentTaskId);
+          if (runningTask?.context.files) {
+            for (const f of runningTask.context.files) {
+              activeFiles.set(f, runningTask.id);
+            }
+          }
+        }
+      }
+
       // Apply assignments
       for (const assignment of output.assignments) {
         const profile = profiles.find((p) => p.id === assignment.profileId);
         const bot = this.profileBotMap.get(assignment.profileId);
         if (!profile || !bot) continue;
 
+        // File conflict check: skip if task targets files currently being modified
+        const candidateTask = routableTasks.find(t => t.id === assignment.taskId);
+        if (candidateTask?.context.files?.length) {
+          const hasFileConflict = candidateTask.context.files.some(f => activeFiles.has(f));
+          if (hasFileConflict) {
+            this.eventLog.emit({
+              type: 'task-skipped',
+              timestamp: Date.now(),
+              data: { taskId: assignment.taskId, reason: 'file-conflict' },
+            });
+            continue; // Skip this assignment, retry next cycle
+          }
+        }
+
         try {
           // Assign task in TaskStore
           await this.taskStore.assignToInstance(assignment.taskId, assignment.instanceId, assignment.profileId);
@@ -668,7 +707,7 @@ export class SwarmController {
     };
 
     // Release task
-    const releaseStatus = result.success ? 'done' : 'failed';
+    const releaseStatus = result.success ? 'done' : 'open';
     await this.taskStore.release(taskId, releaseStatus, runSummary);
 
     // Record token usage
@@ -686,13 +725,31 @@ export class SwarmController {
       this.instanceManager.markIdle(instanceId, result.success);
     } catch { /* instance may have been stopped */ }
 
-    // Emit task event
+    // Emit swarm-level task event
     this.eventLog.emit({
       type: result.success ? 'task-done' : 'task-failed',
       timestamp: Date.now(),
       data: { botId: instanceId, taskId, outcome: runSummary.outcome },
     });
 
+    // Emit hierarchy-scoped event so sibling tasks can see what happened
+    try {
+      const task = await this.taskStore.get(taskId);
+      if (task?.parentId) {
+        this.hierarchyEventLog.emit({
+          parentId: task.parentId,
+          type: result.success ? 'task-completed' : 'task-run-failed',
+          taskId,
+          data: {
+            summary: runSummary.summary,
+            filesModified: runSummary.filesModified,
+            botId: instanceId,
+            attempt: task.attempt,
+          },
+        });
+      }
+    } catch { /* non-fatal — hierarchy events are best-effort */ }
+
     this._syncInstancesState();
     this._persist();
   }

package/src/bot/task-store.ts

@@ -38,7 +38,7 @@ export class TaskStore {
           id: parentId,
           title: input.title,
           description: input.description,
-          status: 'pending',
+          status: 'open',
           priority: input.priority ?? 0,
           isParent: true,
           parentId: input.parentId,
@@ -77,7 +77,7 @@ export class TaskStore {
             id: subId,
             title: sub.title,
             description: sub.description ?? '',
-            status: 'pending',
+            status: 'open',
             priority: sub.priority ?? input.priority ?? 0,
             isParent: false,
             parentId: parentId,
@@ -115,7 +115,7 @@ export class TaskStore {
         id: crypto.randomUUID().slice(0, 8),
         title: input.title,
         description: input.description,
-        status: 'pending',
+        status: 'open',
         priority: input.priority ?? 0,
         isParent: false,
         parentId: input.parentId,
@@ -233,8 +233,8 @@ export class TaskStore {
 
       const task = tasks[idx];
       const assignable =
-        task.status === 'pending' ||
-        (task.status === 'failed' && task.attempt < task.maxAttempts);
+        (task.status === 'open' || task.status === 'pending') &&
+        task.attempt < task.maxAttempts;
       if (!assignable) {
         throw new Error(`Task ${taskId} is not assignable (status: ${task.status}, attempt: ${task.attempt}/${task.maxAttempts})`);
       }
@@ -254,7 +254,7 @@ export class TaskStore {
   // Release
   // ---------------------------------------------------------------------------
 
-  async release(taskId: string, status: 'done' | 'failed', runSummary: RunSummary): Promise<Task> {
+  async release(taskId: string, status: 'done' | 'failed' | 'open', runSummary: RunSummary): Promise<Task> {
     return this.mutex.runExclusive(async () => {
       const tasks = this._readAll();
       const idx = tasks.findIndex(t => t.id === taskId);
@@ -279,7 +279,8 @@ export class TaskStore {
 
       // Update execution tracking
       task.attempt += 1;
-      task.status = status;
+      // Tasks don't fail — runs fail. Map 'failed' to 'open' for backward compat.
+      task.status = status === 'failed' ? 'open' : status;
       task.currentBotId = undefined;
       task.currentRunId = undefined;
       task.updatedAt = new Date().toISOString();
@@ -287,9 +288,7 @@ export class TaskStore {
       if (status === 'done') {
         task.completedAt = new Date().toISOString();
       }
-      if (status === 'failed') {
-        task.completedAt = new Date().toISOString();
-      }
+      // 'open' and 'failed' → task stays open, no completedAt
 
       tasks[idx] = task;
 
@@ -308,28 +307,19 @@ export class TaskStore {
 
   private _handleDependencyEffects(tasks: Task[], changedTask: Task): void {
     if (changedTask.status === 'done') {
-      // Unblock dependents: set blocked tasks to pending if all deps are now done
+      // Unblock dependents: set blocked tasks to open if all deps are now done
       const doneIds = new Set(tasks.filter(t => t.status === 'done').map(t => t.id));
       for (const t of tasks) {
         if (t.status === 'blocked' && t.dependsOn.includes(changedTask.id)) {
           if (t.dependsOn.every(depId => doneIds.has(depId))) {
-            t.status = 'pending';
-            t.updatedAt = new Date().toISOString();
-          }
-        }
-      }
-    } else if (changedTask.status === 'failed') {
-      // Check if failure is terminal (no retries left)
-      if (changedTask.attempt >= changedTask.maxAttempts) {
-        // Block dependents
-        for (const t of tasks) {
-          if (t.status === 'pending' && t.dependsOn.includes(changedTask.id)) {
-            t.status = 'blocked';
+            t.status = 'open';
             t.updatedAt = new Date().toISOString();
           }
         }
       }
     }
+    // Tasks don't fail — runs fail. Dependents stay blocked until dep
+    // succeeds (status=done). No terminal 'failed' state to handle.
   }
 
   private _handleParentEffects(tasks: Task[], changedTask: Task): void {
@@ -351,14 +341,8 @@ export class TaskStore {
       return;
     }
 
-    // Any terminal failure => parent failed
-    const hasTerminalFailure = subtasks.some(
-      s => s.status === 'failed' && s.attempt >= s.maxAttempts,
-    );
-    if (hasTerminalFailure) {
-      parent.status = 'failed';
-      parent.updatedAt = new Date().toISOString();
-    }
+    // Tasks don't fail. Parent stays open until all subtasks are done
+    // or user cancels. No terminal 'failed' state for parent.
   }
 
   // ---------------------------------------------------------------------------
@@ -369,7 +353,7 @@ export class TaskStore {
     return this.mutex.runExclusive(async () => {
       const tasks = this._readAll();
       const before = tasks.length;
-      const kept = tasks.filter(t => t.status !== 'done' && t.status !== 'failed' && t.status !== 'cancelled');
+      const kept = tasks.filter(t => t.status !== 'done' && t.status !== 'cancelled');
       this._writeAll(kept);
       return before - kept.length;
     });
@@ -389,17 +373,17 @@ export class TaskStore {
   // ---------------------------------------------------------------------------
 
   private _findDuplicate(tasks: Task[], title: string, description: string): Task | null {
-    // Check pending duplicates
-    const pendingDup = tasks.find(
-      t => t.status === 'pending' && t.title === title && t.description === description,
+    // Check open/pending duplicates
+    const openDup = tasks.find(
+      t => (t.status === 'open' || t.status === 'pending') && t.title === title && t.description === description,
     );
-    if (pendingDup) return pendingDup;
+    if (openDup) return openDup;
 
-    // Check recently completed/failed (within dedup window)
+    // Check recently completed (within dedup window)
     const now = Date.now();
     const recentDup = tasks.find(
       t =>
-        (t.status === 'done' || t.status === 'failed') &&
+        t.status === 'done' &&
         t.title === title &&
         t.description === description &&
         t.completedAt !== undefined &&

package/src/bot/task-types.ts

@@ -22,7 +22,13 @@ export interface TaskContext {
   lastError?: string;
 }
 
-export type TaskStatus = 'pending' | 'in-progress' | 'blocked' | 'done' | 'failed' | 'cancelled';
+/**
+ * Task status. Tasks NEVER go to 'failed' — runs fail, tasks stay open.
+ * 'open' replaces 'pending'. A task is open until done or cancelled.
+ */
+export type TaskStatus = 'open' | 'pending' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
+// NOTE: 'pending' kept for backward compatibility with existing data.
+// New code should use 'open'. Both are treated as assignable.
 
 export interface Task {
   id: string;

package/src/node-types/bot-report.ts

@@ -120,8 +120,8 @@ export async function weaverBotReport(
   if (task.queueId && context.env?.projectDir) {
     try {
       const store = new TaskStore(context.env.projectDir);
-      await store.update(task.queueId, { status: success ? 'done' : 'failed' });
-      console.log(`\x1b[36m→ Queue task ${task.queueId}: ${success ? 'done' : 'failed'}\x1b[0m`);
+      await store.update(task.queueId, { status: success ? 'done' : 'open' });
+      console.log(`\x1b[36m→ Queue task ${task.queueId}: ${success ? 'done' : 'open'}\x1b[0m`);
     } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[bot-report] queue update failed:', err); }
   }
 

package/src/node-types/build-context.ts

@@ -2,6 +2,7 @@ import { execFileSync } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import type { WeaverContext } from '../bot/types.js';
+import { HierarchyEventLog } from '../bot/hierarchy-event-log.js';
 
 /**
  * Builds the knowledge bundle the AI needs for planning.
@@ -31,6 +32,37 @@ export function weaverBuildContext(ctx: string): { ctx: string } {
     sections.push(...buildFullContext(projectDir, task.mode));
   }
 
+  // Auto-recall project memory (conventions persisted by previous bots)
+  try {
+    const memPath = path.join(projectDir, '.weaver', 'project-memory.json');
+    if (fs.existsSync(memPath)) {
+      const memory = JSON.parse(fs.readFileSync(memPath, 'utf-8')) as Record<string, string>;
+      const entries = Object.entries(memory);
+      if (entries.length > 0) {
+        const memLines = entries.map(([key, value]) => `- **${key}**: ${value}`);
+        sections.push(`## Project Conventions (from memory)\n\nFollow these established patterns:\n${memLines.join('\n')}`);
+      }
+    }
+  } catch { /* non-fatal — memory is best-effort */ }
+
+  // Include sibling context from hierarchy events (previous task completions in same hierarchy)
+  try {
+    const parsedTask = JSON.parse(context.taskJson!) as { parentId?: string };
+    const parentId = parsedTask.parentId;
+    if (parentId) {
+      const hierarchyLog = new HierarchyEventLog(projectDir);
+      const siblingEvents = hierarchyLog.tailByParent(parentId);
+      if (siblingEvents.length > 0) {
+        const siblingLines = siblingEvents.map(e => {
+          const d = e.data ?? {};
+          const files = (d.filesModified as string[])?.join(', ') || 'none';
+          return `- ${e.type}: ${d.summary ?? e.taskId} (files: ${files})`;
+        });
+        sections.push(`## Previous Task Completions\n\nYour sibling tasks in this hierarchy have completed:\n${siblingLines.join('\n')}`);
+      }
+    }
+  } catch { /* non-fatal — sibling context is best-effort */ }
+
   const bundle = sections.join('\n\n---\n\n');
   // Output handled by session renderer; keep a dim line for debugging
   if (process.env.WEAVER_VERBOSE) process.stderr.write(`\x1b[2m  Context: ${bundle.length} chars\x1b[0m\n`);

package/src/node-types/report.ts

@@ -10,18 +10,66 @@ import type { WeaverContext } from '../bot/types.js';
  * @icon summarize
  * @color cyan
  * @input ctx [order:0] - Weaver context (JSON)
- * @output summary [order:0] - Summary string
+ * @output summary [order:0, format:md] - Summary
  * @output onFailure [hidden]
  */
 export function weaverReport(ctx: string): { summary: string } {
   const context = JSON.parse(ctx) as WeaverContext;
   const result = JSON.parse(context.resultJson!);
   const relPath = path.relative(context.env.projectDir, context.targetPath!);
-  const lines = [
-    `Weaver: ${result.outcome} (${relPath})`,
-    result.summary,
-  ];
-  if (result.executionTime) lines.push(`Time: ${result.executionTime}s`);
-  console.log(`\x1b[32m✓ ${lines[0]}\x1b[0m`);
-  return { summary: lines.join('\n') };
+
+  console.log(`\x1b[32m✓ Weaver: ${result.outcome} (${relPath})\x1b[0m`);
+
+  const md: string[] = [];
+  md.push(`## ${result.outcome === 'success' ? 'Task Completed' : 'Task Failed'}`);
+  md.push('');
+  if (result.summary) md.push(result.summary);
+  md.push('');
+
+  // Steps
+  try {
+    const steps = JSON.parse(context.stepLogJson ?? '[]') as Array<{ step: string; status: string; detail?: string }>;
+    if (steps.length > 0) {
+      md.push('### Steps');
+      md.push('');
+      for (const s of steps) {
+        const icon = s.status === 'ok' ? '**ok**' : s.status === 'error' ? '**error**' : '**blocked**';
+        md.push(`- ${s.step} (${icon})${s.detail ? `: ${s.detail}` : ''}`);
+      }
+      md.push('');
+    }
+  } catch { /* skip */ }
+
+  // Files
+  try {
+    const files = JSON.parse(context.filesModified ?? '[]') as string[];
+    if (files.length > 0) {
+      md.push('### Files Modified');
+      md.push('');
+      for (const f of files) md.push(`- \`${f}\``);
+      md.push('');
+    }
+  } catch { /* skip */ }
+
+  // Review
+  try {
+    const review = JSON.parse(context.reviewJson ?? '{}') as Record<string, string>;
+    if (review.intent || review.execution || review.result || review.completeness) {
+      md.push('### Review');
+      md.push('');
+      for (const key of ['intent', 'execution', 'result', 'completeness']) {
+        if (review[key]) md.push(`- **${key}:** ${review[key]}`);
+      }
+      if (review.reason) md.push(`\n${review.reason}`);
+      md.push('');
+    }
+  } catch { /* skip */ }
+
+  // Meta
+  const meta: string[] = [];
+  if (result.executionTime) meta.push(`**Duration:** ${result.executionTime}s`);
+  if (context.env.providerInfo?.model) meta.push(`**Model:** ${context.env.providerInfo.model}`);
+  if (meta.length > 0) md.push(meta.join(' | '));
+
+  return { summary: md.join('\n') };
 }

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

@@ -76,6 +76,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 +98,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 +125,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;
         }