@synergenius/flow-weaver-pack-weaver 0.8.3 → 0.9.3

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); });
 }
 
 /**

package/src/node-types/validate-gate.ts

@@ -0,0 +1,112 @@
+import { execFileSync } from 'node:child_process';
+import * as path from 'node:path';
+import type { WeaverContext } from '../bot/types.js';
+
+/**
+ * Post-agent validation gate. Runs `flow-weaver validate` on all modified files
+ * and fails the task if any have errors. Don't trust the AI's self-assessment.
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Validate Gate
+ * @input ctx [order:0] - Weaver context (JSON)
+ * @output ctx [order:0] - Weaver context with validation result (JSON)
+ * @output onSuccess [order:-2] - All files valid
+ * @output onFailure [order:-1] [hidden] - Validation failed
+ */
+export function weaverValidateGate(ctx: string): {
+  ctx: string;
+  onSuccess: boolean;
+  onFailure: boolean;
+} {
+  const context = JSON.parse(ctx) as WeaverContext;
+  const { projectDir } = context.env;
+  const files: string[] = context.filesModified ? JSON.parse(context.filesModified) : [];
+
+  if (files.length === 0) {
+    context.validationResultJson = JSON.stringify({ skipped: true, reason: 'no files modified' });
+    return { ctx: JSON.stringify(context), onSuccess: true, onFailure: false };
+  }
+
+  // Only validate .ts files that look like workflows or node types
+  const toValidate = files.filter(f => f.endsWith('.ts'));
+  if (toValidate.length === 0) {
+    context.validationResultJson = JSON.stringify({ skipped: true, reason: 'no .ts files' });
+    return { ctx: JSON.stringify(context), onSuccess: true, onFailure: false };
+  }
+
+  const errors: Array<{ file: string; errorCount: number; errors: string[] }> = [];
+  let allValid = true;
+
+  for (const file of toValidate) {
+    const absPath = path.isAbsolute(file) ? file : path.resolve(projectDir, file);
+    try {
+      const output = execFileSync(
+        'npx',
+        ['flow-weaver', 'validate', absPath, '--json'],
+        { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 30_000, cwd: projectDir },
+      ).trim();
+
+      // Parse JSON output — look for errors (not warnings)
+      let result: { errors?: Array<{ message: string }>; errorCount?: number };
+      try {
+        result = JSON.parse(output);
+      } catch {
+        // Non-JSON output — try to detect errors from text
+        const hasErrors = output.includes('error') && !output.includes('0 error');
+        if (hasErrors) {
+          errors.push({ file, errorCount: 1, errors: [output.slice(0, 200)] });
+          allValid = false;
+        }
+        continue;
+      }
+
+      const errorCount = result.errorCount ?? result.errors?.length ?? 0;
+      if (errorCount > 0) {
+        allValid = false;
+        errors.push({
+          file,
+          errorCount,
+          errors: (result.errors ?? []).map(e => e.message).slice(0, 5),
+        });
+      }
+    } catch (err: unknown) {
+      // validate command failed — could be a parse error, treat as validation failure
+      const msg = err instanceof Error ? err.message : String(err);
+      // But don't fail on "not a workflow" — only on actual errors
+      if (!msg.includes('No @flowWeaver annotation') && !msg.includes('not a workflow')) {
+        errors.push({ file, errorCount: 1, errors: [msg.slice(0, 200)] });
+        allValid = false;
+      }
+    }
+  }
+
+  // Also run tsc --noEmit if any .ts files were modified (catches type errors FW validate misses)
+  if (allValid && toValidate.length > 0) {
+    try {
+      execFileSync('npx', ['tsc', '--noEmit', '--pretty'], {
+        cwd: projectDir, encoding: 'utf-8', timeout: 60_000, stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch (err: unknown) {
+      const tscOutput = (err as { stdout?: string }).stdout ?? (err instanceof Error ? err.message : '');
+      if (tscOutput.includes('error TS')) {
+        allValid = false;
+        errors.push({ file: '(tsc)', errorCount: 1, errors: [tscOutput.slice(0, 500)] });
+      }
+    }
+  }
+
+  context.validationResultJson = JSON.stringify({ errors, allValid });
+  context.allValid = allValid;
+
+  if (!allValid && process.env.WEAVER_VERBOSE) {
+    for (const e of errors) {
+      process.stderr.write(`\x1b[31m  ✗ ${e.file}: ${e.errorCount} error(s)\x1b[0m\n`);
+      for (const msg of e.errors) {
+        process.stderr.write(`\x1b[31m    ${msg}\x1b[0m\n`);
+      }
+    }
+  }
+
+  return { ctx: JSON.stringify(context), onSuccess: allValid, onFailure: !allValid };
+}

package/src/workflows/genesis-task.ts

@@ -33,40 +33,48 @@ import { genesisEscrowGrace } from '../node-types/genesis-escrow-grace.js';
  * @flowWeaver workflow
  *
  * @node cfg       weaverLoadConfig         [color: "teal"]    [icon: "settings"]     [position: 200 200]
- * @node detect    weaverDetectProvider     [color: "cyan"]    [icon: "search"]       [position: 400 200]
+ * @node detect    weaverDetectProvider     [color: "cyan"]    [icon: "search"]       [position: 400 200] [suppress: "OBJECT_TYPE_MISMATCH", "ANNOTATION_SIGNATURE_TYPE_MISMATCH"]
  * @node gCfg      genesisLoadConfig        [color: "purple"]  [icon: "settings"]     [position: 600 200]
- * @node escRecover genesisEscrowRecover    [color: "yellow"]  [icon: "healing"]      [position: 750 200]
+ * @node escRecover genesisEscrowRecover    [color: "yellow"]  [icon: "healthAndSafety"] [position: 750 200]
  * @node observe   genesisObserve           [color: "blue"]    [icon: "visibility"]   [position: 900 200]
- * @node diffFp    genesisDiffFingerprint   [color: "cyan"]    [icon: "compare"]      [position: 1100 200]
+ * @node diffFp    genesisDiffFingerprint   [color: "cyan"]    [icon: "assessment"]   [position: 1100 200]
  * @node stabilize genesisCheckStabilize    [color: "orange"]  [icon: "lock"]         [position: 1300 200]
  * @node propose   genesisPropose           [color: "blue"]    [icon: "psychology"]   [position: 1500 200]
- * @node validate  genesisValidateProposal  [color: "teal"]    [icon: "check"]        [position: 1700 200]
+ * @node validate  genesisValidateProposal  [color: "teal"]    [icon: "checkCircle"]  [position: 1700 200]
  * @node snapshot  genesisSnapshot          [color: "cyan"]    [icon: "backup"]       [position: 1900 200]
- * @node applyRetry genesisApplyRetry       [color: "purple"]  [icon: "replay"]       [position: 2100 200] [size: 300 200]
- * @node tryApply  genesisTryApply          applyRetry.attempt [position: 2150 230]
- * @node diffWf    genesisDiffWorkflow      [color: "cyan"]    [icon: "compare"]      [position: 2440 200]
+ * @node applyRetry genesisApplyRetry       [color: "purple"]  [icon: "repeat"]       [position: 2100 200] [size: 300 200] [suppress: "DESIGN_UNBOUNDED_RETRY"]
+ * @node tryApply  genesisTryApply          applyRetry.attempt [position: 2150 230] [suppress: "DESIGN_PULL_CANDIDATE"]
+ * @node diffWf    genesisDiffWorkflow      [color: "cyan"]    [icon: "altRoute"]     [position: 2440 200]
  * @node threshold genesisCheckThreshold    [color: "orange"]  [icon: "tune"]         [position: 2640 200]
  * @node approve   genesisApprove           [color: "orange"]  [icon: "send"]         [position: 2840 200]
  * @node commit    genesisCommit            [color: "green"]   [icon: "save"]         [position: 3040 200]
- * @node escStage  genesisEscrowStage       [color: "yellow"]  [icon: "archive"]      [position: 3240 400]
+ * @node escStage  genesisEscrowStage       [color: "yellow"]  [icon: "storage"]      [position: 3240 400]
  * @node escVal    genesisEscrowValidate    [color: "yellow"]  [icon: "verified"]     [position: 3440 400]
- * @node escMig    genesisEscrowMigrate     [color: "yellow"]  [icon: "swap_horiz"]   [position: 3640 400]
- * @node history   genesisUpdateHistory     [color: "teal"]    [icon: "history"]      [position: 3840 200]
+ * @node escMig    genesisEscrowMigrate     [color: "yellow"]  [icon: "sync"]         [position: 3640 400]
+ * @node history   genesisUpdateHistory     [color: "teal"]    [icon: "receipt"]      [position: 3840 200]
  * @node escGrace  genesisEscrowGrace       [color: "yellow"]  [icon: "timer"]        [position: 4040 200]
  * @node report    genesisReport            [color: "green"]   [icon: "description"]  [position: 4240 200]
  *
  * @path Start -> cfg -> detect -> gCfg -> escRecover -> observe -> diffFp -> stabilize -> propose -> validate -> snapshot -> applyRetry -> diffWf -> threshold -> approve -> commit -> escStage -> escVal -> escMig -> history -> escGrace -> report -> Exit
  *
  * @path applyRetry:fail -> report
+ * @path observe:fail -> report
+ * @path propose:fail -> report
+ * @path approve:fail -> report
+ * @path commit:fail -> report
  * @path escStage:fail -> report
  * @path escVal:fail -> report
  * @path escMig:fail -> report
  *
  * @connect applyRetry.attemptCtx:attempt -> tryApply.ctx
  * @connect tryApply.ctx -> applyRetry.attemptCtx:attempt
+ * @connect tryApply.onSuccess -> applyRetry.success:attempt
+ * @connect tryApply.onFailure -> applyRetry.failure:attempt
  *
- * @connect history.ctx -> report.successCtx
+ * @connect escGrace.ctx -> report.successCtx
  * @connect applyRetry.ctx -> report.failCtx
+ * @connect propose.ctx -> report.proposeFailCtx
+ * @connect commit.ctx -> report.commitFailCtx
  *
  * @connect report.summary -> Exit.summary
  *
@@ -74,7 +82,7 @@ import { genesisEscrowGrace } from '../node-types/genesis-escrow-grace.js';
  * @position Exit 4440 200
  *
  * @param execute [order:-1] - Execute
- * @param projectDir [order:0] [optional] - Project directory
+ * @param [projectDir] [order:0] - Project directory
  * @returns onSuccess [order:-2] - On Success
  * @returns onFailure [order:-1] [hidden] - On Failure
  * @returns summary [order:0] - Summary text