@synergenius/flow-weaver-pack-weaver 0.8.1

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

@@ -0,0 +1,92 @@
+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';
+
+interface QueuedTask {
+  id: string;
+  instruction: string;
+  mode?: 'create' | 'modify' | 'read' | 'batch';
+  targets?: string[];
+  options?: Record<string, unknown>;
+  priority: number;
+  addedAt: number;
+  status: string;
+}
+
+/**
+ * Receives a task from CLI args, MCP tool call, or the task queue.
+ * Parses the instruction into a structured BotTask. Creates the
+ * WeaverContext that threads through the bot pipeline.
+ *
+ * @flowWeaver nodeType
+ * @label Receive Task
+ * @input env [order:0] - Weaver environment bundle
+ * @input [taskJson] [order:1] - Pre-supplied task (JSON, optional)
+ * @output ctx [order:0] - Weaver context (JSON)
+ * @output onSuccess [order:-2] - On Success
+ * @output onFailure [order:-1] [hidden] - On Failure
+ */
+export async function weaverReceiveTask(
+  execute: boolean,
+  env: WeaverEnv,
+  taskJson?: string,
+): Promise<{
+  onSuccess: boolean; onFailure: boolean;
+  ctx: string;
+}> {
+  const context: WeaverContext = { env, taskJson: '{}', hasTask: false };
+
+  if (!execute) {
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+
+  // If taskJson is pre-supplied, use it directly
+  if (taskJson) {
+    try {
+      const parsed = JSON.parse(taskJson);
+      if (parsed.instruction) {
+        console.log(`\x1b[36m→ Task received: ${parsed.instruction.slice(0, 80)}\x1b[0m`);
+        context.taskJson = taskJson;
+        context.hasTask = true;
+        return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+      }
+    } catch { /* fall through to queue check */ }
+  }
+
+  // Check task queue
+  const queuePath = path.join(os.homedir(), '.weaver', 'task-queue.ndjson');
+  try {
+    if (fs.existsSync(queuePath)) {
+      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 (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 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) };
+        }
+      }
+    }
+  } catch { /* ignore queue errors */ }
+
+  console.log('\x1b[33m→ No task found\x1b[0m');
+  return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };
+}

package/src/node-types/report.ts

@@ -0,0 +1,25 @@
+import * as path from 'node:path';
+import type { WeaverContext } from '../bot/types.js';
+
+/**
+ * Format the result summary, suitable for display or further processing.
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Report
+ * @input ctx [order:0] - Weaver context (JSON)
+ * @output summary [order:0] - Summary string
+ * @output onFailure [hidden]
+ */
+export function weaverReport(ctx: string): { summary: string } {
+  const context = JSON.parse(ctx) as WeaverContext;
+  const result = JSON.parse(context.resultJson!);
+  const relPath = path.relative(context.env.projectDir, context.targetPath!);
+  const lines = [
+    `Weaver: ${result.outcome} (${relPath})`,
+    result.summary,
+  ];
+  if (result.executionTime) lines.push(`Time: ${result.executionTime}s`);
+  console.log(`\x1b[32m✓ ${lines[0]}\x1b[0m`);
+  return { summary: lines.join('\n') };
+}

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

@@ -0,0 +1,64 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { WeaverEnv, WeaverContext } from '../bot/types.js';
+
+/**
+ * Find the target workflow file from config or by scanning the project directory.
+ * Creates the WeaverContext that threads through the pipeline.
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Resolve Target
+ * @input env [order:0] - Weaver environment bundle
+ * @output ctx [order:0] - Weaver context (JSON)
+ * @output onFailure [hidden]
+ */
+export function weaverResolveTarget(
+  env: WeaverEnv,
+): { ctx: string } {
+  const { projectDir, config } = env;
+
+  let targetPath: string;
+
+  if (config.target) {
+    const abs = path.resolve(projectDir, config.target);
+    if (!fs.existsSync(abs)) throw new Error(`Target workflow not found: ${abs}`);
+    console.log(`\x1b[36m→ Target: ${abs}\x1b[0m`);
+    targetPath = abs;
+  } else {
+    const found: string[] = [];
+    const scan = (dir: string, depth: number): void => {
+      if (depth > 2) return;
+      let entries: fs.Dirent[];
+      try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+      for (const entry of entries) {
+        if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) { scan(full, depth + 1); }
+        else if (entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts')) {
+          try {
+            const content = fs.readFileSync(full, 'utf-8').slice(0, 2000);
+            if (content.includes('@flowWeaver workflow')) found.push(full);
+          } catch { /* skip */ }
+        }
+      }
+    };
+    scan(projectDir, 0);
+
+    if (found.length === 0) {
+      throw new Error(`No workflow files found in ${projectDir}. Set "target" in .weaver.json or pass a file path.`);
+    }
+    if (found.length > 1) {
+      throw new Error(
+        `Multiple workflows found. Set "target" in .weaver.json to pick one:\n` +
+        found.map(f => `  - ${path.relative(projectDir, f)}`).join('\n'),
+      );
+    }
+
+    console.log(`\x1b[36m→ Target: ${found[0]}\x1b[0m`);
+    targetPath = found[0]!;
+  }
+
+  const context: WeaverContext = { env, targetPath };
+  return { ctx: JSON.stringify(context) };
+}

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

@@ -0,0 +1,25 @@
+import type { WeaverContext } from '../bot/types.js';
+
+/**
+ * Routes based on task mode. onSuccess fires for actionable tasks
+ * (create/modify/batch). onFailure fires for read-only tasks.
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Route Task
+ * @input ctx [order:0] - Weaver context (JSON)
+ * @output ctx [order:0] - Weaver context (pass-through, JSON)
+ */
+export function weaverRouteTask(ctx: string): { ctx: string } {
+  const context = JSON.parse(ctx) as WeaverContext;
+  const task = JSON.parse(context.taskJson!) as { mode?: string };
+  const mode = task.mode ?? 'create';
+
+  if (mode === 'read') {
+    console.log('\x1b[36m→ Routing to read-only path\x1b[0m');
+    throw new Error('read-only-route');
+  }
+
+  console.log(`\x1b[36m→ Routing to ${mode} path\x1b[0m`);
+  return { ctx };
+}

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

@@ -0,0 +1,75 @@
+import type { WeaverContext } from '../bot/types.js';
+import { auditEmit } from '../bot/audit-logger.js';
+
+function sendWebhook(
+  config: { channel: string; url: string; headers?: Record<string, string> },
+  event: Record<string, unknown>,
+): void {
+  const headers: Record<string, string> = {
+    'content-type': 'application/json',
+    ...config.headers,
+  };
+  let body: string;
+  if (config.channel === 'discord') {
+    const color = event.success ? 0x22c55e : 0xef4444;
+    body = JSON.stringify({
+      embeds: [{
+        title: `Weaver: ${event.outcome ?? 'update'}`,
+        description: String(event.summary ?? '').slice(0, 2000),
+        color,
+        fields: [
+          { name: 'Workflow', value: String(event.targetPath ?? 'unknown'), inline: true },
+          { name: 'Provider', value: String(event.providerType ?? 'unknown'), inline: true },
+        ],
+        timestamp: new Date().toISOString(),
+      }],
+    });
+  } else if (config.channel === 'slack') {
+    const emoji = event.success ? ':white_check_mark:' : ':x:';
+    body = JSON.stringify({
+      blocks: [
+        { type: 'header', text: { type: 'plain_text', text: `${emoji} Weaver: ${event.outcome ?? 'update'}` } },
+        { type: 'section', text: { type: 'mrkdwn', text: String(event.summary ?? '').slice(0, 2000) } },
+      ],
+    });
+  } else {
+    body = JSON.stringify(event);
+  }
+  fetch(config.url, {
+    method: 'POST',
+    headers,
+    body,
+    signal: AbortSignal.timeout(10_000),
+  }).catch(() => {});
+}
+
+/**
+ * Send webhook/Discord/Slack notifications based on config.
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Notify Result
+ * @input ctx [order:0] - Weaver context (JSON)
+ * @output ctx [order:0] - Weaver context (pass-through, JSON)
+ * @output onFailure [hidden]
+ */
+export function weaverSendNotify(ctx: string): { ctx: string } {
+  const context = JSON.parse(ctx) as WeaverContext;
+  const { env } = context;
+  const { config, projectDir } = env;
+  const result = context.resultJson ? JSON.parse(context.resultJson) : {};
+  const channels = (Array.isArray(config.notify) ? config.notify : config.notify ? [config.notify] : []);
+
+  for (const ch of channels) {
+    const events = ch.events ?? ['workflow-complete', 'error'];
+    const eventType = result.success ? 'workflow-complete' : 'error';
+    if (!events.includes(eventType)) continue;
+    sendWebhook(ch, { ...result, targetPath: projectDir, providerType: config.provider, projectDir });
+  }
+
+  if (channels.length > 0) {
+    auditEmit('notification-sent', { channelCount: channels.length });
+    console.log(`\x1b[36m→ Sent ${channels.length} notification(s)\x1b[0m`);
+  }
+  return { ctx };
+}

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

@@ -0,0 +1,49 @@
+import type { WeaverEnv } from '../bot/types.js';
+import { validateFiles } from '../bot/file-validator.js';
+
+/**
+ * Validates all modified/created files using flow-weaver validate
+ * and compile. Branches on validation success/failure.
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Validate Result
+ * @input env [order:0] - Weaver environment bundle
+ * @input executionResultJson [order:1] - Execution result (JSON)
+ * @input taskJson [order:2] - Task (JSON, pass-through)
+ * @input filesModified [order:3] - Files modified (JSON array)
+ * @output env [order:0] - Weaver environment bundle (pass-through)
+ * @output validationResultJson [order:1] - Validation results (JSON)
+ * @output taskJson [order:2] - Task (pass-through)
+ * @output allValid [order:3] - Whether all files passed validation
+ */
+export async function weaverValidateResult(
+  env: WeaverEnv,
+  executionResultJson: string,
+  taskJson: string,
+  filesModified: string,
+): Promise<{
+  env: WeaverEnv;
+  validationResultJson: string; taskJson: string; allValid: boolean;
+}> {
+  const { projectDir } = env;
+  const files: string[] = JSON.parse(filesModified);
+  const results = await validateFiles(files, projectDir);
+
+  for (const r of results) {
+    if (r.valid) console.log(`\x1b[32m  ✓ ${r.file}\x1b[0m`);
+    else console.log(`\x1b[31m  x ${r.file}: ${r.errors[0]?.slice(0, 100)}\x1b[0m`);
+  }
+
+  const allValid = results.length === 0 || results.every(r => r.valid);
+
+  if (!allValid) {
+    throw new Error('Validation failed: ' + results.filter(r => !r.valid).map(r => r.file).join(', '));
+  }
+
+  return {
+    env,
+    validationResultJson: JSON.stringify(results),
+    taskJson, allValid,
+  };
+}

package/src/templates/index.ts

@@ -0,0 +1,5 @@
+import { weaverBotTemplate } from './weaver-bot-template.js';
+
+export type { WorkflowTemplate } from './weaver-bot-template.js';
+export { weaverBotTemplate };
+export const workflowTemplates = [weaverBotTemplate];

package/src/templates/weaver-bot-template.ts

@@ -0,0 +1,106 @@
+export interface WorkflowTemplate {
+  id: string;
+  name: string;
+  description: string;
+  category: string;
+  generate: (opts: { projectDir?: string }) => string;
+}
+
+export const weaverBotTemplate: WorkflowTemplate = {
+  id: 'weaver-bot',
+  name: 'Weaver Bot: Autonomous workflow creator',
+  description: 'AI-powered bot that creates, modifies, and manages Flow Weaver workflows autonomously from natural language instructions',
+  category: 'bot',
+  generate: (_opts) => {
+    return `// Generated by flow-weaver-pack-weaver. Compile before running:
+//   flow-weaver compile weaver-bot.ts
+//   flow-weaver weaver bot "Create a hello world workflow"
+
+import { weaverLoadConfig } from '@synergenius/flow-weaver-pack-weaver/node-types';
+import { weaverDetectProvider } from '@synergenius/flow-weaver-pack-weaver/node-types';
+import { weaverReceiveTask } from '@synergenius/flow-weaver-pack-weaver/node-types';
+import { weaverRouteTask } from '@synergenius/flow-weaver-pack-weaver/node-types';
+import { weaverReadWorkflow } from '@synergenius/flow-weaver-pack-weaver/node-types';
+import { weaverBuildContext } from '@synergenius/flow-weaver-pack-weaver/node-types';
+import { weaverPlanTask } from '@synergenius/flow-weaver-pack-weaver/node-types';
+import { weaverApprovalGate } from '@synergenius/flow-weaver-pack-weaver/node-types';
+import { weaverAbortTask } from '@synergenius/flow-weaver-pack-weaver/node-types';
+import { weaverExecValidateRetry } from '@synergenius/flow-weaver-pack-weaver/node-types';
+import { weaverGitOps } from '@synergenius/flow-weaver-pack-weaver/node-types';
+import { weaverSendNotify } from '@synergenius/flow-weaver-pack-weaver/node-types';
+import { weaverBotReport } from '@synergenius/flow-weaver-pack-weaver/node-types';
+
+/**
+ * Autonomous workflow bot.
+ *
+ * @flowWeaver workflow
+ *
+ * @node cfg      weaverLoadConfig       [color: "slate"]    [icon: "settings"]       [position: 80 200]
+ * @node detect   weaverDetectProvider   [color: "cyan"]     [icon: "search"]         [position: 230 200]
+ * @node receive  weaverReceiveTask      [color: "indigo"]   [icon: "inbox"]          [position: 400 200]
+ * @node route    weaverRouteTask        [color: "violet"]   [icon: "alt_route"]      [position: 570 200]
+ * @node readWf   weaverReadWorkflow     [color: "sky"]      [icon: "visibility"]     [position: 740 450]
+ * @node context  weaverBuildContext     [color: "teal"]     [icon: "auto_stories"]   [position: 740 200]
+ * @node plan     weaverPlanTask         [color: "blue"]     [icon: "psychology"]     [position: 910 200]
+ * @node approve  weaverApprovalGate     [color: "amber"]    [icon: "gavel"]          [position: 1080 200]
+ * @node abort    weaverAbortTask        [color: "red"]      [icon: "cancel"]         [position: 1250 450]
+ * @node execRetry weaverExecValidateRetry [color: "purple"] [icon: "replay"]         [position: 1250 200]
+ * @node gitOps   weaverGitOps           [color: "stone"]    [icon: "commit"]         [position: 1420 100]
+ * @node notify   weaverSendNotify       [color: "yellow"]   [icon: "notifications"]  [position: 1420 300]
+ * @node report   weaverBotReport        [color: "green"]    [icon: "summarize"]      [position: 1600 200]
+ *
+ * @path Start -> cfg -> detect -> receive -> route -> context -> plan -> approve -> execRetry -> gitOps -> report -> Exit
+ * @path Start -> execRetry -> notify -> report -> Exit
+ * @path Start -> route:fail -> readWf -> report -> Exit
+ * @path Start -> approve:fail -> abort -> report -> Exit
+ *
+ * @connect route.taskJson -> readWf.taskJson
+ * @connect route.projectDir -> readWf.projectDir
+ * @connect readWf.resultJson -> report.readResult
+ * @connect readWf.taskJson -> report.taskJson
+ * @connect route.taskJson -> context.taskJson
+ * @connect context.contextBundle -> plan.contextBundle
+ * @connect plan.planJson -> approve.planJson
+ * @connect approve.rejectionReason -> abort.rejectionReason
+ * @connect approve.taskJson -> abort.taskJson
+ * @connect approve.projectDir -> abort.projectDir
+ * @connect abort.resultJson -> report.abortResult
+ * @connect abort.taskJson -> report.taskJson
+ * @connect approve.planJson -> execRetry.planJson
+ * @connect approve.taskJson -> execRetry.taskJson
+ * @connect execRetry.filesModified -> gitOps.filesModified
+ * @connect execRetry.projectDir -> gitOps.projectDir
+ * @connect cfg.config -> gitOps.config
+ * @connect execRetry.resultJson -> notify.resultJson
+ * @connect execRetry.projectDir -> notify.projectDir
+ * @connect cfg.config -> notify.config
+ * @connect execRetry.resultJson -> report.mainResult
+ * @connect execRetry.filesModified -> report.filesModified
+ * @connect receive.taskJson -> report.taskJson
+ * @connect gitOps.gitResultJson -> report.gitResultJson
+ * @connect report.summary -> Exit.summary
+ *
+ * @position Start 0 200
+ * @position Exit 1750 200
+ *
+ * @param execute [order:-1] - Execute
+ * @param taskJson [order:0] [optional] - Task instruction (JSON)
+ * @param projectDir [order:1] [optional] - Project directory
+ * @returns onSuccess [order:-2] - On Success
+ * @returns onFailure [order:-1] - On Failure
+ * @returns summary [order:0] - Summary text
+ */
+export async function weaverBot(
+  execute: boolean,
+  taskJson?: string,
+  projectDir?: string,
+  __abortSignal__?: AbortSignal,
+): Promise<{ onSuccess: boolean; onFailure: boolean; summary: string | null }> {
+  // @flow-weaver-body-start
+  // (auto-generated by compiler)
+  // @flow-weaver-body-end
+  return { onSuccess: false, onFailure: true, summary: null };
+}
+`;
+  },
+};

package/src/workflows/genesis-task.ts

@@ -0,0 +1,91 @@
+// Genesis self-evolution workflow. Observes the project, proposes changes
+// to a target workflow, validates + compiles with retry, and commits or
+// rolls back.
+
+import { weaverLoadConfig } from '../node-types/load-config.js';
+import { weaverDetectProvider } from '../node-types/detect-provider.js';
+import { genesisLoadConfig } from '../node-types/genesis-load-config.js';
+import { genesisObserve } from '../node-types/genesis-observe.js';
+import { genesisDiffFingerprint } from '../node-types/genesis-diff-fingerprint.js';
+import { genesisCheckStabilize } from '../node-types/genesis-check-stabilize.js';
+import { genesisPropose } from '../node-types/genesis-propose.js';
+import { genesisValidateProposal } from '../node-types/genesis-validate-proposal.js';
+import { genesisSnapshot } from '../node-types/genesis-snapshot.js';
+import { genesisApplyRetry } from '../node-types/genesis-apply-retry.js';
+import { genesisTryApply } from '../node-types/genesis-try-apply.js';
+import { genesisDiffWorkflow } from '../node-types/genesis-diff-workflow.js';
+import { genesisCheckThreshold } from '../node-types/genesis-check-threshold.js';
+import { genesisApprove } from '../node-types/genesis-approve.js';
+import { genesisCommit } from '../node-types/genesis-commit.js';
+import { genesisUpdateHistory } from '../node-types/genesis-update-history.js';
+import { genesisReport } from '../node-types/genesis-report.js';
+import { genesisEscrowRecover } from '../node-types/genesis-escrow-recover.js';
+import { genesisEscrowStage } from '../node-types/genesis-escrow-stage.js';
+import { genesisEscrowValidate } from '../node-types/genesis-escrow-validate.js';
+import { genesisEscrowMigrate } from '../node-types/genesis-escrow-migrate.js';
+import { genesisEscrowGrace } from '../node-types/genesis-escrow-grace.js';
+
+/**
+ * Genesis self-evolution cycle. Observes the project state, proposes workflow
+ * changes within a budget, validates and compiles with retry, then commits or
+ * rolls back based on approval.
+ *
+ * @flowWeaver workflow
+ *
+ * @node cfg       weaverLoadConfig         [color: "teal"]    [icon: "settings"]     [position: 200 200]
+ * @node detect    weaverDetectProvider     [color: "cyan"]    [icon: "search"]       [position: 400 200]
+ * @node gCfg      genesisLoadConfig        [color: "purple"]  [icon: "settings"]     [position: 600 200]
+ * @node escRecover genesisEscrowRecover    [color: "yellow"]  [icon: "healing"]      [position: 750 200]
+ * @node observe   genesisObserve           [color: "blue"]    [icon: "visibility"]   [position: 900 200]
+ * @node diffFp    genesisDiffFingerprint   [color: "cyan"]    [icon: "compare"]      [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 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 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 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 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 escStage:fail -> report
+ * @path escVal:fail -> report
+ * @path escMig:fail -> report
+ *
+ * @connect applyRetry.attemptCtx:attempt -> tryApply.ctx
+ * @connect tryApply.ctx -> applyRetry.attemptCtx:attempt
+ *
+ * @connect history.ctx -> report.successCtx
+ * @connect applyRetry.ctx -> report.failCtx
+ *
+ * @connect report.summary -> Exit.summary
+ *
+ * @position Start 0 200
+ * @position Exit 4440 200
+ *
+ * @param execute [order:-1] - Execute
+ * @param projectDir [order:0] [optional] - Project directory
+ * @returns onSuccess [order:-2] - On Success
+ * @returns onFailure [order:-1] [hidden] - On Failure
+ * @returns summary [order:0] - Summary text
+ */
+export async function genesisTask(
+  execute: boolean,
+  params: { projectDir?: string } = {},
+  __abortSignal__?: AbortSignal,
+): Promise<{ onSuccess: boolean; onFailure: boolean; summary: string | null }> {
+  // @flow-weaver-body-start
+  // (auto-generated by compiler)
+  // @flow-weaver-body-end
+  return { onSuccess: false, onFailure: true, summary: null };
+}

package/src/workflows/index.ts

@@ -0,0 +1,3 @@
+export { weaverBot } from './weaver-bot.js';
+export { weaverBotBatch } from './weaver-bot-batch.js';
+export { genesisTask } from './genesis-task.js';

package/src/workflows/weaver-bot-batch.ts

@@ -0,0 +1,65 @@
+// Managed weaver bot batch workflow - processes multiple tasks via forEach scope.
+// Run `weaver eject` to customize.
+
+import { weaverLoadConfig } from '../node-types/load-config.js';
+import { weaverDetectProvider } from '../node-types/detect-provider.js';
+import { weaverReceiveTask } from '../node-types/receive-task.js';
+import { weaverBuildContext } from '../node-types/build-context.js';
+import { weaverPlanTask } from '../node-types/plan-task.js';
+import { weaverApprovalGate } from '../node-types/approval-gate.js';
+import { weaverAbortTask } from '../node-types/abort-task.js';
+import { weaverExecValidateRetry } from '../node-types/exec-validate-retry.js';
+import { weaverGitOps } from '../node-types/git-ops.js';
+import { weaverSendNotify } from '../node-types/send-notify.js';
+import { weaverBotReport } from '../node-types/bot-report.js';
+
+/**
+ * Batch workflow bot. Processes multiple sub-tasks sequentially,
+ * running the full plan-approve-execute cycle for each.
+ *
+ * @flowWeaver workflow
+ *
+ * @node cfg       weaverLoadConfig       [color: "teal"]    [icon: "settings"]      [position: 200 200]
+ * @node detect    weaverDetectProvider   [color: "cyan"]    [icon: "search"]        [position: 400 200]
+ * @node receive   weaverReceiveTask      [color: "blue"]    [icon: "send"]          [position: 600 200]
+ * @node context   weaverBuildContext     [color: "teal"]    [icon: "code"]          [position: 800 200]
+ * @node plan      weaverPlanTask         [color: "blue"]    [icon: "psychology"]    [position: 1000 200]
+ * @node approve   weaverApprovalGate     [color: "orange"]  [icon: "send"]          [position: 1200 200]
+ * @node abort     weaverAbortTask        [color: "red"]     [icon: "code"]          [position: 1400 400]
+ * @node execRetry weaverExecValidateRetry [color: "purple"] [icon: "code"]          [position: 1400 200]
+ * @node gitOps    weaverGitOps           [color: "green"]   [icon: "code"]          [position: 1600 100]
+ * @node notify    weaverSendNotify       [color: "yellow"]  [icon: "send"]          [position: 1600 300]
+ * @node report    weaverBotReport        [color: "green"]   [icon: "description"]   [position: 1800 200]
+ *
+ * @path Start -> cfg -> detect -> receive -> context -> plan -> approve -> execRetry -> gitOps -> report -> Exit
+ * @path execRetry -> notify
+ * @path approve:fail -> abort
+ *
+ * @connect notify.onSuccess -> report.execute
+ * @connect abort.onSuccess -> report.execute
+ *
+ * @connect gitOps.ctx -> report.mainCtx
+ * @connect abort.ctx -> report.abortCtx
+ *
+ * @connect report.summary -> Exit.summary
+ *
+ * @position Start 0 200
+ * @position Exit 2000 200
+ *
+ * @param execute [order:-1] - Execute
+ * @param taskJson [order:0] [optional] - Batch task instruction (JSON)
+ * @param projectDir [order:1] [optional] - Project directory
+ * @returns onSuccess [order:-2] - On Success
+ * @returns onFailure [order:-1] [hidden] - On Failure
+ * @returns summary [order:0] - Summary text
+ */
+export async function weaverBotBatch(
+  execute: boolean,
+  params: { taskJson?: string; projectDir?: string },
+  __abortSignal__?: AbortSignal,
+): Promise<{ onSuccess: boolean; onFailure: boolean; summary: string | null }> {
+  // @flow-weaver-body-start
+  // (auto-generated by compiler)
+  // @flow-weaver-body-end
+  return { onSuccess: false, onFailure: true, summary: null };
+}