@synergenius/flow-weaver-pack-weaver 0.9.34 → 0.9.35

package/src/ai-chat-provider.ts

@@ -12,6 +12,7 @@ import { runWorkflow } from './bot/runner.js';
 import { RunStore } from './bot/run-store.js';
 import { CostStore } from './bot/cost-store.js';
 import { defaultRegistry, discoverProviders } from './bot/provider-registry.js';
+import { runRegistry } from './bot/run-registry.js';
 
 interface AiChatToolContext {
   workspacePath: string;
@@ -137,17 +138,21 @@ const toolHandlers: Record<
     // Fire-and-forget: start workflow in background, events stream via EventLog
     eventLog.emit({ type: 'bot-started', timestamp: Date.now(), data: { instruction: task.instruction, mode: task.mode, runId } });
 
-    runWorkflow(workflowPath, {
+    // runWorkflow registers itself in runRegistry via runner.ts.
+    // The .catch ensures EventLog is finalized for errors before runner's try/catch.
+    const runPromise = runWorkflow(workflowPath, {
       params: { taskJson: JSON.stringify(task), projectDir },
       dryRun: args.dryRun as boolean | undefined,
       eventLog,
     }).catch((err) => {
-      // Ensure EventLog is finalized even for early errors (e.g., file not found)
-      // that throw before runner.ts's own try/catch
-      eventLog.done();
+      // Finalize EventLog for early errors that throw before runner.ts's try/finally
+      try { eventLog.done(); } catch { /* already done */ }
       console.error('[weaver-bot] Background execution failed:', err);
     });
 
+    // Keep a reference so we don't lose track of it
+    void runPromise;
+
     return JSON.stringify({ runId, instruction: task.instruction, status: 'started' });
   },
 
@@ -195,9 +200,41 @@ const toolHandlers: Record<
 
   async fw_weaver_status() {
     const { SessionStore } = await import('./bot/session-state.js');
+    const { EventLog } = await import('./bot/event-log.js');
     const store = new SessionStore();
     const state = store.load();
-    return state ? JSON.stringify(state, null, 2) : JSON.stringify({ status: 'no active session' }, null, 2);
+
+    if (!state) {
+      return JSON.stringify({ status: 'no active session' }, null, 2);
+    }
+
+    // Startup cleanup: on first call after process restart, the registry is empty.
+    // If session.json claims 'executing' but nothing is in the registry, heal it.
+    if (!runRegistry.startupCleanupDone) {
+      runRegistry.markStartupCleanupDone();
+      if (state.status !== 'idle' && runRegistry.size === 0) {
+        // Orphaned session from a previous process — heal it
+        const orphanRunId = state.currentRunId;
+        if (orphanRunId) {
+          try { new EventLog(orphanRunId).done(); } catch { /* non-fatal */ }
+        }
+        await store.update({ status: 'idle', currentTask: null, currentRunId: null });
+        return JSON.stringify({ ...state, status: 'idle', currentTask: null, currentRunId: null, alive: false }, null, 2);
+      }
+    }
+
+    // Check if the current run is actually alive in the registry
+    const currentRunId = state.currentRunId ?? null;
+    const alive = currentRunId ? runRegistry.isAlive(currentRunId) : state.status === 'idle' ? null : runRegistry.size > 0;
+
+    // Self-heal: if status says executing but run is dead, clean up
+    if (currentRunId && alive === false && state.status !== 'idle') {
+      try { new EventLog(currentRunId).done(); } catch { /* non-fatal */ }
+      await store.update({ status: 'idle', currentTask: null, currentRunId: null });
+      return JSON.stringify({ ...state, status: 'idle', currentTask: null, currentRunId: null, alive: false }, null, 2);
+    }
+
+    return JSON.stringify({ ...state, alive }, null, 2);
   },
 
   async fw_weaver_events(args) {
@@ -208,7 +245,14 @@ const toolHandlers: Record<
     const offset = (args.offset as number) ?? 0;
     const log = new EventLog(runId);
     const events = log.tail(offset);
-    const done = log.isDone();
+    let done = log.isDone();
+
+    // Self-healing: if the run is not in the registry and has no .done marker,
+    // it's a zombie. Write the .done marker so this is the last poll.
+    if (!done && !runRegistry.isAlive(runId)) {
+      try { log.done(); } catch { /* non-fatal */ }
+      done = true;
+    }
 
     return JSON.stringify({ events, done });
   },
@@ -251,9 +295,10 @@ const toolHandlers: Record<
 
     if (action === 'status') {
       const state = store.load();
-      return state
-        ? JSON.stringify(state, null, 2)
-        : JSON.stringify({ status: 'no active session' });
+      if (!state) return JSON.stringify({ status: 'no active session' });
+      const crid = state.currentRunId ?? null;
+      const alive = crid ? runRegistry.isAlive(crid) : null;
+      return JSON.stringify({ ...state, alive }, null, 2);
     }
 
     if (action === 'stop') {
@@ -310,92 +355,95 @@ const toolHandlers: Record<
         let completed = 0;
         let failed = 0;
 
-        for (let i = 0; i < Math.min(maxTasks, pending.length); i++) {
-          const task = pending[i]!;
-
-          // Check for cancel signal
-          try {
-            const { SteeringController } = await import('./bot/steering.js');
-            const ctrl = new SteeringController();
-            const signal = await ctrl.check();
-            if (signal?.command === 'cancel') {
-              sessionLog.emit({ type: 'session:cancelled', timestamp: Date.now() });
-              break;
-            }
-          } catch { /* non-fatal */ }
-
-          const runId = RunStore.newId();
-          const taskLog = new EventLog(runId);
-
-          // Mark task as running in the queue
-          try { await queue.markRunning(task.id); } catch { /* non-fatal */ }
+        try {
+          for (let i = 0; i < Math.min(maxTasks, pending.length); i++) {
+            const task = pending[i]!;
 
-          await store.update({
-            status: 'executing',
-            currentTask: task.instruction,
-            currentRunId: runId,
-            lastActivity: Date.now(),
-          });
+            // Check for cancel signal
+            try {
+              const { SteeringController } = await import('./bot/steering.js');
+              const ctrl = new SteeringController();
+              const signal = await ctrl.check();
+              if (signal?.command === 'cancel') {
+                sessionLog.emit({ type: 'session:cancelled', timestamp: Date.now() });
+                break;
+              }
+            } catch { /* non-fatal */ }
 
-          sessionLog.emit({ type: 'session:task-start', timestamp: Date.now(), data: {
-            taskId: runId, instruction: task.instruction, index: i, total: Math.min(maxTasks, pending.length),
-          }});
+            const runId = RunStore.newId();
+            const taskLog = new EventLog(runId);
 
-          taskLog.emit({ type: 'bot-started', timestamp: Date.now(), data: {
-            instruction: task.instruction, mode: 'create', runId,
-          }});
+            // Mark task as running in the queue
+            try { await queue.markRunning(task.id); } catch { /* non-fatal */ }
 
-          try {
-            const result = await runWorkflow(workflowPath, {
-              params: {
-                taskJson: JSON.stringify({ instruction: task.instruction, mode: 'create' }),
-                projectDir,
-              },
-              eventLog: taskLog,
+            await store.update({
+              status: 'executing',
+              currentTask: task.instruction,
+              currentRunId: runId,
+              lastActivity: Date.now(),
             });
 
-            const success = result.success;
-            completed += success ? 1 : 0;
-            failed += success ? 0 : 1;
+            sessionLog.emit({ type: 'session:task-start', timestamp: Date.now(), data: {
+              taskId: runId, instruction: task.instruction, index: i, total: Math.min(maxTasks, pending.length),
+            }});
 
-            sessionLog.emit({ type: 'session:task-complete', timestamp: Date.now(), data: {
-              taskId: runId, outcome: result.outcome, duration: result.executionTime,
-              cost: result.cost?.totalCost,
+            taskLog.emit({ type: 'bot-started', timestamp: Date.now(), data: {
+              instruction: task.instruction, mode: 'create', runId,
             }});
 
-            // Mark task in queue
             try {
-              await queue.remove(task.id);
-            } catch { /* non-fatal */ }
+              const result = await runWorkflow(workflowPath, {
+                params: {
+                  taskJson: JSON.stringify({ instruction: task.instruction, mode: 'create' }),
+                  projectDir,
+                },
+                eventLog: taskLog,
+              });
+
+              const success = result.success;
+              completed += success ? 1 : 0;
+              failed += success ? 0 : 1;
+
+              sessionLog.emit({ type: 'session:task-complete', timestamp: Date.now(), data: {
+                taskId: runId, outcome: result.outcome, duration: result.executionTime,
+                cost: result.cost?.totalCost,
+              }});
+
+              // Mark task in queue
+              try {
+                await queue.remove(task.id);
+              } catch { /* non-fatal */ }
+
+            } catch (err) {
+              failed++;
+              sessionLog.emit({ type: 'session:task-complete', timestamp: Date.now(), data: {
+                taskId: runId, outcome: 'error', error: String(err),
+              }});
+            }
 
-          } catch (err) {
-            failed++;
-            sessionLog.emit({ type: 'session:task-complete', timestamp: Date.now(), data: {
-              taskId: runId, outcome: 'error', error: String(err),
-            }});
+            await store.update({
+              completedTasks: completed + failed,
+              currentRunId: null,
+              lastActivity: Date.now(),
+            });
           }
 
-          await store.update({
-            completedTasks: completed + failed,
-            currentRunId: null,
-            lastActivity: Date.now(),
-          });
+          sessionLog.emit({ type: 'session:ended', timestamp: Date.now(), data: {
+            reason: 'complete', completed, failed, total: completed + failed,
+          }});
+        } catch (err) {
+          console.error('[weaver-session] Session failed:', err);
+          sessionLog.emit({ type: 'session:ended', timestamp: Date.now(), data: {
+            reason: 'error', error: String(err),
+          }});
+        } finally {
+          // GUARANTEED: session log finalized and state reset, even on crash
+          try { sessionLog.done(); } catch { /* already done */ }
+          try {
+            await store.update({ status: 'idle', currentTask: null, currentRunId: null });
+          } catch { /* non-fatal */ }
         }
-
-        sessionLog.emit({ type: 'session:ended', timestamp: Date.now(), data: {
-          reason: 'complete', completed, failed, total: completed + failed,
-        }});
-        sessionLog.done();
-
-        await store.update({ status: 'idle', currentTask: null, currentRunId: null });
-      })().catch(async (err) => {
-        console.error('[weaver-session] Session failed:', err);
-        sessionLog.emit({ type: 'session:ended', timestamp: Date.now(), data: {
-          reason: 'error', error: String(err),
-        }});
-        sessionLog.done();
-        await store.update({ status: 'idle', currentTask: null, currentRunId: null });
-      });
+      })();
 
       return JSON.stringify({ started: true, sessionId, taskCount: Math.min(maxTasks, pending.length) });
     }

package/src/bot/run-registry.ts

@@ -0,0 +1,71 @@
+/**
+ * RunRegistry — in-memory registry of active workflow runs.
+ *
+ * Module-level singleton. The ai-chat-provider module is cached per workspace
+ * by the platform, so this Map persists across all tool calls within a session.
+ *
+ * Purpose:
+ * - Definitive alive/dead check: if a runId is in the registry, it's alive.
+ *   If not, it's dead (completed, failed, or orphaned).
+ * - Self-healing: any read path (fw_weaver_status, fw_weaver_events) can check
+ *   the registry and clean up stale state as a side effect.
+ * - Startup cleanup: on first access after process restart, the registry is empty,
+ *   so any session.json claiming 'executing' is immediately detectable as orphaned.
+ */
+
+export interface ActiveRun {
+  /** The workflow file being executed. */
+  file: string;
+  /** ISO timestamp when the run started. */
+  startedAt: string;
+  /** The Promise that resolves when the run completes (for awaiting if needed). */
+  promise: Promise<unknown>;
+}
+
+/** Module-level singleton — survives across tool calls, cleared on process restart. */
+const registry = new Map<string, ActiveRun>();
+
+/** Whether startup cleanup has been performed in this process lifetime. */
+let startupCleanupDone = false;
+
+export const runRegistry = {
+  /** Register a new active run. */
+  register(runId: string, entry: ActiveRun): void {
+    registry.set(runId, entry);
+  },
+
+  /** Remove a completed/failed run from the registry. */
+  remove(runId: string): void {
+    registry.delete(runId);
+  },
+
+  /** Check if a run is currently active (alive). */
+  isAlive(runId: string): boolean {
+    return registry.has(runId);
+  },
+
+  /** Get the active run entry, or undefined if not alive. */
+  get(runId: string): ActiveRun | undefined {
+    return registry.get(runId);
+  },
+
+  /** Get all active run IDs. */
+  activeRunIds(): string[] {
+    return Array.from(registry.keys());
+  },
+
+  /** Number of currently active runs. */
+  get size(): number {
+    return registry.size;
+  },
+
+  /** Whether startup cleanup has already run in this process lifetime. */
+  get startupCleanupDone(): boolean {
+    return startupCleanupDone;
+  },
+
+  /** Mark startup cleanup as completed. */
+  markStartupCleanupDone(): void {
+    startupCleanupDone = true;
+  },
+};

package/src/bot/runner.ts

@@ -26,6 +26,7 @@ import type { NotificationErrorHandler } from './notifications.js';
 import { RunStore } from './run-store.js';
 import { CostTracker } from './cost-tracker.js';
 import { CostStore } from './cost-store.js';
+import { runRegistry } from './run-registry.js';
 
 function resolveApproval(
   approval: BotConfig['approval'],
@@ -122,6 +123,11 @@ export async function runWorkflow(
   const runId = RunStore.newId();
   const startedAt = new Date().toISOString();
 
+  // Track this run in the in-memory registry for alive/dead checks
+  let registryPromiseResolve: (() => void) | undefined;
+  const registryPromise = new Promise<void>((resolve) => { registryPromiseResolve = resolve; });
+  runRegistry.register(runId, { file: absPath, startedAt, promise: registryPromise });
+
   // Collect execution trace and audit events for persistence
   const collectedTrace: ExecutionEvent[] = [];
   const collectedAudit: AuditEvent[] = [];
@@ -362,7 +368,6 @@ export async function runWorkflow(
     }, verbose);
 
     logEvent?.({ type: 'bot-completed', timestamp: Date.now(), data: { success, outcome, summary } });
-    options?.eventLog?.done();
 
     auditEmit('run-complete', { success, outcome, summary });
 
@@ -395,12 +400,15 @@ export async function runWorkflow(
     }, verbose);
 
     logEvent?.({ type: 'bot-failed', timestamp: Date.now(), data: { error: msg } });
-    options?.eventLog?.done();
 
     auditEmit('run-complete', { success: false, error: msg });
 
     return { success: false, summary: msg, outcome: 'error', cost: costSummary };
   } finally {
+    // GUARANTEED cleanup — runs on success, error, dry-run early return, and crash
+    runRegistry.remove(runId);
+    registryPromiseResolve?.();
+    try { options?.eventLog?.done(); } catch { /* already done or no log */ }
     teardownAuditLogger();
   }
 }

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