@synergenius/flow-weaver-pack-weaver 0.9.62 → 0.9.78

package/src/ui/task-pool-list.tsx

@@ -6,8 +6,8 @@
  * Each row shows status icon, title (clickable), assigned bot tags, and priority badge.
  */
 const React = require('react');
-const { Flex, Typography, Icon, StatusIcon, Tag, ScrollArea, Badge } = require('@fw/plugin-ui-kit');
-const { styled } = require('@fw/plugin-theme');
+const { useState } = React;
+const { Flex, Typography, Icon, StatusIcon, Tag, ScrollArea, Badge, EmptyState } = require('@fw/plugin-ui-kit');
 
 // --- Types ---
 
@@ -20,7 +20,7 @@ interface Task {
   priority: number;
   isParent: boolean;
   parentId?: string;
-  assignedBots: string[];
+  assignedProfile?: string;
   createdAt: string;
 }
 
@@ -40,57 +40,18 @@ const statusToIcon: Record<TaskStatus, string> = {
   'cancelled': 'failed',
 };
 
-const statusToColor: Record<TaskStatus, string> = {
-  'pending': 'color-text-subtle',
-  'in-progress': 'color-status-info',
-  'done': 'color-status-positive',
-  'failed': 'color-status-negative',
-  'blocked': 'color-status-caution',
-  'cancelled': 'color-text-subtle',
-};
-
-// --- Styled components ---
+// --- Row styles ---
 
-const Container = styled.div({
-  display: 'flex',
-  flexDirection: 'column',
-  height: '100%',
-  overflow: 'hidden',
-});
-
-const TaskRow = styled.div({
-  display: 'flex',
-  alignItems: 'center',
-  gap: '8px',
+const rowBaseStyle: React.CSSProperties = {
   padding: '8px 12px',
   cursor: 'pointer',
-  borderBottom: '1px solid $color-border-default',
-  '&:hover': { backgroundColor: '$color-surface-elevated' },
-});
-
-const TitleText = styled.div({
-  flex: 1,
-  overflow: 'hidden',
-  textOverflow: 'ellipsis',
-  whiteSpace: 'nowrap',
-  minWidth: 0,
-});
-
-const BotTags = styled.div({
-  display: 'flex',
-  gap: '4px',
-  flexShrink: 0,
-});
-
-const EmptyState = styled.div({
-  display: 'flex',
-  flexDirection: 'column',
-  alignItems: 'center',
-  justifyContent: 'center',
-  gap: '8px',
-  padding: '24px 16px',
-  flex: 1,
-});
+  borderBottom: '1px solid var(--color-border-default)',
+};
+
+const indentedRowStyle: React.CSSProperties = {
+  ...rowBaseStyle,
+  paddingLeft: '32px',
+};
 
 // --- Sorting ---
 
@@ -142,62 +103,80 @@ function buildHierarchy(tasks: Task[]): Array<{ task: Task; indent: boolean }> {
   return result;
 }
 
+// --- Task Row component with hover ---
+
+function TaskRowItem({ task, indent, onClick }: { task: Task; indent: boolean; onClick: () => void }) {
+  const [hovered, setHovered] = useState(false);
+  const style: React.CSSProperties = {
+    ...(indent ? indentedRowStyle : rowBaseStyle),
+    ...(hovered ? { backgroundColor: 'var(--color-surface-elevated)' } : undefined),
+  };
+
+  return React.createElement(Flex, {
+    variant: 'row-center-start-nowrap-8',
+    style,
+    onClick,
+    onMouseEnter: () => setHovered(true),
+    onMouseLeave: () => setHovered(false),
+  },
+    // Status icon
+    React.createElement(StatusIcon, {
+      status: statusToIcon[task.status] || 'pending',
+      size: 'sm',
+    }),
+
+    // Title
+    React.createElement(Flex, {
+      variant: 'row-center-start-nowrap-0',
+      style: { flex: 1, minWidth: 0 },
+    },
+      React.createElement(Typography, {
+        variant: 'caption-regular',
+        color: task.status === 'cancelled'
+          ? 'color-text-subtle'
+          : 'color-text-high',
+        truncate: true,
+        style: task.status === 'cancelled' ? { textDecoration: 'line-through', opacity: 0.6 } : undefined,
+      }, task.title),
+    ),
+
+    // Assigned profile as Tag
+    task.assignedProfile && React.createElement(Tag, {
+      size: 'small',
+      color: 'info',
+    }, task.assignedProfile),
+
+    // Priority badge (only if > 0)
+    task.priority > 0 && React.createElement(Badge, {
+      variant: task.priority >= 3 ? 'warning' : 'info',
+    }, `P${task.priority}`),
+  );
+}
+
 // --- Component ---
 
 function TaskPoolList({ tasks, onTaskClick }: TaskPoolListProps) {
   if (!tasks || tasks.length === 0) {
-    return React.createElement(EmptyState, null,
-      React.createElement(Icon, { name: 'inbox', size: 20, color: 'color-text-subtle' }),
-      React.createElement(Typography, {
-        variant: 'caption-regular',
-        color: 'color-text-subtle',
-      }, 'No tasks in the pool.'),
-    );
+    return React.createElement(EmptyState, {
+      icon: 'inbox',
+      message: 'No tasks in the pool.',
+    });
   }
 
   const rows = buildHierarchy(tasks);
 
-  return React.createElement(Container, null,
+  return React.createElement(Flex, {
+    variant: 'column-stretch-start-nowrap-0',
+    style: { height: '100%', overflow: 'hidden' },
+  },
     React.createElement(ScrollArea, { style: { flex: 1 } },
       rows.map(({ task, indent }) =>
-        React.createElement(TaskRow, {
+        React.createElement(TaskRowItem, {
           key: task.id,
-          style: indent ? { paddingLeft: '32px' } : undefined,
+          task,
+          indent,
           onClick: () => onTaskClick(task.id),
-        },
-          // Status icon
-          React.createElement(StatusIcon, {
-            status: statusToIcon[task.status] || 'pending',
-            size: 'sm',
-          }),
-
-          // Title
-          React.createElement(TitleText, null,
-            React.createElement(Typography, {
-              variant: 'caption-regular',
-              color: statusToColor[task.status] === 'color-text-subtle' && task.status === 'cancelled'
-                ? 'color-text-subtle'
-                : 'color-text-high',
-              style: task.status === 'cancelled' ? { textDecoration: 'line-through', opacity: 0.6 } : undefined,
-            }, task.title),
-          ),
-
-          // Assigned bots as Tags
-          task.assignedBots.length > 0 && React.createElement(BotTags, null,
-            task.assignedBots.map((botId: string) =>
-              React.createElement(Tag, {
-                key: botId,
-                size: 'small',
-                color: 'info',
-              }, botId),
-            ),
-          ),
-
-          // Priority badge (only if > 0)
-          task.priority > 0 && React.createElement(Badge, {
-            variant: task.priority >= 3 ? 'warning' : 'info',
-          }, `P${task.priority}`),
-        ),
+        }),
       ),
     ),
   );

package/src/workflows/orchestrator.ts

@@ -0,0 +1,302 @@
+import { orchestratorLoadState } from '../node-types/orchestrator-load-state.js';
+import { orchestratorRoute } from '../node-types/orchestrator-route.js';
+import { orchestratorDispatch } from '../node-types/orchestrator-dispatch.js';
+
+// @flow-weaver-runtime-start
+// ============================================================================
+// DO NOT EDIT - This section is auto-generated by Flow Weaver
+// ============================================================================
+
+import { GeneratedExecutionContext, CancellationError } from '@synergenius/flow-weaver/runtime';
+import type { TDebugger, TDebugController } from '@synergenius/flow-weaver/runtime';
+declare const __flowWeaverDebugger__: TDebugger | undefined;
+// @flow-weaver-runtime-end
+
+/**
+ * @flowWeaver workflow
+ * @node load orchestratorLoadState [position: 200 300]
+ * @node route orchestratorRoute [position: 450 300]
+ * @node dispatch orchestratorDispatch [position: 700 300]
+ * @path Start -> load -> route -> dispatch -> Exit
+ * @position Start 0 0
+ * @position Exit 1080 0
+ * @connect dispatch.results -> Exit.results
+ * @param execute [order:-1] - Execute
+ * @param projectDir [order:0] - ProjectDir
+ * @returns onSuccess [order:-1] - On Success
+ * @returns results [order:0] - Results
+ */
+export async function orchestratorWorkflow(
+  execute: boolean,
+  params: { projectDir: string },
+  __abortSignal__?: AbortSignal,
+): Promise<{ onSuccess: boolean; results: string | null }> {
+  // @flow-weaver-body-start
+  // ============================================================================
+  // DO NOT EDIT - This section is auto-generated by Flow Weaver
+  // Edit the @flowWeaver annotations above to modify workflow behavior
+  // ============================================================================
+
+    const __effectiveDebugger__ = typeof __flowWeaverDebugger__ !== 'undefined' ? __flowWeaverDebugger__ : undefined;
+
+    // Recursion depth protection
+    const __rd__ = (params as { __rd__?: number }).__rd__ ?? 0;
+    if (__rd__ >= 1000) {
+      throw new Error('Max recursion depth exceeded (1000) in workflow "orchestratorWorkflow"');
+    }
+
+    const ctx = new GeneratedExecutionContext(true, __effectiveDebugger__, __abortSignal__);
+
+    // Debug controller for step-through debugging and checkpoint/resume
+    const __ctrl__: TDebugController = (
+      typeof globalThis !== 'undefined' && (globalThis as unknown as { __fw_debug_controller__?: TDebugController }).__fw_debug_controller__
+        ? (globalThis as unknown as { __fw_debug_controller__?: TDebugController }).__fw_debug_controller__
+        : { beforeNode: () => true, afterNode: () => {} }
+    )!;
+
+    const startIdx = ctx.addExecution('Start');
+    await ctx.setVariable({ id: 'Start', portName: 'execute', executionIndex: startIdx, nodeTypeName: 'Start' }, execute);
+    await ctx.setVariable({ id: 'Start', portName: 'projectDir', executionIndex: startIdx, nodeTypeName: 'Start' }, params.projectDir);
+    await ctx.sendStatusChangedEvent({
+      nodeTypeName: 'Start',
+      id: 'Start',
+      executionIndex: startIdx,
+      status: 'SUCCEEDED',
+    });
+
+    let loadIdx: number | undefined;
+    let routeIdx: number | undefined;
+    let dispatchIdx: number | undefined;
+
+    let load_success = false;
+    let route_success = false;
+
+    if (await __ctrl__.beforeNode('load', ctx)) {
+
+      // ── load (orchestratorLoadState) ──
+      ctx.checkAborted('load');
+      loadIdx = ctx.addExecution('load');
+      if (typeof globalThis !== 'undefined') (globalThis as unknown as { __fw_current_node_id__?: string }).__fw_current_node_id__ = 'load';
+      await ctx.sendStatusChangedEvent({
+        nodeTypeName: 'orchestratorLoadState',
+        id: 'load',
+        executionIndex: loadIdx,
+        status: 'RUNNING',
+      });
+
+      load_success = false;
+
+      try {
+        const load_execute = await ctx.getVariable({ id: 'Start', portName: 'execute', executionIndex: startIdx }) as boolean;
+        await ctx.setVariable({ id: 'load', portName: 'execute', executionIndex: loadIdx, nodeTypeName: 'orchestratorLoadState' }, load_execute);
+        const load_projectDir = await ctx.getVariable({ id: 'Start', portName: 'projectDir', executionIndex: startIdx }) as string;
+        await ctx.setVariable({ id: 'load', portName: 'projectDir', executionIndex: loadIdx, nodeTypeName: 'orchestratorLoadState' }, load_projectDir);
+        const loadResult = await orchestratorLoadState(load_execute, load_projectDir);
+        await ctx.setVariable({ id: 'load', portName: 'state', executionIndex: loadIdx, nodeTypeName: 'orchestratorLoadState' }, loadResult.state);
+        await ctx.setVariable({ id: 'load', portName: 'onSuccess', executionIndex: loadIdx, nodeTypeName: 'orchestratorLoadState' }, loadResult.onSuccess);
+        await ctx.setVariable({ id: 'load', portName: 'onFailure', executionIndex: loadIdx, nodeTypeName: 'orchestratorLoadState' }, loadResult.onFailure);
+        await ctx.sendStatusChangedEvent({
+          nodeTypeName: 'orchestratorLoadState',
+          id: 'load',
+          executionIndex: loadIdx,
+          status: 'SUCCEEDED',
+        });
+        await __ctrl__.afterNode('load', ctx);
+        load_success = loadResult.onSuccess;
+      } catch (error: unknown) {
+        const isCancellation = CancellationError.isCancellationError(error);
+        await ctx.sendStatusChangedEvent({
+          nodeTypeName: 'orchestratorLoadState',
+          id: 'load',
+          executionIndex: loadIdx,
+          status: isCancellation ? 'CANCELLED' : 'FAILED',
+        });
+        if (!isCancellation) {
+          ctx.sendLogErrorEvent({
+            nodeTypeName: 'orchestratorLoadState',
+            id: 'load',
+            executionIndex: loadIdx,
+            error: error instanceof Error ? error.message : String(error),
+          });
+          await ctx.setVariable({ id: 'load', portName: 'onSuccess', executionIndex: loadIdx, nodeTypeName: 'orchestratorLoadState' }, false);
+          await ctx.setVariable({ id: 'load', portName: 'onFailure', executionIndex: loadIdx, nodeTypeName: 'orchestratorLoadState' }, true);
+          load_success = false;
+        }
+        throw error;
+      }
+    } else {
+      loadIdx = ctx.addExecution('load');
+      load_success = true;
+    }
+
+    if (load_success) {
+      if (await __ctrl__.beforeNode('route', ctx)) {
+
+        // ── route (orchestratorRoute) ──
+        ctx.checkAborted('route');
+        routeIdx = ctx.addExecution('route');
+        if (typeof globalThis !== 'undefined') (globalThis as unknown as { __fw_current_node_id__?: string }).__fw_current_node_id__ = 'route';
+        await ctx.sendStatusChangedEvent({
+          nodeTypeName: 'orchestratorRoute',
+          id: 'route',
+          executionIndex: routeIdx,
+          status: 'RUNNING',
+        });
+
+        route_success = false;
+
+        try {
+          const route_execute = loadIdx !== undefined ? await ctx.getVariable({ id: 'load', portName: 'onSuccess', executionIndex: loadIdx }) as boolean : false;
+          await ctx.setVariable({ id: 'route', portName: 'execute', executionIndex: routeIdx, nodeTypeName: 'orchestratorRoute' }, route_execute);
+          const route_state = await ctx.getVariable({ id: 'load', portName: 'state', executionIndex: loadIdx! }) as string;
+          await ctx.setVariable({ id: 'route', portName: 'state', executionIndex: routeIdx, nodeTypeName: 'orchestratorRoute' }, route_state);
+          const routeResult = await orchestratorRoute(route_execute, route_state);
+          await ctx.setVariable({ id: 'route', portName: 'decisions', executionIndex: routeIdx, nodeTypeName: 'orchestratorRoute' }, routeResult.decisions);
+          await ctx.setVariable({ id: 'route', portName: 'onSuccess', executionIndex: routeIdx, nodeTypeName: 'orchestratorRoute' }, routeResult.onSuccess);
+          await ctx.setVariable({ id: 'route', portName: 'onFailure', executionIndex: routeIdx, nodeTypeName: 'orchestratorRoute' }, routeResult.onFailure);
+          await ctx.sendStatusChangedEvent({
+            nodeTypeName: 'orchestratorRoute',
+            id: 'route',
+            executionIndex: routeIdx,
+            status: 'SUCCEEDED',
+          });
+          await __ctrl__.afterNode('route', ctx);
+          route_success = routeResult.onSuccess;
+        } catch (error: unknown) {
+          const isCancellation = CancellationError.isCancellationError(error);
+          await ctx.sendStatusChangedEvent({
+            nodeTypeName: 'orchestratorRoute',
+            id: 'route',
+            executionIndex: routeIdx,
+            status: isCancellation ? 'CANCELLED' : 'FAILED',
+          });
+          if (!isCancellation) {
+            ctx.sendLogErrorEvent({
+              nodeTypeName: 'orchestratorRoute',
+              id: 'route',
+              executionIndex: routeIdx,
+              error: error instanceof Error ? error.message : String(error),
+            });
+            await ctx.setVariable({ id: 'route', portName: 'onSuccess', executionIndex: routeIdx, nodeTypeName: 'orchestratorRoute' }, false);
+            await ctx.setVariable({ id: 'route', portName: 'onFailure', executionIndex: routeIdx, nodeTypeName: 'orchestratorRoute' }, true);
+            route_success = false;
+          }
+          throw error;
+        }
+      } else {
+        routeIdx = ctx.addExecution('route');
+        route_success = true;
+      }
+
+    } else {
+      const routeIdx = ctx.addExecution('route');
+      await ctx.setVariable({ id: 'route', portName: 'onSuccess', executionIndex: routeIdx, nodeTypeName: 'orchestratorRoute' }, false);
+      await ctx.setVariable({ id: 'route', portName: 'onFailure', executionIndex: routeIdx, nodeTypeName: 'orchestratorRoute' }, false);
+      await ctx.sendStatusChangedEvent({
+        nodeTypeName: 'orchestratorRoute',
+        id: 'route',
+        executionIndex: routeIdx,
+        status: 'CANCELLED',
+      });
+      const dispatchIdx = ctx.addExecution('dispatch');
+      await ctx.setVariable({ id: 'dispatch', portName: 'onSuccess', executionIndex: dispatchIdx, nodeTypeName: 'orchestratorDispatch' }, false);
+      await ctx.setVariable({ id: 'dispatch', portName: 'onFailure', executionIndex: dispatchIdx, nodeTypeName: 'orchestratorDispatch' }, false);
+      await ctx.sendStatusChangedEvent({
+        nodeTypeName: 'orchestratorDispatch',
+        id: 'dispatch',
+        executionIndex: dispatchIdx,
+        status: 'CANCELLED',
+      });
+    }
+    if (load_success && route_success) {
+      if (await __ctrl__.beforeNode('dispatch', ctx)) {
+
+        // ── dispatch (orchestratorDispatch) ──
+        ctx.checkAborted('dispatch');
+        dispatchIdx = ctx.addExecution('dispatch');
+        if (typeof globalThis !== 'undefined') (globalThis as unknown as { __fw_current_node_id__?: string }).__fw_current_node_id__ = 'dispatch';
+        await ctx.sendStatusChangedEvent({
+          nodeTypeName: 'orchestratorDispatch',
+          id: 'dispatch',
+          executionIndex: dispatchIdx,
+          status: 'RUNNING',
+        });
+
+        try {
+          const dispatch_execute = routeIdx !== undefined ? await ctx.getVariable({ id: 'route', portName: 'onSuccess', executionIndex: routeIdx }) as boolean : false;
+          await ctx.setVariable({ id: 'dispatch', portName: 'execute', executionIndex: dispatchIdx, nodeTypeName: 'orchestratorDispatch' }, dispatch_execute);
+          const dispatch_decisions = await ctx.getVariable({ id: 'route', portName: 'decisions', executionIndex: routeIdx! }) as string;
+          await ctx.setVariable({ id: 'dispatch', portName: 'decisions', executionIndex: dispatchIdx, nodeTypeName: 'orchestratorDispatch' }, dispatch_decisions);
+          const dispatch_projectDir = await ctx.getVariable({ id: 'Start', portName: 'projectDir', executionIndex: startIdx }) as string;
+          await ctx.setVariable({ id: 'dispatch', portName: 'projectDir', executionIndex: dispatchIdx, nodeTypeName: 'orchestratorDispatch' }, dispatch_projectDir);
+          const dispatchResult = await orchestratorDispatch(dispatch_execute, dispatch_decisions, dispatch_projectDir);
+          await ctx.setVariable({ id: 'dispatch', portName: 'results', executionIndex: dispatchIdx, nodeTypeName: 'orchestratorDispatch' }, dispatchResult.results);
+          await ctx.setVariable({ id: 'dispatch', portName: 'onSuccess', executionIndex: dispatchIdx, nodeTypeName: 'orchestratorDispatch' }, dispatchResult.onSuccess);
+          await ctx.setVariable({ id: 'dispatch', portName: 'onFailure', executionIndex: dispatchIdx, nodeTypeName: 'orchestratorDispatch' }, dispatchResult.onFailure);
+          await ctx.sendStatusChangedEvent({
+            nodeTypeName: 'orchestratorDispatch',
+            id: 'dispatch',
+            executionIndex: dispatchIdx,
+            status: 'SUCCEEDED',
+          });
+          await __ctrl__.afterNode('dispatch', ctx);
+        } catch (error: unknown) {
+          const isCancellation = CancellationError.isCancellationError(error);
+          await ctx.sendStatusChangedEvent({
+            nodeTypeName: 'orchestratorDispatch',
+            id: 'dispatch',
+            executionIndex: dispatchIdx,
+            status: isCancellation ? 'CANCELLED' : 'FAILED',
+          });
+          if (!isCancellation) {
+            ctx.sendLogErrorEvent({
+              nodeTypeName: 'orchestratorDispatch',
+              id: 'dispatch',
+              executionIndex: dispatchIdx,
+              error: error instanceof Error ? error.message : String(error),
+            });
+            await ctx.setVariable({ id: 'dispatch', portName: 'onSuccess', executionIndex: dispatchIdx, nodeTypeName: 'orchestratorDispatch' }, false);
+            await ctx.setVariable({ id: 'dispatch', portName: 'onFailure', executionIndex: dispatchIdx, nodeTypeName: 'orchestratorDispatch' }, true);
+          }
+          throw error;
+        }
+      } else {
+        dispatchIdx = ctx.addExecution('dispatch');
+      }
+
+    } else {
+      const dispatchIdx = ctx.addExecution('dispatch');
+      await ctx.setVariable({ id: 'dispatch', portName: 'onSuccess', executionIndex: dispatchIdx, nodeTypeName: 'orchestratorDispatch' }, false);
+      await ctx.setVariable({ id: 'dispatch', portName: 'onFailure', executionIndex: dispatchIdx, nodeTypeName: 'orchestratorDispatch' }, false);
+      await ctx.sendStatusChangedEvent({
+        nodeTypeName: 'orchestratorDispatch',
+        id: 'dispatch',
+        executionIndex: dispatchIdx,
+        status: 'CANCELLED',
+      });
+    }
+    const exitIdx = ctx.addExecution('Exit');
+    const exit_results = dispatchIdx !== undefined ? await ctx.getVariable({ id: 'dispatch', portName: 'results', executionIndex: dispatchIdx }) : undefined;
+    await ctx.setVariable({ id: 'Exit', portName: 'results', executionIndex: exitIdx, nodeTypeName: 'Exit' }, exit_results);
+    const exit_onSuccess = dispatchIdx !== undefined ? await ctx.getVariable({ id: 'dispatch', portName: 'onSuccess', executionIndex: dispatchIdx }) : false;
+    await ctx.setVariable({ id: 'Exit', portName: 'onSuccess', executionIndex: exitIdx, nodeTypeName: 'Exit' }, exit_onSuccess);
+
+    await ctx.setVariable({ id: 'Exit', portName: 'onFailure', executionIndex: exitIdx, nodeTypeName: 'Exit' }, false);
+    const finalResult = { onFailure: false, results: exit_results as string, onSuccess: exit_onSuccess as boolean };
+
+    await ctx.sendStatusChangedEvent({
+      nodeTypeName: 'Exit',
+      id: 'Exit',
+      executionIndex: exitIdx,
+      status: 'SUCCEEDED',
+    });
+    ctx.sendWorkflowCompletedEvent({
+      executionIndex: exitIdx,
+      status: 'SUCCEEDED',
+      result: finalResult,
+    });
+
+    return finalResult;
+  // @flow-weaver-body-end
+  return { onSuccess: false, results: null };
+}

package/dist/docs/weaver-bot-usage.md

@@ -1,34 +0,0 @@
-## Weaver Bot
-
-The Weaver bot is an autonomous AI agent that creates and modifies Flow Weaver workflows from natural language instructions.
-
-### Running the bot
-
-Use `fw_weaver_bot` with a task description:
-- `task`: Natural language instruction (required)
-- `mode`: `create` (new workflow), `modify` (edit existing), `read` (analyze), `batch` (multiple tasks)
-- `targets`: File paths for modify/read mode
-- `autoApprove`: Skip the approval gate (default: true in studio)
-
-### Execution flow
-
-1. **Receive task** — parses instruction and determines mode
-2. **Build context** — gathers project state, templates, and relevant files
-3. **Plan** — AI generates a step-by-step execution plan
-4. **Approval gate** — plan shown for review (skipped if autoApprove)
-5. **Execute + validate + retry** — runs steps, validates output, retries on errors (up to 3 attempts)
-6. **Git ops** — commits changes if successful
-7. **Report** — returns summary with outcome
-
-### Steering a running bot
-
-Use `fw_weaver_steer` to control execution:
-- `pause` — pause at next safe point
-- `resume` — continue after pause
-- `cancel` — abort execution
-- `redirect` — change task mid-execution
-- `queue` — add a follow-up task
-
-### Checking status
-
-Use `fw_weaver_status` to see the current bot session state, active task, and completion count.

package/dist/docs/weaver-genesis.md

@@ -1,32 +0,0 @@
-## Genesis Self-Evolution
-
-Genesis is Weaver's self-evolution protocol. It autonomously observes, proposes, applies, and validates changes to workflows.
-
-### Running a Genesis cycle
-
-Use `fw_weaver_genesis` to trigger a single cycle:
-- `projectDir`: Project directory (defaults to workspace)
-- `dryRun`: Preview changes without applying
-
-### How it works
-
-1. **Observe** — scans project for workflows and their health
-2. **Fingerprint** — detects if workflows changed since last cycle (avoids duplicate proposals)
-3. **Stabilize check** — prevents rapid churn (cooldown between cycles)
-4. **Propose** — AI analyzes project state and proposes modifications within a budget
-5. **Validate proposal** — checks proposed changes are safe
-6. **Snapshot** — creates backup before applying
-7. **Apply** — executes proposed operations via `flow-weaver modify`
-8. **Validate result** — compiles and validates the modified workflow
-9. **Threshold check** — decides if changes meet the quality bar
-10. **Approve** — human approval gate (configurable)
-11. **Commit** — git commit with rollback capability
-12. **Escrow** — data safety pipeline for recovery
-
-### Safety features
-
-- Pre-apply snapshots for rollback
-- Escrow recovery from previous cycles
-- Fingerprinting prevents duplicate proposals
-- Threshold checking before committing
-- Budget limits on proposed changes

package/dist/docs/weaver-task-queue.md

@@ -1,34 +0,0 @@
-## Task Queue & Steering
-
-Weaver supports queuing tasks for background processing and steering running bots in real-time.
-
-### Task queue
-
-Use `fw_weaver_queue` to manage tasks:
-- `add` — add a task to the queue (requires `task` instruction)
-- `list` — show all queued tasks
-- `clear` — remove all pending tasks
-- `remove` — remove a specific task by ID
-
-Tasks are stored in NDJSON format and processed sequentially by the bot session.
-
-### Steering commands
-
-Use `fw_weaver_steer` to control a running bot:
-- `pause` — pause execution at the next safe point
-- `resume` — continue after a pause
-- `cancel` — abort the current task
-- `redirect` — change the task instruction mid-execution (requires `payload` with new instruction)
-- `queue` — add a follow-up task without interrupting the current one
-
-### Batch mode
-
-For multiple related tasks, use `fw_weaver_bot` with `mode: "batch"` to process them in sequence through the same bot session, sharing context between tasks.
-
-### Monitoring
-
-Use `fw_weaver_status` to check the current session state:
-- Session phase (idle, planning, executing, validating)
-- Current task instruction
-- Completed task count
-- Error state if any

package/src/bot/error-guide.ts

@@ -1,4 +0,0 @@
-/**
- * @deprecated Use error-classifier.ts instead. This file re-exports for backward compatibility.
- */
-export { getErrorGuidance } from './error-classifier.js';

package/src/bot/retry-utils.ts

@@ -1,4 +0,0 @@
-/**
- * @deprecated Use error-classifier.ts instead. This file re-exports for backward compatibility.
- */
-export { isTransientError, withRetry } from './error-classifier.js';