@synergenius/flow-weaver-pack-weaver 0.9.59 → 0.9.77

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

@@ -0,0 +1,187 @@
+/**
+ * Task Pool List — hierarchical task list for the Swarm Dashboard.
+ *
+ * Displays tasks sorted by priority DESC then createdAt ASC.
+ * Parent tasks show at top level; subtasks are indented below their parent.
+ * Each row shows status icon, title (clickable), assigned bot tags, and priority badge.
+ */
+const React = require('react');
+const { useState } = React;
+const { Flex, Typography, Icon, StatusIcon, Tag, ScrollArea, Badge, EmptyState } = require('@fw/plugin-ui-kit');
+
+// --- Types ---
+
+type TaskStatus = 'pending' | 'in-progress' | 'blocked' | 'done' | 'failed' | 'cancelled';
+
+interface Task {
+  id: string;
+  title: string;
+  status: TaskStatus;
+  priority: number;
+  isParent: boolean;
+  parentId?: string;
+  assignedProfile?: string;
+  createdAt: string;
+}
+
+interface TaskPoolListProps {
+  tasks: Task[];
+  onTaskClick: (taskId: string) => void;
+}
+
+// --- Status mapping ---
+
+const statusToIcon: Record<TaskStatus, string> = {
+  'pending': 'pending',
+  'in-progress': 'running',
+  'done': 'completed',
+  'failed': 'failed',
+  'blocked': 'pending',
+  'cancelled': 'failed',
+};
+
+// --- Row styles ---
+
+const rowBaseStyle: React.CSSProperties = {
+  padding: '8px 12px',
+  cursor: 'pointer',
+  borderBottom: '1px solid var(--color-border-default)',
+};
+
+const indentedRowStyle: React.CSSProperties = {
+  ...rowBaseStyle,
+  paddingLeft: '32px',
+};
+
+// --- Sorting ---
+
+function sortTasks(tasks: Task[]): Task[] {
+  return [...tasks].sort((a, b) => {
+    // Priority DESC (higher priority first)
+    if (b.priority !== a.priority) return b.priority - a.priority;
+    // CreatedAt ASC (older first)
+    return a.createdAt.localeCompare(b.createdAt);
+  });
+}
+
+// --- Build hierarchical list ---
+
+function buildHierarchy(tasks: Task[]): Array<{ task: Task; indent: boolean }> {
+  const sorted = sortTasks(tasks);
+
+  // Separate top-level tasks and subtasks
+  const topLevel = sorted.filter((t) => !t.parentId);
+  const subtasksByParent = new Map<string, Task[]>();
+
+  for (const t of sorted) {
+    if (t.parentId) {
+      const existing = subtasksByParent.get(t.parentId) || [];
+      existing.push(t);
+      subtasksByParent.set(t.parentId, existing);
+    }
+  }
+
+  const result: Array<{ task: Task; indent: boolean }> = [];
+  for (const parent of topLevel) {
+    result.push({ task: parent, indent: false });
+    const children = subtasksByParent.get(parent.id);
+    if (children) {
+      for (const child of children) {
+        result.push({ task: child, indent: true });
+      }
+    }
+  }
+
+  // Any orphaned subtasks (parentId set but parent not in list)
+  const topLevelIds = new Set(topLevel.map((t) => t.id));
+  for (const t of sorted) {
+    if (t.parentId && !topLevelIds.has(t.parentId)) {
+      result.push({ task: t, indent: false });
+    }
+  }
+
+  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, {
+      icon: 'inbox',
+      message: 'No tasks in the pool.',
+    });
+  }
+
+  const rows = buildHierarchy(tasks);
+
+  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(TaskRowItem, {
+          key: task.id,
+          task,
+          indent,
+          onClick: () => onTaskClick(task.id),
+        }),
+      ),
+    ),
+  );
+}
+
+export { TaskPoolList };
+export default TaskPoolList;
+module.exports = TaskPoolList;

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