@synergenius/flow-weaver-pack-weaver 0.8.1

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

@@ -0,0 +1,256 @@
+import type { WeaverEnv, ProviderInfo, WeaverContext } from '../bot/types.js';
+import { callAI, parseJsonResponse } from '../bot/ai-client.js';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function buildWeaverPrompt(): Promise<string> {
+  const FALLBACK = 'You are Weaver, an expert AI companion for Flow Weaver workflows. Respond ONLY with valid JSON. No markdown, no code fences, no explanation outside the JSON structure.';
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const docMeta: any = await import('@synergenius/flow-weaver/doc-metadata');
+
+    const annotations: Array<{ name: string; syntax: string; description: string; category: string }> = docMeta.ALL_ANNOTATIONS ?? [];
+    const portMods: Array<{ syntax: string; description: string }> = docMeta.PORT_MODIFIERS ?? [];
+    const nodeMods: Array<{ syntax: string; description: string }> = docMeta.NODE_MODIFIERS ?? [];
+    const codes: Array<{ code: string; severity: string; title: string; description: string }> = docMeta.VALIDATION_CODES ?? [];
+    const commands: Array<{ name: string; description: string; group?: string }> = docMeta.CLI_COMMANDS ?? [];
+
+    const groups = new Map<string, typeof annotations>();
+    for (const a of annotations) {
+      const list = groups.get(a.category) ?? [];
+      list.push(a);
+      groups.set(a.category, list);
+    }
+    const annotationLines: string[] = [];
+    for (const [category, items] of groups) {
+      annotationLines.push('[' + category + ']');
+      for (const item of items) annotationLines.push('  ' + item.syntax + '  -- ' + item.description);
+    }
+
+    const modLines: string[] = [];
+    if (portMods.length > 0) {
+      modLines.push('Port modifiers (after port name):');
+      for (const m of portMods) modLines.push('  ' + m.syntax + '  -- ' + m.description);
+    }
+    if (nodeMods.length > 0) {
+      modLines.push('Node instance modifiers (in @node declaration):');
+      for (const m of nodeMods) modLines.push('  ' + m.syntax + '  -- ' + m.description);
+    }
+
+    const errors = codes.filter(c => c.severity === 'error').slice(0, 15);
+    const errorLines = errors.map(c => '  ' + c.code + ': ' + c.title + ' -- ' + c.description);
+
+    const topCmds = commands.filter(c => !c.group);
+    const cmdLines = topCmds.map(c => '  flow-weaver ' + c.name + ' -- ' + c.description);
+
+    return `You are Weaver, an expert AI companion for Flow Weaver workflows. You have deep knowledge of the entire Flow Weaver ecosystem: annotation grammar, compilation, CLI tools, node patterns, error diagnosis, and the Genesis self-evolution protocol.
+
+## Core Mental Model
+
+The code IS the workflow. Flow Weaver workflows are plain TypeScript files with JSDoc annotations above functions. The compiler reads annotations and generates deterministic execution code between @flow-weaver-body-start/end markers. Compiled code is standalone with no runtime dependency on flow-weaver.
+
+Three block types:
+- @flowWeaver nodeType: A reusable function (node) with typed inputs/outputs
+- @flowWeaver workflow: A DAG orchestration that wires node instances together
+- @flowWeaver pattern: A reusable fragment with boundary ports (IN/OUT instead of Start/Exit)
+
+## Annotation Grammar
+
+${annotationLines.join('\n')}
+
+${modLines.join('\n')}
+
+## Node Execution Model
+
+Expression nodes (@expression):
+- No execute/onSuccess/onFailure params. Just inputs and return value.
+- throw = failure path, return = success path
+- Synchronous. Use execSync for shell commands.
+- Preferred for deterministic operations.
+
+Standard nodes:
+- execute: boolean param gates execution
+- Return { onSuccess: boolean, onFailure: boolean, ...outputs }
+- Can be async for I/O operations
+
+Async agent nodes:
+- Use (globalThis as any).__fw_agent_channel__ to pause workflow
+- Call channel.request({ agentId, context, prompt }) which returns a Promise
+- Workflow suspends until agent responds
+- NOT @expression (must be async)
+
+Pass-through pattern:
+- FW auto-connects ports by matching names on adjacent nodes
+- To forward data through intermediate nodes, declare it as both @input and @output with the same name
+- For non-adjacent wiring, use @connect sourceNode.port -> targetNode.port
+
+Data flow:
+- @path A -> B -> C: Linear execution path (sugar for multiple @connect)
+- @autoConnect: Auto-wire all nodes in declaration order
+- @connect: Explicit port-to-port wiring
+- Merge strategies for fan-in: FIRST, LAST, COLLECT, MERGE, CONCAT
+
+## CLI Commands
+
+${cmdLines.join('\n')}
+
+Key workflows:
+  flow-weaver compile <file>  -- Generate executable code (in-place)
+  flow-weaver validate <file> -- Check for errors without compiling
+  flow-weaver modify <op> --file <f> -- Structural changes (addNode, removeNode, addConnection, removeConnection)
+  flow-weaver implement <file> -- Replace declare stubs with implementations
+  flow-weaver diff <a> <b> -- Semantic diff between two workflow versions
+  flow-weaver diagram <file> -f ascii-compact -- Generate ASCII diagram
+
+## Validation Errors
+
+${errorLines.join('\n')}
+
+When you encounter validation errors, suggest the specific fix. Common resolutions:
+- UNKNOWN_NODE_TYPE: Ensure the referenced function has @flowWeaver nodeType annotation
+- MISSING_REQUIRED_INPUT: Add a @connect from a source port or make the input optional with [brackets]
+- UNKNOWN_SOURCE_PORT / UNKNOWN_TARGET_PORT: Check port name spelling in @connect
+- CYCLE_DETECTED: Break the cycle; use scoped iteration (@scope, @map) instead of circular dependencies
+
+## Genesis Protocol
+
+Genesis is a 17-step self-evolving workflow engine:
+1. Load config (.genesis/config.json with intent, focus, constraints, approval thresholds)
+2. Observe project (fingerprint: files, package.json, git, CI, tests, existing FW workflows)
+3. Load task workflow (genesis-task.ts)
+4. Diff fingerprint against last cycle
+5. Check stabilize mode (3+ rollbacks/rejections = read-only, or explicit flag)
+6. Wait for agent (YOU decide what evolutions to propose)
+7. Propose evolution (map your decisions to FwModifyOperation[])
+8. Validate proposal (budget: max 3 cost units per cycle. addNode=1, removeNode=1, addConnection=1, removeConnection=1, implementNode=2)
+9. Snapshot current task workflow for rollback
+10. Apply changes via flow-weaver CLI
+11. Compile and validate (auto-rollback on failure)
+12. Diff workflow (semantic diff)
+13. Check approval threshold (CRITICAL > BREAKING > MINOR > COSMETIC)
+14. Wait for approval (if impact >= threshold)
+15. Commit or rollback based on approval
+16. Update history (.genesis/history.json)
+17. Report summary
+
+When stabilize mode is active, only fix-up operations are allowed: removeNode, removeConnection, implementNode. No new nodes or connections.
+
+## Response Format
+
+Return ONLY valid JSON. No markdown, no code fences, no explanation outside the JSON structure.`;
+  } catch {
+    return FALLBACK;
+  }
+}
+
+/**
+ * Run the target workflow via the flow-weaver executor with an AI agent channel.
+ *
+ * @flowWeaver nodeType
+ * @label Execute Target
+ * @input ctx [order:0] - Weaver context (JSON)
+ * @output ctx [order:0] - Weaver context with resultJson (JSON)
+ * @output onSuccess [order:-2] - On Success
+ * @output onFailure [order:-1] [hidden] - On Failure
+ */
+export async function weaverExecuteTarget(
+  execute: boolean,
+  ctx: string,
+): Promise<{
+  onSuccess: boolean; onFailure: boolean;
+  ctx: string;
+}> {
+  const context = JSON.parse(ctx) as WeaverContext;
+  const { env } = context;
+  const targetPath = context.targetPath!;
+
+  if (!execute) {
+    context.resultJson = JSON.stringify({ success: true, summary: 'Dry run', outcome: 'skipped' });
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+
+  const { config, providerInfo: pInfo } = env;
+  const systemPrompt = await buildWeaverPrompt();
+
+  const approvalSetting = config.approval ?? 'auto';
+  const approvalMode = typeof approvalSetting === 'string' ? approvalSetting : approvalSetting.mode;
+
+  const agentChannel = {
+    request: async (req: { agentId: string; context: Record<string, unknown>; prompt: string }) => {
+      if (req.agentId.includes('approval')) {
+        if (approvalMode === 'auto') {
+          console.log('\x1b[36m→ Auto-approving\x1b[0m');
+          return { approved: true, reason: 'auto-approved' };
+        }
+        if (approvalMode === 'timeout-auto') {
+          const timeout = typeof approvalSetting === 'object' ? (approvalSetting.timeoutSeconds ?? 300) : 300;
+          console.log(`\x1b[36m→ Waiting ${timeout}s before auto-approving...\x1b[0m`);
+          await new Promise(resolve => setTimeout(resolve, timeout * 1000));
+          return { approved: true, reason: 'timeout-auto-approved' };
+        }
+        return { approved: true, reason: 'default-approved' };
+      }
+
+      const contextStr = typeof req.context === 'string'
+        ? req.context
+        : JSON.stringify(req.context, null, 2);
+      const userPrompt = `Context:\n${contextStr}\n\nInstructions:\n${req.prompt}`;
+
+      const text = await callAI(pInfo, systemPrompt, userPrompt);
+
+      return parseJsonResponse(text);
+    },
+    onPause: () => new Promise<never>(() => {}),
+    resume: () => {},
+    fail: () => {},
+  };
+
+  try {
+    console.log(`\x1b[36m→ Executing: ${targetPath}\x1b[0m`);
+    const startTime = Date.now();
+
+    const mod = '@synergenius/flow-weaver/executor';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const { executeWorkflowFromFile } = await (import(mod) as Promise<any>);
+    const execResult = await executeWorkflowFromFile(targetPath, {}, {
+      agentChannel,
+      includeTrace: false,
+      production: true,
+    });
+
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+    const result = execResult.result as Record<string, unknown> | null;
+    const ok = (result?.onSuccess as boolean) ?? false;
+
+    let summary: string;
+    if (typeof result?.summary === 'string') {
+      summary = result.summary;
+    } else if (result) {
+      const parts: string[] = [];
+      for (const [k, v] of Object.entries(result)) {
+        if (k === 'onSuccess' || k === 'onFailure' || v == null) continue;
+        const s = typeof v === 'string' ? v : JSON.stringify(v);
+        parts.push(k + ': ' + (s.length > 80 ? s.slice(0, 80) + '...' : s));
+      }
+      summary = parts.length > 0 ? parts.join(', ') : 'completed';
+    } else {
+      summary = 'completed';
+    }
+
+    if (ok) console.log(`\x1b[32m✓ Completed in ${elapsed}s: ${summary}\x1b[0m`);
+    else console.log(`\x1b[33m! Failed after ${elapsed}s: ${summary}\x1b[0m`);
+
+    const resultObj = {
+      success: ok, summary, outcome: ok ? 'completed' : 'failed',
+      functionName: execResult.functionName,
+      executionTime: Number(elapsed),
+    };
+
+    context.resultJson = JSON.stringify(resultObj);
+    return { onSuccess: ok, onFailure: !ok, ctx: JSON.stringify(context) };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(`\x1b[33m! Error: ${msg}\x1b[0m`);
+    context.resultJson = JSON.stringify({ success: false, summary: msg, outcome: 'error' });
+    return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };
+  }
+}

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

@@ -0,0 +1,63 @@
+import type { WeaverEnv } from '../bot/types.js';
+import { callAI, parseJsonResponse } from '../bot/ai-client.js';
+
+/**
+ * When validation fails, sends errors + context to the AI and
+ * asks it to produce a repair plan.
+ *
+ * @flowWeaver nodeType
+ * @label Fix Errors
+ * @input env [order:0] - Weaver environment bundle
+ * @input validationResultJson [order:1] - Validation results (JSON)
+ * @input taskJson [order:2] - Task (JSON, pass-through)
+ * @output env [order:0] - Weaver environment bundle (pass-through)
+ * @output fixPlanJson [order:1] - Fix plan (JSON, same schema as planJson)
+ * @output taskJson [order:2] - Task (pass-through)
+ * @output onSuccess [order:-2] - On Success
+ * @output onFailure [order:-1] - On Failure
+ */
+export async function weaverFixErrors(
+  execute: boolean,
+  env: WeaverEnv,
+  validationResultJson: string,
+  taskJson: string,
+): Promise<{
+  onSuccess: boolean; onFailure: boolean;
+  env: WeaverEnv;
+  fixPlanJson: string; taskJson: string;
+}> {
+  if (!execute) {
+    return { onSuccess: true, onFailure: false, env, taskJson, fixPlanJson: '{"steps":[],"summary":"dry run"}' };
+  }
+
+  const { providerInfo: pInfo } = env;
+  const validation = JSON.parse(validationResultJson) as Array<{ file: string; valid: boolean; errors: string[] }>;
+  const errors = validation.filter(v => !v.valid);
+
+  if (errors.length === 0) {
+    return { onSuccess: true, onFailure: false, env, taskJson, fixPlanJson: '{"steps":[],"summary":"no errors to fix"}' };
+  }
+
+  let systemPrompt: string;
+  try {
+    const mod = await import('../bot/system-prompt.js');
+    systemPrompt = await mod.buildSystemPrompt();
+  } catch {
+    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".`;
+
+  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`);
+    return { onSuccess: true, onFailure: false, env, taskJson, fixPlanJson: JSON.stringify(plan) };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`\x1b[31m→ Fix planning failed: ${msg}\x1b[0m`);
+    return { onSuccess: false, onFailure: true, env, taskJson, fixPlanJson: JSON.stringify({ steps: [], summary: `Fix failed: ${msg}` }) };
+  }
+}

package/src/node-types/genesis-apply-retry.ts

@@ -0,0 +1,133 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { GenesisConfig, GenesisContext } from '../bot/types.js';
+import { callAI, parseJsonResponse } from '../bot/ai-client.js';
+import { GenesisStore } from '../bot/genesis-store.js';
+import { getGenesisSystemPrompt, getOperationExamples } from '../bot/genesis-prompt-context.js';
+
+/**
+ * Scoped retry loop for apply + compile. Delegates the actual work to
+ * a child node via the attempt callback, and between failures restores
+ * the snapshot and asks the AI to revise the proposal.
+ *
+ * @flowWeaver nodeType
+ * @label Genesis Apply Retry
+ * @input ctx [order:0] - Genesis context (JSON)
+ * @output start scope:attempt [order:10] [hidden] - Trigger scope execution (boolean)
+ * @output attemptCtx scope:attempt [order:11] - Context for child (JSON)
+ * @input success scope:attempt [order:12] [hidden] - Success signal from child (boolean)
+ * @input failure scope:attempt [order:13] [hidden] - Failure signal from child (boolean)
+ * @input attemptCtx scope:attempt [order:14] - Result context from child (JSON)
+ * @output ctx [order:0] - Genesis context with applyResultJson (JSON)
+ * @output onSuccess [order:-2] - On Success
+ * @output onFailure [order:-1] - On Failure
+ */
+export async function genesisApplyRetry(
+  execute: boolean,
+  ctx: string,
+  attempt: (
+    start: boolean,
+    attemptCtx: string,
+  ) => Promise<{ success: boolean; failure: boolean; attemptCtx: string }>,
+): Promise<{
+  onSuccess: boolean; onFailure: boolean;
+  ctx: string;
+}> {
+  const context = JSON.parse(ctx) as GenesisContext;
+
+  if (!execute) {
+    const result = { applied: 0, failed: 0, errors: [] as string[] };
+    context.applyResultJson = JSON.stringify(result);
+    context.error = '';
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+
+  const { env } = context;
+  const maxAttempts = 3;
+  let lastResult = '';
+  let lastErrors = '';
+
+  for (let i = 1; i <= maxAttempts; i++) {
+    console.log(`\x1b[36m→ Apply attempt ${i}/${maxAttempts}\x1b[0m`);
+
+    const outcome = await attempt(true, JSON.stringify(context));
+    const childCtx = JSON.parse(outcome.attemptCtx) as GenesisContext;
+    lastResult = childCtx.applyResultJson ?? '';
+    lastErrors = childCtx.error ?? '';
+
+    if (outcome.success) {
+      context.applyResultJson = childCtx.applyResultJson;
+      context.error = '';
+      return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+    }
+
+    if (i < maxAttempts) {
+      console.log('\x1b[33m→ Requesting revised proposal from AI...\x1b[0m');
+
+      const config = JSON.parse(context.genesisConfigJson) as GenesisConfig;
+      const targetPath = path.resolve(env.projectDir, config.targetWorkflow);
+      const store = new GenesisStore(env.projectDir);
+      const snapshot = store.loadSnapshot(context.snapshotPath!);
+      if (snapshot) {
+        fs.writeFileSync(targetPath, snapshot, 'utf-8');
+      }
+
+      try {
+        const revisedProposal = await reviseProposal(
+          env, config, context.proposalJson!, lastErrors,
+          targetPath, context.workflowDescription, !!context.stabilized,
+        );
+        context.proposalJson = revisedProposal;
+        console.log('\x1b[36m→ Revised proposal received\x1b[0m');
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`\x1b[31m→ AI revision failed: ${msg}\x1b[0m`);
+        break;
+      }
+    }
+  }
+
+  const errorDesc = lastErrors
+    ? `Apply/compile failed after ${maxAttempts} attempts. Last errors: ${lastErrors}`
+    : `Apply failed after ${maxAttempts} attempts (all operations failed)`;
+
+  context.applyResultJson = lastResult;
+  context.error = errorDesc;
+  return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };
+}
+
+async function reviseProposal(
+  env: GenesisContext['env'],
+  config: GenesisConfig,
+  currentProposal: string,
+  compileErrors: string,
+  targetPath: string,
+  workflowDescription?: string,
+  stabilized?: boolean,
+): Promise<string> {
+  const { providerInfo: pInfo } = env;
+
+  const systemPrompt = await getGenesisSystemPrompt(config, !!stabilized);
+
+  const userPrompt = [
+    'The following proposal caused errors when applied. Revise it to fix these errors.',
+    '',
+    '## Current Workflow Structure',
+    workflowDescription || '(no description available)',
+    '',
+    '## Failed Proposal',
+    currentProposal,
+    '',
+    '## Errors',
+    compileErrors,
+    '',
+    getOperationExamples(targetPath),
+    '',
+    'Return the full revised proposal as JSON. Use node IDs and port names that exist in the workflow structure above.',
+  ].join('\n');
+
+  const text = await callAI(pInfo, systemPrompt, userPrompt, 8192);
+
+  const parsed = parseJsonResponse(text);
+  return JSON.stringify(parsed);
+}

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

@@ -0,0 +1,96 @@
+import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import type { WeaverEnv, GenesisConfig, GenesisProposal, GenesisOperation } from '../bot/types.js';
+
+/**
+ * Applies proposal operations to the target workflow by invoking the
+ * flow-weaver CLI modify command for each operation.
+ *
+ * @flowWeaver nodeType
+ * @label Genesis Apply
+ * @input env [order:0] - Weaver environment bundle
+ * @input genesisConfigJson [order:1] - Genesis configuration (JSON)
+ * @input proposalJson [order:2] - Genesis proposal (JSON)
+ * @input snapshotPath [order:3] - Path to the pre-apply snapshot
+ * @output env [order:0] - Weaver environment bundle (pass-through)
+ * @output genesisConfigJson [order:1] - Genesis configuration (pass-through)
+ * @output proposalJson [order:2] - Genesis proposal (pass-through)
+ * @output snapshotPath [order:3] - Path to the pre-apply snapshot (pass-through)
+ * @output applyResultJson [order:4] - Apply result (JSON)
+ * @output onSuccess [order:-2] - On Success
+ * @output onFailure [order:-1] - On Failure
+ */
+export async function genesisApply(
+  execute: boolean,
+  env: WeaverEnv,
+  genesisConfigJson: string,
+  proposalJson: string,
+  snapshotPath: string,
+): Promise<{
+  onSuccess: boolean; onFailure: boolean;
+  env: WeaverEnv;
+  genesisConfigJson: string;
+  proposalJson: string;
+  snapshotPath: string;
+  applyResultJson: string;
+}> {
+  if (!execute) {
+    const result = { applied: 0, failed: 0, errors: [] as string[] };
+    return { onSuccess: true, onFailure: false, env, genesisConfigJson, proposalJson, snapshotPath, applyResultJson: JSON.stringify(result) };
+  }
+
+  const config = JSON.parse(genesisConfigJson) as GenesisConfig;
+  const proposal = JSON.parse(proposalJson) as GenesisProposal;
+  const targetPath = path.resolve(env.projectDir, config.targetWorkflow);
+
+  let applied = 0;
+  let failed = 0;
+  const errors: string[] = [];
+
+  for (const op of proposal.operations) {
+    try {
+      const cliArgs = buildModifyArgs(op, targetPath);
+      execFileSync('flow-weaver', cliArgs, {
+        cwd: env.projectDir,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 30_000,
+      });
+      applied++;
+      console.log(`\x1b[32m  + ${op.type}: ${op.rationale}\x1b[0m`);
+    } catch (err: unknown) {
+      failed++;
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push(`${op.type}: ${msg}`);
+      console.error(`\x1b[31m  x ${op.type}: ${msg}\x1b[0m`);
+    }
+  }
+
+  const result = { applied, failed, errors };
+  const success = failed === 0 && applied > 0;
+
+  console.log(`\x1b[36m→ Apply: ${applied} succeeded, ${failed} failed\x1b[0m`);
+
+  return {
+    onSuccess: success, onFailure: !success,
+    env, genesisConfigJson, proposalJson, snapshotPath,
+    applyResultJson: JSON.stringify(result),
+  };
+}
+
+function buildModifyArgs(op: GenesisOperation, targetPath: string): string[] {
+  switch (op.type) {
+    case 'addNode':
+      return ['modify', 'addNode', '--file', targetPath, '--nodeId', String(op.args.nodeId), '--nodeType', String(op.args.nodeType)];
+    case 'removeNode':
+      return ['modify', 'removeNode', '--file', targetPath, '--nodeId', String(op.args.nodeId)];
+    case 'addConnection':
+      return ['modify', 'addConnection', '--file', targetPath, '--from', String(op.args.from), '--to', String(op.args.to)];
+    case 'removeConnection':
+      return ['modify', 'removeConnection', '--file', targetPath, '--from', String(op.args.from), '--to', String(op.args.to)];
+    case 'implementNode':
+      return ['implement', targetPath, '--nodeId', String(op.args.nodeId)];
+    default:
+      throw new Error(`Unknown genesis operation type: ${op.type}`);
+  }
+}

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

@@ -0,0 +1,73 @@
+import type { GenesisProposal, GenesisContext } from '../bot/types.js';
+
+/**
+ * Handles approval for genesis proposals. Auto-approves when approval
+ * is not required or when config approval mode is 'auto'. Otherwise
+ * displays the proposal summary and diff, then rejects (non-interactive
+ * environments cannot prompt).
+ *
+ * @flowWeaver nodeType
+ * @label Genesis Approve
+ * @input ctx [order:0] - Genesis context (JSON)
+ * @output ctx [order:0] - Genesis context with approved (JSON)
+ * @output onSuccess [order:-2] - On Success
+ * @output onFailure [order:-1] [hidden] - On Failure
+ */
+export async function genesisApprove(
+  execute: boolean,
+  ctx: string,
+): Promise<{
+  onSuccess: boolean; onFailure: boolean;
+  ctx: string;
+}> {
+  const context = JSON.parse(ctx) as GenesisContext;
+
+  if (!execute) {
+    context.approved = true;
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+
+  // Auto-approve when approval is not required
+  if (!context.approvalRequired) {
+    console.log('\x1b[32m→ Auto-approved (below threshold)\x1b[0m');
+    context.approved = true;
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+
+  const { config } = context.env;
+  // Match the same default as runner.ts resolveApproval: no approval field = 'auto'
+  const approvalMode = !config.approval || config.approval === 'auto'
+    ? 'auto'
+    : typeof config.approval === 'string'
+      ? config.approval
+      : config.approval.mode;
+
+  // Display proposal summary
+  const proposal = JSON.parse(context.proposalJson!) as GenesisProposal;
+  const diffData = JSON.parse(context.workflowDiffJson!) as { diff: string };
+
+  console.log('\n\x1b[1m┌─ Genesis Proposal ─────────────────────┐\x1b[0m');
+  console.log(`\x1b[1m│\x1b[0m Impact: ${proposal.impactLevel}`);
+  console.log(`\x1b[1m│\x1b[0m Summary: ${proposal.summary}`);
+  console.log(`\x1b[1m│\x1b[0m Operations: ${proposal.operations.length} (cost: ${proposal.totalCost})`);
+  for (const op of proposal.operations) {
+    console.log(`\x1b[1m│\x1b[0m  ${op.type}: ${op.rationale}`);
+  }
+  console.log('\x1b[1m├─ Diff ─────────────────────────────────┤\x1b[0m');
+  for (const line of diffData.diff.split('\n').slice(0, 20)) {
+    console.log(`\x1b[1m│\x1b[0m ${line}`);
+  }
+  console.log('\x1b[1m└────────────────────────────────────────┘\x1b[0m\n');
+
+  // Auto mode approves automatically
+  if (approvalMode === 'auto') {
+    console.log('\x1b[32m→ Auto-approved (approval mode: auto)\x1b[0m');
+    context.approved = true;
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+
+  // Non-auto modes reject in non-interactive context
+  console.log('\x1b[33m→ Rejected (approval required, non-auto mode)\x1b[0m');
+  context.approved = false;
+  return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+}

package/src/node-types/genesis-check-stabilize.ts

@@ -0,0 +1,37 @@
+import type { GenesisConfig, GenesisContext } from '../bot/types.js';
+import { GenesisStore } from '../bot/genesis-store.js';
+
+/**
+ * Determines whether genesis should enter stabilize mode. This happens
+ * when the config flag is set or when the last 3 cycles were all
+ * rollbacks or rejections.
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Genesis Check Stabilize
+ * @input ctx [order:0] - Genesis context (JSON)
+ * @output ctx [order:0] - Genesis context with stabilized (JSON)
+ * @output onFailure [hidden]
+ */
+export function genesisCheckStabilize(ctx: string): { ctx: string } {
+  const context = JSON.parse(ctx) as GenesisContext;
+  const config = JSON.parse(context.genesisConfigJson) as GenesisConfig;
+
+  if (config.stabilize) {
+    console.log('\x1b[33m→ Stabilize mode: enabled by config\x1b[0m');
+    context.stabilized = true;
+    return { ctx: JSON.stringify(context) };
+  }
+
+  const store = new GenesisStore(context.env.projectDir);
+  const recent = store.getRecentOutcomes(3);
+
+  if (recent.length >= 3 && recent.every(o => o === 'rolled-back' || o === 'rejected')) {
+    console.log('\x1b[33m→ Stabilize mode: 3+ consecutive rollbacks/rejections\x1b[0m');
+    context.stabilized = true;
+    return { ctx: JSON.stringify(context) };
+  }
+
+  context.stabilized = false;
+  return { ctx: JSON.stringify(context) };
+}