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

package/src/bot/step-executor.ts

@@ -7,7 +7,7 @@ import { promisify } from 'node:util';
 const execAsync = promisify(exec);
 import { runCommand } from '@synergenius/flow-weaver';
 import { BLOCKED_SHELL_PATTERNS } from './safety.js';
-import { OP_WRITE_FILE, OP_READ_FILE, OP_PATCH_FILE, OP_LIST_FILES, OP_RUN_SHELL, OP_TASK_CREATE, OP_RESPOND, OP_NO_OP, OP_NOOP, OP_DONE, OP_COMPLETE, OP_CREATE_WORKFLOW, OP_MODIFY_SOURCE, OP_IMPLEMENT_NODE, normalizeOperation } from './operations.js';
+import { OP_WRITE_FILE, OP_READ_FILE, OP_PATCH_FILE, OP_LIST_FILES, OP_RUN_SHELL, OP_TASK_CREATE, OP_RESPOND, OP_NO_OP, OP_NOOP, OP_DONE, OP_COMPLETE, OP_CREATE_WORKFLOW, OP_MODIFY_SOURCE, OP_IMPLEMENT_NODE, OP_REMEMBER, OP_RECALL, normalizeOperation } from './operations.js';
 import { TaskStore } from './task-store.js';
 import type { CreateTaskInput } from './task-types.js';
 
@@ -398,6 +398,7 @@ export async function executeStep(
       if (!title) return { blocked: true, blockReason: 'task_create requires a "title" argument.' };
 
       const store = new TaskStore(projectDir);
+      const assignedProfile = args.assignedProfile as string | undefined;
       const input: CreateTaskInput = {
         title,
         description: (args.description as string) ?? title,
@@ -405,6 +406,7 @@ export async function executeStep(
         priority: (args.priority as number) ?? 0,
         parentId: args.parentId as string | undefined,
         dependsOn: (args.dependsOn as string[]) ?? [],
+        assignedProfile,
       };
 
       // Support inline subtasks
@@ -415,6 +417,7 @@ export async function executeStep(
           description: (s.description as string) ?? '',
           complexity: (s.complexity as 'trivial' | 'simple' | 'moderate' | 'complex') ?? 'simple',
           priority: (s.priority as number) ?? 0,
+          assignedProfile: (s.assignedProfile as string) ?? assignedProfile ?? 'developer',
         }));
       }
 
@@ -424,6 +427,34 @@ export async function executeStep(
       return { output: `Created task "${title}" (${task.id})${subtasks.length ? ` with ${subtasks.length} subtasks` : ''}. IDs: ${ids.join(', ')}` };
     }
 
+    // -----------------------------------------------------------------
+    // Memory operations — persist/recall project conventions
+    // -----------------------------------------------------------------
+    case OP_REMEMBER: {
+      const key = args.key as string | undefined;
+      if (!key) return { blocked: true, blockReason: 'remember requires a "key" argument.' };
+      const value = (args.value as string) ?? '';
+      const memDir = path.join(projectDir, '.weaver');
+      if (!fs.existsSync(memDir)) fs.mkdirSync(memDir, { recursive: true });
+      const memPath = path.join(memDir, 'project-memory.json');
+      let memory: Record<string, string> = {};
+      try {
+        if (fs.existsSync(memPath)) memory = JSON.parse(fs.readFileSync(memPath, 'utf-8'));
+      } catch { /* start fresh */ }
+      memory[key] = value;
+      fs.writeFileSync(memPath, JSON.stringify(memory, null, 2), 'utf-8');
+      return { output: `Remembered: ${key} = ${value}` };
+    }
+
+    case OP_RECALL: {
+      const memPath = path.join(projectDir, '.weaver', 'project-memory.json');
+      let memory: Record<string, string> = {};
+      try {
+        if (fs.existsSync(memPath)) memory = JSON.parse(fs.readFileSync(memPath, 'utf-8'));
+      } catch { /* no memory yet */ }
+      return { output: JSON.stringify(memory) };
+    }
+
     // -----------------------------------------------------------------
     // Passthrough operations
     // -----------------------------------------------------------------

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,26 @@ export class SwarmController {
         await this._checkSteering(inst.instanceId);
       }
 
+      // Route unassigned tasks: top-level → orchestrator, subtasks → developer (fallback)
+      const unassignedTasks = await this.taskStore.list({ status: ['open', 'pending'] });
+      for (const t of unassignedTasks) {
+        if (!t.assignedProfile && !t.isParent) {
+          // Top-level tasks (no parent) go to orchestrator for decomposition.
+          // Subtasks without a profile default to developer — the orchestrator
+          // should have set assignedProfile, but if it didn't, assume code work.
+          const defaultProfile = t.parentId ? 'developer' : 'orchestrator';
+          await this.taskStore.update(t.id, { assignedProfile: defaultProfile });
+        }
+      }
+
       // 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 +518,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);
@@ -613,7 +656,7 @@ export class SwarmController {
       // Build behavior config from profile preferences, adjusted for task complexity.
       // Trivial tasks get cheaper models and fewer retries; complex tasks are unchanged.
       const baseBehavior: ProfileBehavior = profile.preferences.behavior
-        ?? buildDefaultBehavior(profile.preferences.costStrategy);
+        ?? buildDefaultBehavior(profile.preferences.costStrategy, undefined, profile.id);
       const behavior = adjustBehaviorForComplexity(baseBehavior, task.complexity);
       const behaviorJson = JSON.stringify(behavior);
 
@@ -668,7 +711,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 +729,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/bot/types.ts

@@ -167,6 +167,8 @@ export interface WorkflowResult {
   success: boolean;
   summary: string;
   outcome: string;
+  /** Optional markdown report for rich UI display. */
+  report?: string;
   functionName?: string;
   executionTime?: number;
   cost?: RunCostSummary;
@@ -191,6 +193,8 @@ export interface RunRecord {
   success: boolean;
   outcome: RunOutcome;
   summary: string;
+  /** Optional markdown report for rich UI display. */
+  report?: string;
   functionName?: string;
   executionTime?: number;
   params?: Record<string, unknown>;

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

@@ -16,7 +16,8 @@ import { TaskStore } from '../bot/task-store.js';
  * @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 report [order:1] - Markdown report
+ * @output reportJson [order:2] [hidden] - Full report (JSON)
  * @output onFailure [hidden]
  */
 export async function weaverBotReport(
@@ -25,24 +26,24 @@ export async function weaverBotReport(
   readCtx?: string,
   abortCtx?: string,
   failCtx?: string,
-): Promise<{ onSuccess: boolean; onFailure: boolean; summary: string; reportJson: string }> {
+): Promise<{ onSuccess: boolean; onFailure: boolean; summary: string; report: string; reportJson: string }> {
   const ctxStr = mainCtx ?? readCtx ?? abortCtx ?? failCtx;
 
   if (!execute) {
-    const report = { task: {}, path: 'unknown', result: null, filesModified: [], gitResult: null, timestamp: Date.now() };
-    return { onSuccess: true, onFailure: false, summary: '', reportJson: JSON.stringify(report) };
+    const reportObj = { task: {}, path: 'unknown', result: null, filesModified: [], gitResult: null, timestamp: Date.now() };
+    return { onSuccess: true, onFailure: false, summary: '', report: '', reportJson: JSON.stringify(reportObj) };
   }
   if (!ctxStr) {
-    const report = { task: {}, path: 'no-context', result: null, filesModified: [], gitResult: null, timestamp: Date.now() };
-    return { onSuccess: false, onFailure: true, summary: 'No context received', reportJson: JSON.stringify(report) };
+    const reportObj = { task: {}, path: 'no-context', result: null, filesModified: [], gitResult: null, timestamp: Date.now() };
+    return { onSuccess: false, onFailure: true, summary: 'No context received', report: '', reportJson: JSON.stringify(reportObj) };
   }
 
   let context: WeaverContext;
   try {
     context = JSON.parse(ctxStr) as WeaverContext;
   } catch {
-    const report = { task: {}, path: 'parse-error', result: null, filesModified: [], gitResult: null, timestamp: Date.now() };
-    return { onSuccess: false, onFailure: true, summary: 'Failed to parse context', reportJson: JSON.stringify(report) };
+    const reportObj = { task: {}, path: 'parse-error', result: null, filesModified: [], gitResult: null, timestamp: Date.now() };
+    return { onSuccess: false, onFailure: true, summary: 'Failed to parse context', report: '', reportJson: JSON.stringify(reportObj) };
   }
 
   const safeJsonParse = <T>(str: string | undefined, fallback: T): T => {
@@ -120,12 +121,12 @@ 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); }
   }
 
-  const report = {
+  const reportObj = {
     task,
     path: pathName,
     result,
@@ -134,7 +135,57 @@ export async function weaverBotReport(
     timestamp: Date.now(),
   };
 
+  // Build markdown report
+  const md: string[] = [];
+  md.push(`## ${success ? 'Task Completed' : 'Task Failed'}`);
+  md.push('');
+  if (result?.summary) md.push(result.summary);
+  if (!reviewPassed && reviewReason) md.push(`\n> Review: ${reviewReason}`);
+  md.push('');
+
+  // Steps
+  const stepLog = safeJsonParse<Array<{ step: string; status: string; detail?: string }>>(context.stepLogJson, []);
+  if (stepLog.length > 0) {
+    md.push('### Steps');
+    md.push('');
+    for (const s of stepLog) {
+      const icon = s.status === 'ok' ? '**ok**' : s.status === 'error' ? '**error**' : '**blocked**';
+      md.push(`- ${s.step} (${icon})${s.detail ? `: ${s.detail}` : ''}`);
+    }
+    md.push('');
+  }
+
+  // Files
+  if (files.length > 0) {
+    md.push('### Files Modified');
+    md.push('');
+    for (const f of files) md.push(`- \`${f}\``);
+    md.push('');
+  }
+
+  // Review
+  if (context.reviewJson) {
+    const review = safeJsonParse<Record<string, string>>(context.reviewJson, {});
+    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('');
+    }
+  }
+
+  // Git
+  if (gitResult && !gitResult.skipped) {
+    md.push('### Git');
+    md.push('');
+    md.push('Changes committed');
+    md.push('');
+  }
+
   console.log(`\n\x1b[1m${success ? '\x1b[32m' : '\x1b[31m'}Bot Report: ${summary}\x1b[0m\n`);
 
-  return { onSuccess: success, onFailure: !success, summary, reportJson: JSON.stringify(report) };
+  return { onSuccess: success, onFailure: !success, summary, report: md.join('\n'), reportJson: JSON.stringify(reportObj) };
 }

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

@@ -11,17 +11,69 @@ import type { WeaverContext } from '../bot/types.js';
  * @color cyan
  * @input ctx [order:0] - Weaver context (JSON)
  * @output summary [order:0] - Summary string
+ * @output report [order:1] - Markdown report
  * @output onFailure [hidden]
  */
-export function weaverReport(ctx: string): { summary: string } {
+export function weaverReport(ctx: string): { summary: string; report: 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') };
+
+  // Plain one-liner for notifications, task lists, logs
+  const summaryLine = `Weaver: ${result.outcome} (${relPath})${result.summary ? ' — ' + result.summary : ''}`;
+  console.log(`\x1b[32m✓ ${summaryLine}\x1b[0m`);
+
+  // Markdown report for rich UI display
+  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: summaryLine, report: md.join('\n') };
 }

package/src/ui/task-detail-view.tsx

@@ -281,6 +281,7 @@ function TaskDetailView({ taskId, onBack, onEdit }: TaskDetailViewProps) {
     cost: liveCost,
     plan,
     awaitingApproval,
+    report: liveReport,
   } = useStreamTimeline(stream.events, stream.isDone);
 
   const currentRunId = task?.currentRunId;
@@ -616,6 +617,7 @@ function TaskDetailView({ taskId, onBack, onEdit }: TaskDetailViewProps) {
                   state: isSuccess ? 'completed' : 'failed',
                   instruction: extractInstruction(run),
                   timeline: runTimeline,
+                  report: run.report ?? null,
                   cost: typeof run.cost === 'number' ? run.cost : ((run.costDetail?.totalCost as number) ?? null),
                   plan: run.plan,
                   startedAt: run.startedAt,
@@ -630,6 +632,7 @@ function TaskDetailView({ taskId, onBack, onEdit }: TaskDetailViewProps) {
                 state: 'running',
                 instruction: liveInstruction ?? task.title,
                 timeline: liveTimeline,
+                report: liveReport,
                 phase: livePhase,
                 elapsed,
                 cost: liveCost,