@synergenius/flow-weaver-pack-weaver 0.9.0 → 0.9.4

package/src/node-types/exec-validate-retry.ts

@@ -1,8 +1,8 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
-import type { WeaverContext } from '../bot/types.js';
-import { callAI, parseJsonResponse } from '../bot/ai-client.js';
+import type { WeaverContext, StepLogEntry } from '../bot/types.js';
+import { callAI, parseJsonResponse, normalizePlan } from '../bot/ai-client.js';
 import { executeStep } from '../bot/step-executor.js';
 import { validateFiles } from '../bot/file-validator.js';
 import { auditEmit } from '../bot/audit-logger.js';
@@ -38,19 +38,29 @@ export async function weaverExecValidateRetry(
 
   const { providerInfo: pInfo, projectDir } = env;
   const maxAttempts = 3;
+  const taskDeadline = Date.now() + 180_000; // 3 minute max per task
   let currentPlan = JSON.parse(context.planJson!);
   let allFilesModified: string[] = [];
+  let allStepLog: StepLogEntry[] = [];
   let lastExecResult: Record<string, unknown> = {};
   let lastValidation: Array<{ file: string; valid: boolean; errors: string[] }> = [];
   let allValid = false;
+  let prevErrorCount = Infinity;
 
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    // Task timeout — stop if we've exceeded the deadline
+    if (Date.now() > taskDeadline) {
+      console.error('\x1b[33m→ Task timeout (3 min), moving on\x1b[0m');
+      break;
+    }
+
     console.log(`\x1b[36m→ Attempt ${attempt}/${maxAttempts}\x1b[0m`);
     auditEmit('step-start', { attempt, stepCount: currentPlan.steps?.length });
 
     const execResult = await executePlanSteps(currentPlan, projectDir);
     lastExecResult = execResult;
     allFilesModified = [...new Set([...allFilesModified, ...execResult.filesModified])];
+    allStepLog.push(...execResult.stepLog);
     auditEmit('step-complete', { attempt, filesModified: execResult.filesModified, errors: execResult.errors });
 
     const validation = await validateFiles(execResult.filesModified, projectDir);
@@ -59,6 +69,13 @@ export async function weaverExecValidateRetry(
     const errorCount = validation.filter(v => !v.valid).length;
     auditEmit('validation-run', { attempt, allValid, errorCount });
 
+    // Stop retrying if errors didn't decrease — AI is stuck
+    if (attempt > 1 && errorCount >= prevErrorCount) {
+      console.error(`\x1b[33m→ Errors not decreasing (${errorCount} >= ${prevErrorCount}), stopping retry\x1b[0m`);
+      break;
+    }
+    prevErrorCount = errorCount;
+
     // Collect design warnings from valid files
     const designWarnings = validation
       .filter(v => v.valid && v.warnings.length > 0)
@@ -97,16 +114,23 @@ export async function weaverExecValidateRetry(
         try {
           const mod = await import('../bot/system-prompt.js');
           systemPrompt = await mod.buildSystemPrompt();
-        } catch {
+        } catch (err) {
+          if (process.env.WEAVER_VERBOSE) console.error('[exec-validate-retry] system prompt build failed:', err);
           systemPrompt = 'You are Weaver. Return ONLY valid JSON.';
         }
 
-        const fixPrompt = `The following validation errors occurred:\n${errors}\n\nProvide a fix plan as JSON with steps and summary.`;
+        // Include step outputs so the AI has context from discovery steps
+        const outputContext = Object.entries(execResult.stepOutputs)
+          .map(([id, out]) => `--- Output of ${id} ---\n${out}`)
+          .join('\n\n');
+
+        const fixPrompt = `The following validation errors occurred:\n${errors}\n\n${outputContext ? `Discovery step outputs:\n${outputContext}\n\n` : ''}Provide a CONCRETE fix plan. Every patch-file step MUST include "file" (absolute path from the outputs above) and "patches" array with exact "find"/"replace" strings. Do NOT use placeholders.`;
 
         const text = await callAI(pInfo, systemPrompt, fixPrompt, 8192);
 
-        currentPlan = parseJsonResponse(text);
-        console.log(`\x1b[36m→ Fix plan: ${(currentPlan as { summary?: string }).summary ?? 'generated'}\x1b[0m`);
+        const parsed = parseJsonResponse(text);
+        currentPlan = normalizePlan(parsed);
+        console.log(`\x1b[36m→ Fix plan: ${currentPlan.summary} (${currentPlan.steps.length} steps)\x1b[0m`);
       } catch (err: unknown) {
         const msg = err instanceof Error ? err.message : String(err);
         console.error(`\x1b[31m→ Fix planning failed: ${msg}\x1b[0m`);
@@ -118,6 +142,7 @@ export async function weaverExecValidateRetry(
   context.resultJson = JSON.stringify(lastExecResult);
   context.validationResultJson = JSON.stringify(lastValidation);
   context.filesModified = JSON.stringify(allFilesModified);
+  context.stepLogJson = JSON.stringify(allStepLog);
   context.allValid = allValid;
 
   return { onSuccess: allValid, onFailure: !allValid, ctx: JSON.stringify(context) };
@@ -126,9 +151,11 @@ export async function weaverExecValidateRetry(
 async function executePlanSteps(
   plan: { steps: Array<{ id: string; operation: string; description: string; args: Record<string, unknown> }> },
   projectDir: string,
-): Promise<{ success: boolean; filesModified: string[]; errors: string[]; stepsCompleted: number; stepsTotal: number }> {
+): Promise<{ success: boolean; filesModified: string[]; errors: string[]; stepsCompleted: number; stepsTotal: number; stepLog: StepLogEntry[]; stepOutputs: Record<string, string> }> {
   const filesModified: string[] = [];
   const errors: string[] = [];
+  const stepLog: StepLogEntry[] = [];
+  const stepOutputs: Record<string, string> = {};
   let completed = 0;
   const steps = plan.steps ?? [];
 
@@ -136,23 +163,35 @@ async function executePlanSteps(
     const steering = checkSteeringSignal();
     if (steering === 'cancel') {
       errors.push(`Cancelled at step ${step.id}`);
+      stepLog.push({ step: step.id, status: 'error', detail: 'Cancelled by steering signal' });
       break;
     }
 
     try {
       const result = await executeStep(step, projectDir);
+      if (result.blocked) {
+        console.error(`\x1b[33m  ⚠ ${step.id}: ${result.blockReason}\x1b[0m`);
+        stepLog.push({ step: step.id, status: 'blocked', detail: result.blockReason });
+        continue;
+      }
       if (result.file) filesModified.push(result.file);
       if (result.files) filesModified.push(...result.files);
+      // Capture step output for feeding into fix prompts
+      if (result.output) {
+        stepOutputs[step.id] = result.output.slice(0, 4000); // cap at 4k to fit in prompt
+      }
       completed++;
       console.log(`\x1b[32m  + ${step.id}: ${step.description}\x1b[0m`);
+      stepLog.push({ step: step.id, status: 'ok', detail: step.description });
     } catch (err: unknown) {
       const msg = err instanceof Error ? err.message : String(err);
       errors.push(`${step.id}: ${msg}`);
       console.error(`\x1b[31m  x ${step.id}: ${msg}\x1b[0m`);
+      stepLog.push({ step: step.id, status: 'error', detail: msg });
     }
   }
 
-  return { success: errors.length === 0, filesModified: [...new Set(filesModified)], errors, stepsCompleted: completed, stepsTotal: steps.length };
+  return { success: errors.length === 0, filesModified: [...new Set(filesModified)], errors, stepsCompleted: completed, stepsTotal: steps.length, stepLog, stepOutputs };
 }
 
 function checkSteeringSignal(): 'cancel' | null {

package/src/node-types/execute-plan.ts

@@ -2,7 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import type { WeaverEnv } from '../bot/types.js';
-import { executeStep } from '../bot/step-executor.js';
+import { executeStep, resetPlanFileCounter } from '../bot/step-executor.js';
 
 /**
  * Executes plan steps via the flow-weaver CLI. Checks steering
@@ -39,6 +39,7 @@ export async function weaverExecutePlan(
   }
 
   const { projectDir } = env;
+  resetPlanFileCounter(); // Reset per-plan write counter for safety guards
   const plan = JSON.parse(planJson) as { steps: Array<{ id: string; operation: string; description: string; args: Record<string, unknown> }> };
   const filesModified: string[] = [];
   const filesCreated: string[] = [];
@@ -55,10 +56,27 @@ export async function weaverExecutePlan(
     };
   }
 
-  for (const step of plan.steps) {
+  for (let i = 0; i < plan.steps.length; i++) {
+    const step = plan.steps[i];
+    // Defensive: ensure step has required fields
+    if (!step || typeof step !== 'object') {
+      errors.push(`step-${i + 1}: Malformed step (not an object)`);
+      continue;
+    }
+    const stepId = step.id ?? `step-${i + 1}`;
+    const stepDesc = step.description ?? step.operation ?? 'unknown';
+    if (!step.operation) {
+      errors.push(`${stepId}: Missing "operation" field`);
+      console.error(`\x1b[31m  x ${stepId}: Missing operation\x1b[0m`);
+      continue;
+    }
+    if (!step.args) {
+      step.args = {};
+    }
+
     const steering = checkSteering();
     if (steering === 'cancel') {
-      output.push(`Cancelled at step ${step.id}`);
+      output.push(`Cancelled at ${stepId}`);
       break;
     }
     if (steering === 'pause') {
@@ -68,18 +86,24 @@ export async function weaverExecutePlan(
 
     try {
       const result = await executeStep(step, projectDir);
+      if (result.blocked) {
+        errors.push(`${stepId}: BLOCKED - ${result.blockReason}`);
+        output.push(`${stepId}: BLOCKED - ${result.blockReason}`);
+        console.error(`\x1b[33m  ⚠ ${stepId}: ${result.blockReason}\x1b[0m`);
+        continue;
+      }
       if (result.file) {
         if (result.created) filesCreated.push(result.file);
         else filesModified.push(result.file);
       }
       completed++;
-      output.push(`${step.id}: ${step.description} - done`);
-      console.log(`\x1b[32m  + ${step.id}: ${step.description}\x1b[0m`);
+      output.push(`${stepId}: ${stepDesc} - done`);
+      console.log(`\x1b[32m  + ${stepId}: ${stepDesc}\x1b[0m`);
     } catch (err: unknown) {
       const msg = err instanceof Error ? err.message : String(err);
-      errors.push(`${step.id}: ${msg}`);
-      output.push(`${step.id}: FAILED - ${msg}`);
-      console.error(`\x1b[31m  x ${step.id}: ${msg}\x1b[0m`);
+      errors.push(`${stepId}: ${msg}`);
+      output.push(`${stepId}: FAILED - ${msg}`);
+      console.error(`\x1b[31m  x ${stepId}: ${msg}\x1b[0m`);
     }
   }
 

package/src/node-types/execute-target.ts

@@ -137,7 +137,8 @@ When stabilize mode is active, only fix-up operations are allowed: removeNode, r
 ## Response Format
 
 Return ONLY valid JSON. No markdown, no code fences, no explanation outside the JSON structure.`;
-  } catch {
+  } catch (err) {
+    if (process.env.WEAVER_VERBOSE) console.error('[execute-target] prompt build failed:', err);
     return FALLBACK;
   }
 }

package/src/node-types/fix-errors.ts

@@ -1,5 +1,5 @@
 import type { WeaverEnv } from '../bot/types.js';
-import { callAI, parseJsonResponse } from '../bot/ai-client.js';
+import { callAI, parseJsonResponse, normalizePlan } from '../bot/ai-client.js';
 
 /**
  * When validation fails, sends errors + context to the AI and
@@ -42,18 +42,33 @@ export async function weaverFixErrors(
   try {
     const mod = await import('../bot/system-prompt.js');
     systemPrompt = await mod.buildSystemPrompt();
-  } catch {
+  } catch (err) {
+    if (process.env.WEAVER_VERBOSE) console.error('[fix-errors] system prompt build failed:', err);
     systemPrompt = 'You are Weaver. Return ONLY valid JSON.';
   }
 
   const errorSummary = errors.map(e => `${e.file}: ${e.errors.join(', ')}`).join('\n');
-  const userPrompt = `The following validation errors occurred:\n${errorSummary}\n\nProvide a fix plan as JSON with "steps" and "summary". Each step needs "id", "operation", "description", and "args".`;
+  const userPrompt = `The following validation errors occurred:
+${errorSummary}
+
+Provide a fix plan as JSON: {"steps": [...], "summary": "..."}
+
+Each step MUST have: "id" (string), "operation" (string), "description" (string), "args" (object).
+
+Available operations for fixes:
+- patch-file: Surgical find-and-replace. args: { "file": "path", "patches": [{ "find": "old text", "replace": "new text" }] }
+  PREFERRED for fixing @input annotations. Example: { "find": "@input portName", "replace": "@input [portName]" }
+- run-shell: Execute a command. args: { "command": "..." }
+- read-file: Read file content. args: { "file": "path" }
+
+Return ONLY valid JSON. No explanation outside the JSON.`;
 
   try {
     const text = await callAI(pInfo, systemPrompt, userPrompt, 8192);
 
-    const plan = parseJsonResponse(text);
-    console.log(`\x1b[36m→ Fix plan: ${(plan as { summary?: string }).summary ?? 'generated'}\x1b[0m`);
+    const parsed = parseJsonResponse(text);
+    const plan = normalizePlan(parsed);
+    console.log(`\x1b[36m→ Fix plan: ${plan.summary} (${plan.steps.length} steps)\x1b[0m`);
     return { onSuccess: true, onFailure: false, env, taskJson, fixPlanJson: JSON.stringify(plan) };
   } catch (err: unknown) {
     const msg = err instanceof Error ? err.message : String(err);

package/src/node-types/genesis-observe.ts

@@ -77,8 +77,9 @@ export async function genesisObserve(
       gitCommit = execFileSync('git', ['rev-parse', 'HEAD'], {
         cwd: projectDir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
       }).trim();
-    } catch {
+    } catch (err) {
       // Not a git repo or git unavailable
+      if (process.env.WEAVER_VERBOSE) console.error('[genesis-observe] git unavailable:', err);
     }
 
     const existingWorkflows: string[] = [];

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

@@ -34,7 +34,7 @@ export function genesisReport(successCtx?: string, failCtx?: string, proposeFail
       try {
         const result = JSON.parse(context.applyResultJson) as { applied: number; failed: number };
         summary += ` (applied: ${result.applied}, failed: ${result.failed})`;
-      } catch { /* ignore */ }
+      } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[genesis-report] applyResultJson parse failed:', err); }
     }
     summary += elapsed ? ` [${elapsed}]` : '';
     console.log(`\n\x1b[31m${summary}\x1b[0m\n`);

package/src/node-types/git-ops.ts

@@ -1,7 +1,62 @@
 import { execFileSync } from 'node:child_process';
+import * as path from 'node:path';
 import type { WeaverContext } from '../bot/types.js';
 import { auditEmit } from '../bot/audit-logger.js';
 
+/**
+ * Review staged diff for suspicious changes before committing.
+ * Returns an array of issues found (empty = safe to commit).
+ */
+function reviewStagedDiff(cwd: string): string[] {
+  const issues: string[] = [];
+
+  try {
+    const diff = execFileSync('git', ['diff', '--cached', '--stat'], { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    if (!diff) return issues;
+
+    // Check for large deletions (file became empty or nearly empty)
+    const numstat = execFileSync('git', ['diff', '--cached', '--numstat'], { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    for (const line of numstat.split('\n').filter(Boolean)) {
+      const [added, deleted, file] = line.split('\t');
+      if (!file || !added || !deleted) continue;
+      const addedN = parseInt(added, 10) || 0;
+      const deletedN = parseInt(deleted, 10) || 0;
+
+      // Flag: file lost >80% of its content with minimal additions
+      if (deletedN > 50 && addedN < 5 && deletedN > addedN * 10) {
+        issues.push(`${file}: deleted ${deletedN} lines, added only ${addedN} (possible truncation)`);
+      }
+
+      // Flag: file became empty (0 additions, all deletions)
+      if (addedN === 0 && deletedN > 10) {
+        issues.push(`${file}: file emptied (${deletedN} lines deleted, 0 added)`);
+      }
+    }
+
+    // Check for sensitive patterns in added lines
+    const patchDiff = execFileSync('git', ['diff', '--cached', '-U0'], { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+    const sensitivePatterns = [
+      /api[_-]?key\s*[:=]\s*["'][^"']{20,}/i,
+      /secret\s*[:=]\s*["'][^"']{10,}/i,
+      /password\s*[:=]\s*["'][^"']{5,}/i,
+    ];
+    for (const line of patchDiff.split('\n')) {
+      if (!line.startsWith('+') || line.startsWith('+++')) continue;
+      for (const pattern of sensitivePatterns) {
+        if (pattern.test(line)) {
+          issues.push('Possible credential/secret in staged changes');
+          return issues; // One is enough to block
+        }
+      }
+    }
+  } catch (err) {
+    // If diff commands fail, don't block — let commit proceed
+    if (process.env.WEAVER_VERBOSE) console.error('[git-ops] diff review failed:', err);
+  }
+
+  return issues;
+}
+
 /**
  * Git operations on created/modified files: stage, commit, branch.
  * Runs in parallel with notifications after execution.
@@ -48,25 +103,59 @@ export function weaverGitOps(ctx: string): { ctx: string } {
     }
   }
 
-  // Stage files
+  // Get actually-changed files from git (avoids phantom commits)
+  let changedFiles: Set<string>;
+  try {
+    const diff = execFileSync('git', ['diff', '--name-only'], { cwd: projectDir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    const untracked = execFileSync('git', ['ls-files', '--others', '--exclude-standard'], { cwd: projectDir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    changedFiles = new Set([...diff.split('\n'), ...untracked.split('\n')].filter(Boolean));
+  } catch (err) {
+    if (process.env.WEAVER_VERBOSE) console.error('[git-ops] git diff failed, using filesModified fallback:', err);
+    changedFiles = new Set(files); // fallback: trust filesModified
+  }
+
+  // Stage only files that are both in filesModified AND actually changed
+  let staged = 0;
   for (const file of files) {
+    // Resolve to relative path for comparison
+    const relative = path.relative(projectDir, path.resolve(projectDir, file));
+    if (!changedFiles.has(relative) && !changedFiles.has(file)) continue;
     try {
       execFileSync('git', ['add', file], { cwd: projectDir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+      staged++;
     } catch { /* ignore unstaged files */ }
   }
 
+  if (staged === 0) {
+    results.push('No actual changes to commit');
+    auditEmit('git-operation', { branch: gitConfig.branch, filesCount: 0, results });
+    context.gitResultJson = JSON.stringify({ skipped: true, reason: 'no actual changes', results });
+    return { ctx: JSON.stringify(context) };
+  }
+
+  // Diff review: check for suspicious changes before committing
+  const diffIssues = reviewStagedDiff(projectDir);
+  if (diffIssues.length > 0) {
+    // Unstage and skip commit — something looks wrong
+    try { execFileSync('git', ['reset', 'HEAD'], { cwd: projectDir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }); } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[git-ops] reset failed:', err); }
+    results.push(`Commit blocked: ${diffIssues.join('; ')}`);
+    auditEmit('git-operation', { branch: gitConfig.branch, filesCount: 0, results, blocked: true });
+    context.gitResultJson = JSON.stringify({ skipped: true, reason: 'diff review failed', issues: diffIssues, results });
+    return { ctx: JSON.stringify(context) };
+  }
+
   // Commit
   const prefix = gitConfig.commitPrefix ?? 'weaver:';
-  const commitMsg = `${prefix} bot task (${files.length} file${files.length === 1 ? '' : 's'})`;
+  const commitMsg = `${prefix} bot task (${staged} file${staged === 1 ? '' : 's'})`;
   try {
     execFileSync('git', ['commit', '-m', commitMsg], { cwd: projectDir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
     results.push(`Committed: ${commitMsg}`);
-    console.log(`\x1b[36m→ Git: ${commitMsg}\x1b[0m`);
+    if (process.env.WEAVER_VERBOSE) process.stderr.write(`\x1b[2m  Git: ${commitMsg}\x1b[0m\n`);
   } catch {
     results.push('Nothing to commit');
   }
 
-  auditEmit('git-operation', { branch: gitConfig.branch, filesCount: files.length, results });
+  auditEmit('git-operation', { branch: gitConfig.branch, filesCount: staged, results });
   context.gitResultJson = JSON.stringify({ skipped: false, results });
   return { ctx: JSON.stringify(context) };
 }

package/src/node-types/index.ts

@@ -17,6 +17,8 @@ export { weaverValidateResult } from './validate-result.js';
 export { weaverFixErrors } from './fix-errors.js';
 export { weaverGitOps } from './git-ops.js';
 export { weaverBotReport } from './bot-report.js';
+export { weaverAgentExecute } from './agent-execute.js';
+export { weaverValidateGate } from './validate-gate.js';
 export { genesisLoadConfig } from './genesis-load-config.js';
 export { genesisObserve } from './genesis-observe.js';
 export { genesisDiffFingerprint } from './genesis-diff-fingerprint.js';

package/src/node-types/load-config.ts

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import type { WeaverConfig } from '../bot/types.js';
+import type { BotConfig } from '../bot/types.js';
 
 /**
  * Read .weaver.json, merge with defaults, and output the config object.
@@ -13,10 +13,10 @@ import type { WeaverConfig } from '../bot/types.js';
  * @output config [order:1] - Weaver configuration
  * @output onFailure [hidden]
  */
-export function weaverLoadConfig(projectDir?: string): { projectDir: string; config: WeaverConfig } {
+export function weaverLoadConfig(projectDir?: string): { projectDir: string; config: BotConfig } {
   const dir = projectDir || process.cwd();
   const configPath = path.join(dir, '.weaver.json');
-  let config: WeaverConfig = { provider: 'auto' };
+  let config: BotConfig = { provider: 'auto' };
   if (fs.existsSync(configPath)) {
     config = { ...config, ...JSON.parse(fs.readFileSync(configPath, 'utf-8')) };
     console.log(`\x1b[36m→ Loaded config from ${configPath}\x1b[0m`);

package/src/node-types/plan-task.ts

@@ -29,7 +29,12 @@ export async function weaverPlanTask(
   }
 
   const { providerInfo: pInfo } = env;
-  const task = JSON.parse(context.taskJson!);
+
+  if (!context.taskJson) {
+    context.planJson = JSON.stringify({ steps: [], summary: 'Planning failed: missing taskJson' });
+    return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };
+  }
+  const task = JSON.parse(context.taskJson);
 
   let systemPrompt: string;
   try {
@@ -42,11 +47,18 @@ export async function weaverPlanTask(
     } catch { /* older flow-weaver version */ }
     const botPrompt = mod.buildBotSystemPrompt(context.contextBundle!, cliCommands);
     systemPrompt = basePrompt + '\n\n' + botPrompt;
-  } catch {
+  } catch (err) {
+    if (process.env.WEAVER_VERBOSE) console.error('[plan-task] system prompt build failed:', err);
     systemPrompt = 'You are Weaver, an AI workflow bot. Return ONLY valid JSON with a plan.';
   }
 
-  const userPrompt = `Task: ${task.instruction}\nMode: ${task.mode ?? 'create'}\n${task.targets ? 'Targets: ' + task.targets.join(', ') : ''}\n\nPlan this task. Return a JSON plan with steps and summary.`;
+  const userPrompt = `Task: ${task.instruction}\nMode: ${task.mode ?? 'create'}\n${task.targets ? 'Targets: ' + task.targets.join(', ') : ''}
+
+Plan this task. IMPORTANT rules:
+1. Every step MUST have complete, concrete args — no empty patches, no placeholders.
+2. If you need to discover file contents or errors before fixing, plan ONLY the discovery steps (run-shell, read-file, list-files) in this first plan. The system will automatically provide a second planning round with actual errors if validation fails.
+3. Do NOT plan patch-file steps unless you already know the exact find/replace strings.
+4. Prefer run-shell with "npx flow-weaver validate <file> --json" to discover errors, then read-file to see the file, then patch-file with exact strings.`;
 
   try {
     const text = await callAI(pInfo, systemPrompt, userPrompt, 8192);

package/src/node-types/read-workflow.ts

@@ -47,7 +47,7 @@ export function weaverReadWorkflow(ctx: string): { ctx: string } {
         timeout: 30_000,
         cwd: projectDir,
       }).trim();
-    } catch { /* diagram generation failed, continue without it */ }
+    } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[read-workflow] diagram failed:', err); }
 
     try {
       description = execFileSync('flow-weaver', ['describe', filePath], {
@@ -56,7 +56,7 @@ export function weaverReadWorkflow(ctx: string): { ctx: string } {
         timeout: 30_000,
         cwd: projectDir,
       }).trim();
-    } catch { /* description failed, continue without it */ }
+    } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[read-workflow] describe failed:', err); }
 
     results.push({ file: target, source, diagram, description });
     console.log(`\x1b[36m→ Read: ${target}\x1b[0m`);

package/src/node-types/receive-task.ts

@@ -2,6 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import type { WeaverEnv, WeaverContext } from '../bot/types.js';
+import { withFileLock } from '../bot/file-lock.js';
 
 interface QueuedTask {
   id: string;
@@ -54,38 +55,42 @@ export async function weaverReceiveTask(
     } catch { /* fall through to queue check */ }
   }
 
-  // Check task queue
+  // Check task queue (with file locking to prevent race conditions)
   const queuePath = path.join(os.homedir(), '.weaver', 'task-queue.ndjson');
   try {
-    if (fs.existsSync(queuePath)) {
+    const claimed = await withFileLock(queuePath, () => {
+      if (!fs.existsSync(queuePath)) return null;
       const content = fs.readFileSync(queuePath, 'utf-8').trim();
-      if (content) {
-        const tasks: QueuedTask[] = content.split('\n').map(l => JSON.parse(l));
-        const pending = tasks
-          .filter(t => t.status === 'pending')
-          .sort((a, b) => b.priority - a.priority || a.addedAt - b.addedAt);
+      if (!content) return null;
 
-        if (pending.length > 0) {
-          const task = pending[0]!;
-          // Mark as running
-          const updated = tasks.map(t => t.id === task.id ? { ...t, status: 'running' } : t);
-          fs.writeFileSync(queuePath, updated.map(t => JSON.stringify(t)).join('\n') + '\n', 'utf-8');
+      const tasks: QueuedTask[] = content.split('\n').filter(Boolean).map(l => JSON.parse(l));
+      const pending = tasks
+        .filter(t => t.status === 'pending')
+        .sort((a, b) => b.priority - a.priority || a.addedAt - b.addedAt);
 
-          const botTask = {
-            instruction: task.instruction,
-            mode: task.mode ?? 'create',
-            targets: task.targets,
-            options: task.options,
-            queueId: task.id,
-          };
-          console.log(`\x1b[36m→ Task from queue [${task.id}]: ${task.instruction.slice(0, 80)}\x1b[0m`);
-          context.taskJson = JSON.stringify(botTask);
-          context.hasTask = true;
-          return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
-        }
-      }
+      if (pending.length === 0) return null;
+
+      const task = pending[0]!;
+      // Atomically mark as running inside the lock
+      const updated = tasks.map(t => t.id === task.id ? { ...t, status: 'running' } : t);
+      fs.writeFileSync(queuePath, updated.map(t => JSON.stringify(t)).join('\n') + '\n', 'utf-8');
+      return task;
+    });
+
+    if (claimed) {
+      const botTask = {
+        instruction: claimed.instruction,
+        mode: claimed.mode ?? 'create',
+        targets: claimed.targets,
+        options: claimed.options,
+        queueId: claimed.id,
+      };
+      console.log(`\x1b[36m→ Task from queue [${claimed.id}]: ${claimed.instruction.slice(0, 80)}\x1b[0m`);
+      context.taskJson = JSON.stringify(botTask);
+      context.hasTask = true;
+      return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
     }
-  } catch { /* ignore queue errors */ }
+  } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[receive-task] queue error:', err); }
 
   console.log('\x1b[33m→ No task found\x1b[0m');
   return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };

package/src/node-types/send-notify.ts

@@ -40,7 +40,7 @@ function sendWebhook(
     headers,
     body,
     signal: AbortSignal.timeout(10_000),
-  }).catch(() => {});
+  }).catch((err) => { if (process.env.WEAVER_VERBOSE) console.error('[send-notify] webhook failed:', err); });
 }
 
 /**