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

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);
@@ -262,8 +262,11 @@ export class TaskStore {
 
       const task = tasks[idx];
 
-      // Append run summary
+      // Append run summary and track runId
       task.context.runSummaries.push(runSummary);
+      if (runSummary.runId && !task.runs.includes(runSummary.runId)) {
+        task.runs.push(runSummary.runId);
+      }
       if (runSummary.outcome === 'failed' || runSummary.outcome === 'error') {
         task.context.lastError = runSummary.error;
       } else {
@@ -276,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();
@@ -284,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;
 
@@ -305,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 {
@@ -348,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.
   }
 
   // ---------------------------------------------------------------------------
@@ -366,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;
     });
@@ -386,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

@@ -14,6 +14,7 @@ import { TaskStore } from '../bot/task-store.js';
  * @input [mainCtx] [order:0] - Context from main path (JSON, optional)
  * @input [readCtx] [order:1] - Context from read-only path (JSON, optional)
  * @input [abortCtx] [order:2] - Context from abort path (JSON, optional)
+ * @input [failCtx] [order:3] - Context from failure paths (exec/plan fail, JSON, optional)
  * @output summary [order:0] - Summary text
  * @output reportJson [order:1] [hidden] - Full report (JSON)
  * @output onFailure [hidden]
@@ -23,8 +24,9 @@ export async function weaverBotReport(
   mainCtx?: string,
   readCtx?: string,
   abortCtx?: string,
+  failCtx?: string,
 ): Promise<{ onSuccess: boolean; onFailure: boolean; summary: string; reportJson: string }> {
-  const ctxStr = mainCtx ?? readCtx ?? abortCtx;
+  const ctxStr = mainCtx ?? readCtx ?? abortCtx ?? failCtx;
 
   if (!execute) {
     const report = { task: {}, path: 'unknown', result: null, filesModified: [], gitResult: null, timestamp: Date.now() };
@@ -66,6 +68,9 @@ export async function weaverBotReport(
   } else if (abortCtx) {
     result = safeJsonParse<ResultShape>(context.resultJson, null);
     pathName = 'abort';
+  } else if (failCtx) {
+    result = safeJsonParse<ResultShape>(context.resultJson, null);
+    pathName = 'failed';
   }
 
   const parts: string[] = [];
@@ -115,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/plan-task.ts

@@ -102,7 +102,11 @@ export async function weaverPlanTask(
   try {
     const mod = await import('../bot/system-prompt.js');
     const basePrompt = mod.buildPromptFromCapabilities(selectedCaps);
-    const botPrompt = mod.buildBotSystemPrompt(context.contextBundle!, undefined, context.env?.projectDir);
+    // Only include the context bundle if the 'context' capability was selected.
+    // This prevents sending 10k+ tokens of FW authoring docs for simple file creation tasks.
+    const selectedCapNames = new Set(selectedCaps.map(c => c.name));
+    const contextBundle = selectedCapNames.has('context') ? context.contextBundle : undefined;
+    const botPrompt = mod.buildBotSystemPrompt(contextBundle, undefined, context.env?.projectDir);
     systemPrompt = basePrompt + '\n\n' + botPrompt;
   } catch (err) {
     if (process.env.WEAVER_VERBOSE) console.error('[plan-task] system prompt build failed:', err);

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;
         }