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

package/src/bot/capability-registry.ts

@@ -10,7 +10,7 @@ import type { CapabilityDefinition } from './capability-types.js';
 import {
   OP_WRITE_FILE, OP_READ_FILE, OP_PATCH_FILE, OP_LIST_FILES,
   OP_RUN_SHELL, OP_VALIDATE, OP_TSC_CHECK, OP_RUN_TESTS,
-  OP_TASK_CREATE,
+  OP_TASK_CREATE, OP_REMEMBER, OP_RECALL,
 } from './operations.js';
 
 // ---------------------------------------------------------------------------
@@ -67,13 +67,31 @@ Use run_shell for running tests (npx vitest), validation (flow-weaver validate),
 
 const CAP_TASK_MGMT: CapabilityDefinition = {
   name: 'task-mgmt',
-  description: 'Create and manage swarm subtasks for parallel execution.',
+  description: 'Create and manage swarm subtasks for parallel execution, with decomposition and review nudges.',
   tools: [OP_TASK_CREATE],
-  prompt: `## Task Management
-- task_create: Create swarm subtasks for parallel execution. args: { title, description, complexity, subtasks[] }
-- task_list, task_get, task_update: Query and update existing tasks
-
-Use task_create to decompose complex work into smaller, independent subtasks that other bots can execute in parallel.`,
+  prompt: `## Task Management & Decomposition
+
+- task_create: Create swarm subtasks. args: { title, description, complexity, subtasks[], dependsOn[], assignedProfile? }
+
+### Decomposition
+When you encounter a broad objective (multi-file, multi-concern), decompose into subtasks:
+- If the task is bigger than a single file change, create subtasks instead of doing it all yourself.
+- Minimize dependencies between subtasks to maximize parallel execution.
+- Set complexity per subtask: trivial | simple | moderate | complex.
+- Use dependsOn to express blocking relationships (e.g., setup before code, code before tests).
+
+### Review Task Creation
+After creating or modifying multiple files, create a review task:
+- title: "Review: [what was changed]"
+- description: List the files modified and what to check
+- assignedProfile: "reviewer"
+- complexity: "simple"
+Skip review for trivial single-file tasks.
+
+### Dependency Guidelines
+- BAD: A → B → C → D (serial, slow)
+- GOOD: A → [B + C + D] (A blocks all, but B/C/D run in parallel)
+Structure as: setup → independent implementations → integration/testing.`,
 };
 
 const CAP_FW_GRAMMAR: CapabilityDefinition = {
@@ -156,17 +174,41 @@ Note: compile, validate, modify, diff, diagram, and describe operations are avai
 
 const CAP_CODE_REVIEW: CapabilityDefinition = {
   name: 'code-review',
-  description: 'Code review guidelines, quality checklist, and security review patterns.',
-  prompt: `## Code Review
-
-When reviewing code, check for:
-1. Correctness: Does the code do what the task asked?
-2. Security: No hardcoded secrets, no injection vulnerabilities, no exposed APIs
-3. Style: Consistent with project conventions, proper naming, no dead code
-4. Testing: Are there tests? Do they cover edge cases?
-5. Performance: No unnecessary loops, no blocking calls in async code
-
-Report concerns with specific file:line references and suggested fixes.`,
+  description: 'Comprehensive code review with correctness, security, style, testing, and performance checks.',
+  tools: [OP_READ_FILE, OP_PATCH_FILE, OP_RUN_SHELL],
+  prompt: `## Code Review Checklist
+
+### 1. Correctness
+- Does the code do what the task asked?
+- Edge cases handled (empty input, null, invalid types)?
+- Error paths covered (try/catch, validation)?
+- Return types match function signature?
+
+### 2. Security
+- NO hardcoded API keys, passwords, or tokens (use env vars)
+- NO shell: true in child_process (command injection risk)
+- NO eval() or Function() with untrusted input
+- User input validated and sanitized before use
+- File paths validated (no ../ traversal)
+
+### 3. Style
+- Naming is clear and consistent with project conventions
+- No dead code (unused variables, unreachable branches)
+- No debug statements left in (console.log, debugger)
+- Imports organized, no duplicates
+
+### 4. Testing
+- Unit tests exist for new/changed functions
+- Tests cover happy path AND edge cases
+- Error cases have tests
+- Code coverage adequate (aim for 80%+ of changed code)
+
+### 5. Performance
+- No O(n²) loops where O(n) is possible
+- No blocking I/O in async code
+- No memory leaks (listeners removed, timers cleared)
+
+Report findings as: FILE:LINE | SEVERITY (critical/high/medium/low) | ISSUE → Fix suggestion`,
 };
 
 const CAP_WEB: CapabilityDefinition = {
@@ -186,6 +228,134 @@ Use list_files to understand the project structure before making changes.
 The context bundle (when available) provides a snapshot of the workspace.`,
 };
 
+// ---------------------------------------------------------------------------
+// New capabilities — swarm improvements
+// ---------------------------------------------------------------------------
+
+const CAP_VERIFICATION: CapabilityDefinition = {
+  name: 'verification',
+  description: 'Post-write verification: run tsc and tests to catch errors before delivery.',
+  tools: [OP_RUN_SHELL],
+  prompt: `## Verification
+
+After writing or patching code, ALWAYS verify your work:
+1. Run \`npx tsc --noEmit\` in the project root to catch TypeScript errors
+2. If package.json has a "test" script, run \`npm test\` to validate functionality
+3. If verification fails, read the errors, fix the code, and re-verify
+
+Include verification as explicit steps in your plan. Verification is NOT optional.
+Do NOT deliver code that hasn't been verified.`,
+};
+
+const CAP_CROSS_FILE_CHECK: CapabilityDefinition = {
+  name: 'cross-file-check',
+  description: 'Verify imports, exports, module paths, and cross-file dependencies.',
+  tools: [OP_READ_FILE, OP_LIST_FILES, OP_RUN_SHELL],
+  prompt: `## Cross-File Dependency Checks
+
+When modifying code that affects multiple files:
+1. If you rename an export, grep for all imports of it and update them
+2. Verify relative import paths resolve correctly (../types vs ./types)
+3. Check for circular dependencies (A imports B imports A)
+4. If you change a function signature, update all callers
+5. Use \`run_shell\` with grep to search: grep -r "functionName" src/
+
+Do NOT move or rename exports without verifying all dependents.`,
+};
+
+const CAP_PROJECT_SETUP: CapabilityDefinition = {
+  name: 'project-setup',
+  description: 'Initialize new projects with correct structure, config, and dependencies.',
+  tools: [OP_WRITE_FILE, OP_RUN_SHELL],
+  prompt: `## Project Setup
+
+When initializing a project:
+1. Create package.json with name, type: "module", main, scripts (build, test)
+2. Create tsconfig.json with strict: true, module: "esnext", target: "ES2020"
+3. Create standard directories: src/, tests/
+4. Install dependencies with run_shell: npm install <deps>
+5. Create .gitignore excluding node_modules/, dist/
+6. Verify setup: run tsc --noEmit to ensure TypeScript compiles`,
+};
+
+const CAP_SECURITY: CapabilityDefinition = {
+  name: 'security',
+  description: 'Audit code for vulnerabilities, secrets, and security best practices.',
+  tools: [OP_READ_FILE, OP_LIST_FILES, OP_RUN_SHELL],
+  prompt: `## Security Audit
+
+Check for:
+1. **Secrets**: NO hardcoded API keys, passwords, tokens. Use env vars.
+   grep -r "password\\|secret\\|apiKey\\|token" src/ to find leaks.
+2. **Injection**: NO string concatenation in SQL. NO shell: true in child_process. NO eval().
+3. **Dependencies**: Run npm audit to check for known CVEs.
+4. **File paths**: Validate paths to prevent ../ traversal attacks.
+5. **Data handling**: Validate user input (type, length, format). Sanitize before logging.
+
+Report findings with severity: critical | high | medium | low.`,
+};
+
+const CAP_DECOMPOSITION: CapabilityDefinition = {
+  name: 'decomposition',
+  description: 'Break complex objectives into subtask DAGs with dependencies for parallel execution.',
+  tools: [OP_TASK_CREATE],
+  prompt: `## Task Decomposition
+
+When given a large objective, break it into smaller subtasks:
+1. Identify all work items (files, features, tests)
+2. Group by dependency: what must happen first?
+3. Create subtasks with task_create, each focused on one responsibility
+4. Set dependencies with dependsOn to model blocking relationships
+5. Minimize dependencies to maximize parallel execution
+6. Estimate complexity per subtask: trivial | simple | moderate | complex
+
+Example: "Implement auth module"
+- Task A: Extract shared auth types (simple)
+- Task B: Rewrite login endpoint (moderate, depends on A)
+- Task C: Add login tests (moderate, depends on B)
+- Task D: Update auth docs (simple, independent — runs in parallel with B)
+
+Assign profiles: code tasks → developer, review tasks → reviewer, infra → ops.`,
+};
+
+const CAP_ROUTING: CapabilityDefinition = {
+  name: 'routing',
+  description: 'Route tasks to appropriate bot profiles based on capabilities and complexity.',
+  tools: [OP_TASK_CREATE],
+  prompt: `## Task Routing
+
+When creating subtasks, assign the right profile:
+- Code writing, file creation, bug fixes → developer profile
+- Code review, quality checks → reviewer profile
+- Shell commands, project setup, infrastructure → ops profile
+- Leave assignedProfile empty for auto-triage when unsure
+
+Match complexity to profile capabilities:
+- trivial/simple tasks: any profile (prefer cheapest)
+- moderate tasks: specialist profiles
+- complex tasks: profiles with full capability sets`,
+};
+
+const CAP_MEMORY: CapabilityDefinition = {
+  name: 'memory',
+  description: 'Remember and recall project conventions for continuity across sessions.',
+  tools: [OP_REMEMBER, OP_RECALL],
+  prompt: `## Project Memory
+
+Persist project conventions for future sessions:
+- remember: Save a convention. args: { key: "naming", value: "kebab-case for files" }
+- recall: Load all saved conventions. args: {} — returns project memory.
+
+What to remember:
+- Naming conventions (file names, variable names)
+- Architecture decisions (Result pattern, Zod for validation)
+- Test patterns (where tests go, what framework)
+- Common dependencies and their usage
+
+Before planning, recall project memory to follow established patterns.
+When you discover a new convention, remember it for future bots.`,
+};
+
 // ---------------------------------------------------------------------------
 // Registry
 // ---------------------------------------------------------------------------
@@ -203,6 +373,14 @@ export const BUILT_IN_CAPABILITIES: readonly CapabilityDefinition[] = [
   CAP_CODE_REVIEW,
   CAP_WEB,
   CAP_CONTEXT,
+  // Swarm improvement capabilities
+  CAP_VERIFICATION,
+  CAP_CROSS_FILE_CHECK,
+  CAP_PROJECT_SETUP,
+  CAP_SECURITY,
+  CAP_DECOMPOSITION,
+  CAP_ROUTING,
+  CAP_MEMORY,
 ];
 
 const capabilityMap = new Map<string, CapabilityDefinition>(

package/src/bot/dashboard.ts

@@ -326,12 +326,12 @@ export class DashboardServer {
       const pending = tasks.filter(t => t.status === 'pending').length;
       const inProgress = tasks.filter(t => t.status === 'in-progress').length;
       const done = tasks.filter(t => t.status === 'done').length;
-      const failed = tasks.filter(t => t.status === 'failed').length;
+      const cancelled = tasks.filter(t => t.status === 'cancelled').length;
       res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ status: inProgress > 0 ? 'executing' : 'idle', pending, inProgress, done, failed }));
+      res.end(JSON.stringify({ status: inProgress > 0 ? 'executing' : 'idle', pending, inProgress, done, cancelled }));
     }).catch(() => {
       res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ status: 'idle', pending: 0, inProgress: 0, done: 0, failed: 0 }));
+      res.end(JSON.stringify({ status: 'idle', pending: 0, inProgress: 0, done: 0, cancelled: 0 }));
     });
   }
 

package/src/bot/hierarchy-event-log.ts

@@ -0,0 +1,64 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+export interface HierarchyEvent {
+  id: number;
+  parentId: string;
+  type: string;
+  taskId: string;
+  timestamp: number;
+  data?: Record<string, unknown>;
+}
+
+/**
+ * Append-only event log scoped to task hierarchies.
+ *
+ * Events are tagged with `parentId` so sibling tasks can read only
+ * events relevant to their hierarchy. Unrelated task hierarchies
+ * don't see each other's events.
+ *
+ * Writes to `.weaver/hierarchy-events.ndjson`.
+ */
+export class HierarchyEventLog {
+  private readonly filePath: string;
+  private nextId = 0;
+
+  constructor(projectDir: string) {
+    const dir = path.join(projectDir, '.weaver');
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    this.filePath = path.join(dir, 'hierarchy-events.ndjson');
+  }
+
+  /** Append a hierarchy-scoped event. */
+  emit(event: { parentId: string; type: string; taskId: string; data?: Record<string, unknown> }): void {
+    const full: HierarchyEvent = { ...event, id: this.nextId++, timestamp: Date.now() };
+    fs.appendFileSync(this.filePath, JSON.stringify(full) + '\n', 'utf-8');
+  }
+
+  /**
+   * Read events for a specific parent hierarchy, starting from offset.
+   * Only returns events matching the given parentId.
+   */
+  tailByParent(parentId: string, offset = 0): HierarchyEvent[] {
+    if (!fs.existsSync(this.filePath)) return [];
+    const content = fs.readFileSync(this.filePath, 'utf-8');
+    const result: HierarchyEvent[] = [];
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const event = JSON.parse(trimmed) as HierarchyEvent;
+        if (event.parentId === parentId && event.id >= offset) {
+          result.push(event);
+        }
+      } catch { /* skip corrupt line */ }
+    }
+    return result;
+  }
+
+  /** Remove all events. */
+  clear(): void {
+    try { fs.unlinkSync(this.filePath); } catch { /* ok */ }
+    this.nextId = 0;
+  }
+}

package/src/bot/operations.ts

@@ -34,6 +34,13 @@ export const OP_RUN_TESTS = 'run_tests';
 
 export const OP_TASK_CREATE = 'task_create';
 
+// ---------------------------------------------------------------------------
+// Memory
+// ---------------------------------------------------------------------------
+
+export const OP_REMEMBER = 'remember';
+export const OP_RECALL = 'recall';
+
 // ---------------------------------------------------------------------------
 // Passthrough (no execution needed)
 // ---------------------------------------------------------------------------

package/src/bot/profile-store.ts

@@ -230,6 +230,45 @@ const DEFAULT_PROFILES: Record<string, Array<Omit<CreateProfileInput, 'botId'>>>
         },
       },
     },
+    {
+      name: 'Orchestrator',
+      description: 'Decomposes high-level objectives into tasks, assigns profiles, manages dependencies.',
+      icon: 'accountTree',
+      color: 'color-node-purple-icon',
+      capabilities: [
+        { name: 'decomposition', description: 'Break complex objectives into subtask DAGs with dependencies' },
+        { name: 'routing', description: 'Match tasks to the right bot profile based on capabilities' },
+        { name: 'task-mgmt', description: 'Create, prioritize, and manage swarm tasks' },
+      ],
+      preferences: {
+        costStrategy: 'frugal',
+        requireApproval: false,
+        instructions: `You are the orchestrator. Your job is to decompose high-level objectives into concrete, actionable subtasks that other bots can execute.
+
+## Protocol
+1. ANALYZE: Understand the objective. What files, features, and concerns are involved?
+2. DECOMPOSE: Break into subtasks. Each subtask should be completable by a single bot.
+3. ASSIGN: Set assignedProfile per task (developer, reviewer, ops). Set complexity and priority.
+4. DEPENDENCIES: Use dependsOn to model blocking relationships. Minimize deps for parallelism.
+
+## Rules
+- You do NOT write code yourself. You create tasks for other bots.
+- Every subtask needs: title, description, assignedProfile, complexity.
+- Structure as: setup → independent implementations → integration → review.
+- If a task is simple enough (single file, clear scope), don't decompose further.`,
+        behavior: {
+          phases: {
+            plan: { enabled: true, tier: 'fast' as const },
+            execute: { enabled: true, tier: 'fast' as const },
+            review: { enabled: false },
+            validate: { enabled: false },
+            gitOps: { enabled: false },
+          },
+          escalation: { maxAttempts: 2, onExhausted: 'block' as const },
+          exitProtocol: { reportConcerns: false, requireEvidence: false },
+        },
+      },
+    },
   ],
   'weaver-genesis': [
     {

package/src/bot/runner.ts

@@ -255,6 +255,7 @@ export async function runWorkflow(
     const nodeLabels = new Map<string, string>(); // nodeTypeName | instanceId → label
     const nodeVisuals = new Map<string, { color?: string; icon?: string }>(); // nodeTypeName | instanceId → visual meta
     const portLabels = new Map<string, string>(); // "nodeTypeName.portName" → label
+    const portFormats = new Map<string, string>(); // "nodeTypeName.portName" → format hint
     try {
       const parserMod = '@synergenius/flow-weaver';
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -267,8 +268,9 @@ export async function runWorkflow(
         // Extract output port labels: outputs is Record<string, PortConfig>
         if (nt.outputs && typeof nt.outputs === 'object') {
           for (const [portName, portCfg] of Object.entries(nt.outputs)) {
-            const cfg = portCfg as { label?: string } | undefined;
+            const cfg = portCfg as { label?: string; customMetadata?: Record<string, string | boolean | number> } | undefined;
             if (cfg?.label) portLabels.set(`${nt.name}.${portName}`, cfg.label);
+            if (cfg?.customMetadata?.format) portFormats.set(`${nt.name}.${portName}`, String(cfg.customMetadata.format));
           }
         }
       }
@@ -288,7 +290,7 @@ export async function runWorkflow(
     // Track node start times, node types, and outputs so we can attach them on completion.
     const nodeStartTimes = new Map<string, number>();
     const nodeTypes = new Map<string, string>(); // nodeId → nodeTypeName
-    const nodeOutputs = new Map<string, Array<{ portLabel: string; value: unknown }>>();
+    const nodeOutputs = new Map<string, Array<{ portLabel: string; value: unknown; format?: string }>>();
 
     /** Try to parse JSON strings into objects so the UI renders them as structured JSON. */
     function resolveOutputValue(value: unknown): unknown {
@@ -320,9 +322,11 @@ export async function runWorkflow(
           const nodeTypeName = ident.nodeTypeName as string | undefined;
           if (nodeId && portName) {
             if (nodeTypeName) nodeTypes.set(nodeId, nodeTypeName);
-            const label = resolvePortLabel(nodeTypeName ?? nodeTypes.get(nodeId), portName);
+            const resolvedNt = nodeTypeName ?? nodeTypes.get(nodeId);
+            const label = resolvePortLabel(resolvedNt, portName);
+            const format = resolvedNt ? portFormats.get(`${resolvedNt}.${portName}`) : undefined;
             const outputs = nodeOutputs.get(nodeId) ?? [];
-            outputs.push({ portLabel: label, value: resolveOutputValue(traceEvent.data.value) });
+            outputs.push({ portLabel: label, value: resolveOutputValue(traceEvent.data.value), ...(format ? { format } : {}) });
             nodeOutputs.set(nodeId, outputs);
           }
         }

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';
 
@@ -424,6 +424,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,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();
   }