@joshualelon/clawdbot-skill-flow 2.3.4 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joshualelon/clawdbot-skill-flow",
-  "version": "2.3.4",
+  "version": "2.4.0",
   "type": "module",
   "description": "Multi-step workflow orchestration plugin for Clawdbot",
   "keywords": [

package/src/commands/flow-step.ts

@@ -13,11 +13,6 @@ import {
 } from "../state/session-store.js";
 import { saveFlowHistory } from "../state/history-store.js";
 import { processStep } from "../engine/executor.js";
-import {
-  loadHooks,
-  resolveFlowPath,
-  safeExecuteHook,
-} from "../engine/hooks-loader.js";
 
 export function createFlowStepCommand(api: ClawdbotPluginApi) {
   return async (args: {
@@ -68,29 +63,6 @@ export function createFlowStepCommand(api: ClawdbotPluginApi) {
     const session = getSession(sessionKey);
 
     if (!session) {
-      // Load hooks and call onFlowAbandoned
-      if (flow.hooks) {
-        const hooksPath = resolveFlowPath(api, flow.name, flow.hooks);
-        const hooks = await loadHooks(api, hooksPath);
-        if (hooks?.lifecycle?.onFlowAbandoned) {
-          await safeExecuteHook(
-            api,
-            "onFlowAbandoned",
-            hooks.lifecycle.onFlowAbandoned,
-            {
-              flowName,
-              currentStepId: stepId,
-              senderId: args.senderId,
-              channel: args.channel,
-              variables: {},
-              startedAt: 0,
-              lastActivityAt: 0,
-            },
-            "timeout"
-          );
-        }
-      }
-
       return {
         text: `Session expired or not found.\n\nUse /flow_start ${flowName} to restart the flow.`,
       };

package/src/engine/executor.ts

@@ -8,272 +8,148 @@ import type {
   FlowSession,
   FlowStep,
   ReplyPayload,
-  LoadedHooks,
-  ConditionalAction,
-  FetchAction,
-  BeforeRenderAction,
-  EnhancedPluginApi,
   DeclarativeAction,
 } from "../types.js";
 import { renderStep } from "./renderer.js";
 import { executeTransition } from "./transitions.js";
-import { loadHooks, resolveFlowPath, safeExecuteHook, safeExecuteAction, validateFlowActions } from "./hooks-loader.js";
-import * as pluginHooks from "../hooks/index.js";
 import { loadActionRegistry, type ActionRegistry } from "./action-loader.js";
 import { evaluateCondition } from "./condition-evaluator.js";
 import { executeDeclarativeAction } from "./action-executor.js";
 import { createInterpolationContext, interpolateConfig } from "./interpolation.js";
 
-/**
- * Determine if an action should execute based on conditional logic
- */
-export function shouldExecuteAction(
-  action: ConditionalAction,
-  session: FlowSession
-): { execute: boolean; actionName: string } {
-  // Check if condition is specified
-  if (action.if) {
-    const conditionValue = session.variables[action.if];
-    const execute = Boolean(conditionValue);
-    return { execute, actionName: action.action };
-  }
-
-  // No condition, always execute
-  return { execute: true, actionName: action.action };
-}
-
 /**
  * Execute step-level actions (fetch, beforeRender)
- * Supports both declarative actions (new) and hooks (legacy)
  */
 async function executeStepActions(
   api: ClawdbotPluginApi,
   step: FlowStep,
   session: FlowSession,
   flow: FlowMetadata,
-  hooks: LoadedHooks | null,
-  actionRegistry: ActionRegistry | null
+  actionRegistry: ActionRegistry
 ): Promise<{ step: FlowStep; session: FlowSession }> {
+  api.logger.info(`[ACTIONS] executeStepActions called for step: ${step.id}`);
+
   if (!step.actions) {
+    api.logger.debug(`[ACTIONS] No actions defined for step ${step.id}`);
     return { step, session };
   }
 
+  api.logger.info(`[ACTIONS] Step ${step.id} has actions. Fetch: ${step.actions.fetch ? Object.keys(step.actions.fetch).length : 0}, BeforeRender: ${step.actions.beforeRender?.length || 0}, AfterCapture: ${step.actions.afterCapture?.length || 0}`);
+
   let modifiedStep = step;
   let modifiedSession = { ...session };
+  const context = createInterpolationContext(modifiedSession, flow.env || {});
 
-  // Check if actions are declarative (new) or legacy hooks
-  const firstAction =
-    step.actions.fetch && Object.values(step.actions.fetch)[0] ||
-    step.actions.beforeRender?.[0];
-
-  const isDeclarative = firstAction && "type" in firstAction;
-
-  if (isDeclarative && actionRegistry) {
-    // NEW: Declarative action system
-    const context = createInterpolationContext(modifiedSession, flow.env || {});
+  // 1. Execute fetch actions
+  if (step.actions.fetch) {
+    api.logger.info(`[FETCH] Executing ${Object.keys(step.actions.fetch).length} fetch action(s) for step ${step.id}`);
 
-    // 1. Execute fetch actions
-    if (step.actions.fetch) {
-      for (const [varName, action] of Object.entries(step.actions.fetch)) {
-        const declarativeAction = action as DeclarativeAction;
+    for (const [varName, action] of Object.entries(step.actions.fetch)) {
+      const declarativeAction = action as DeclarativeAction;
+      api.logger.info(`[FETCH] Starting fetch action: ${declarativeAction.type} -> ${varName}`);
 
-        // Evaluate condition
-        if (declarativeAction.if && !evaluateCondition(declarativeAction.if, modifiedSession)) {
-          api.logger.debug(`Skipping fetch action ${declarativeAction.type} - condition not met`);
-          continue;
-        }
+      // Evaluate condition
+      if (declarativeAction.if && !evaluateCondition(declarativeAction.if, modifiedSession)) {
+        api.logger.debug(`[FETCH] Skipping fetch action ${declarativeAction.type} - condition not met`);
+        continue;
+      }
 
-        // Interpolate config
-        const config = interpolateConfig(declarativeAction.config, context);
-
-        try {
-          // Execute action
-          const result = await executeDeclarativeAction(
-            declarativeAction.type,
-            config,
-            { session: modifiedSession, api, step: modifiedStep },
-            actionRegistry
-          );
-
-          // Inject result into session
-          if (result !== null && result !== undefined) {
-            if (typeof result === "object") {
-              // If result is an object, inject all its fields as separate variables
-              const resultObj = result as Record<string, unknown>;
-              for (const [key, value] of Object.entries(resultObj)) {
-                if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-                  modifiedSession = {
-                    ...modifiedSession,
-                    variables: {
-                      ...modifiedSession.variables,
-                      [key]: value,
-                    },
-                  };
-                }
+      // Interpolate config
+      const config = interpolateConfig(declarativeAction.config, context);
+      api.logger.debug(`[FETCH] Interpolated config: ${JSON.stringify(config)}`);
+
+      try {
+        // Execute action
+        api.logger.info(`[FETCH] Executing ${declarativeAction.type}...`);
+        const result = await executeDeclarativeAction(
+          declarativeAction.type,
+          config,
+          { session: modifiedSession, api, step: modifiedStep },
+          actionRegistry
+        );
+        api.logger.info(`[FETCH] Action ${declarativeAction.type} completed. Result type: ${typeof result}`);
+
+        // Inject result into session
+        if (result !== null && result !== undefined) {
+          if (typeof result === "object") {
+            // If result is an object, inject all its fields as separate variables
+            const resultObj = result as Record<string, unknown>;
+            api.logger.info(`[FETCH] Injecting ${Object.keys(resultObj).length} variables from result: ${Object.keys(resultObj).join(', ')}`);
+
+            for (const [key, value] of Object.entries(resultObj)) {
+              if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+                modifiedSession = {
+                  ...modifiedSession,
+                  variables: {
+                    ...modifiedSession.variables,
+                    [key]: value,
+                  },
+                };
+                api.logger.debug(`[FETCH] Injected ${key} = ${value}`);
               }
-              // Update context for next actions
-              context.variables = modifiedSession.variables;
-            } else if (typeof result === "string" || typeof result === "number" || typeof result === "boolean") {
-              // If result is a primitive, inject it under varName
-              modifiedSession = {
-                ...modifiedSession,
-                variables: {
-                  ...modifiedSession.variables,
-                  [varName]: result,
-                },
-              };
-              // Update context for next actions
-              context.variables = modifiedSession.variables;
             }
+            // Update context for next actions
+            context.variables = modifiedSession.variables;
+          } else if (typeof result === "string" || typeof result === "number" || typeof result === "boolean") {
+            // If result is a primitive, inject it under varName
+            api.logger.info(`[FETCH] Injecting primitive result as ${varName} = ${result}`);
+            modifiedSession = {
+              ...modifiedSession,
+              variables: {
+                ...modifiedSession.variables,
+                [varName]: result,
+              },
+            };
+            // Update context for next actions
+            context.variables = modifiedSession.variables;
           }
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          api.logger.error(`Fetch action ${declarativeAction.type} failed: ${errorMsg}`);
-          // Continue with other actions
+        } else {
+          api.logger.warn(`[FETCH] Action ${declarativeAction.type} returned null/undefined`);
         }
-      }
-    }
-
-    // 2. Execute beforeRender actions
-    if (step.actions.beforeRender) {
-      for (const action of step.actions.beforeRender) {
-        const declarativeAction = action as DeclarativeAction;
-
-        // Evaluate condition
-        if (declarativeAction.if && !evaluateCondition(declarativeAction.if, modifiedSession)) {
-          api.logger.debug(`Skipping beforeRender action ${declarativeAction.type} - condition not met`);
-          continue;
-        }
-
-        // Interpolate config
-        const config = interpolateConfig(declarativeAction.config, context);
-
-        try {
-          // Execute action
-          const result = await executeDeclarativeAction(
-            declarativeAction.type,
-            config,
-            { session: modifiedSession, api, step: modifiedStep },
-            actionRegistry
-          );
-
-          if (result && typeof result === "object") {
-            modifiedStep = result as FlowStep;
-          }
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          api.logger.error(`BeforeRender action ${declarativeAction.type} failed: ${errorMsg}`);
-          // Continue with other actions
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        const errorStack = error instanceof Error ? error.stack : '';
+        api.logger.error(`[FETCH] Fetch action ${declarativeAction.type} failed: ${errorMsg}`);
+        if (errorStack) {
+          api.logger.debug(`[FETCH] Stack trace: ${errorStack}`);
         }
+        // Continue with other actions
       }
     }
-  } else if (hooks) {
-    // LEGACY: Hook-based action system
-    const enhancedApi: EnhancedPluginApi = {
-      ...api,
-      hooks: pluginHooks,
-    };
 
-    // 1. Execute fetch actions - inject variables into session
-    if (step.actions.fetch) {
-      for (const [varName, action] of Object.entries(step.actions.fetch)) {
-        // Check if it's a legacy action (has "action" field instead of "type")
-        if (!("action" in action)) continue;
-
-        const legacyAction = action as unknown as ConditionalAction;
-        // Check if action should execute
-        const { execute, actionName} = shouldExecuteAction(legacyAction, modifiedSession);
-
-        if (!execute) {
-          api.logger.debug(
-            `Skipping fetch action "${actionName}" for variable "${varName}" - condition not met`
-          );
-          continue;
-        }
+    api.logger.info(`[FETCH] Fetch actions complete. Variables in session: ${Object.keys(modifiedSession.variables).join(', ')}`);
+  }
 
-        const fetchFn = hooks.actions[actionName] as FetchAction | undefined;
-        if (fetchFn) {
-          // Validate signature before calling
-          if (fetchFn.length > 2) {
-            api.logger.error(
-              `Fetch action "${actionName}" has invalid signature. Expected 1-2 parameters (session, api?), got ${fetchFn.length}`
-            );
-            continue;
-          }
+  // 2. Execute beforeRender actions
+  if (step.actions.beforeRender) {
+    for (const action of step.actions.beforeRender) {
+      const declarativeAction = action as DeclarativeAction;
 
-          const result = await safeExecuteAction(
-            api,
-            actionName,
-            fetchFn,
-            modifiedSession,
-            enhancedApi
-          );
-          if (result !== null && result !== undefined) {
-            if (typeof result === "object") {
-              // If result is an object, inject all its fields as separate variables
-              for (const [key, value] of Object.entries(result)) {
-                if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-                  modifiedSession = {
-                    ...modifiedSession,
-                    variables: {
-                      ...modifiedSession.variables,
-                      [key]: value,
-                    },
-                  };
-                }
-              }
-            } else if (typeof result === "string" || typeof result === "number" || typeof result === "boolean") {
-              // If result is a primitive, inject it under varName
-              modifiedSession = {
-                ...modifiedSession,
-                variables: {
-                  ...modifiedSession.variables,
-                  [varName]: result,
-                },
-              };
-            }
-          }
-        }
+      // Evaluate condition
+      if (declarativeAction.if && !evaluateCondition(declarativeAction.if, modifiedSession)) {
+        api.logger.debug(`Skipping beforeRender action ${declarativeAction.type} - condition not met`);
+        continue;
       }
-    }
-
-    // 2. Execute beforeRender actions - modify step
-    if (step.actions.beforeRender) {
-      for (const action of step.actions.beforeRender) {
-        // Check if it's a legacy action (has "action" field instead of "type")
-        if (!("action" in action)) continue;
 
-        const legacyAction = action as unknown as ConditionalAction;
-        const { execute, actionName } = shouldExecuteAction(legacyAction, modifiedSession);
+      // Interpolate config
+      const config = interpolateConfig(declarativeAction.config, context);
 
-        if (!execute) {
-          api.logger.debug(
-            `Skipping beforeRender action "${actionName}" - condition not met`
-          );
-          continue;
-        }
-
-        const beforeRenderFn = hooks.actions[actionName] as BeforeRenderAction | undefined;
-        if (beforeRenderFn) {
-          if (beforeRenderFn.length > 3) {
-            api.logger.error(
-              `BeforeRender action "${actionName}" has invalid signature. Expected 2-3 parameters (step, session, api?), got ${beforeRenderFn.length}`
-            );
-            continue;
-          }
+      try {
+        // Execute action
+        const result = await executeDeclarativeAction(
+          declarativeAction.type,
+          config,
+          { session: modifiedSession, api, step: modifiedStep },
+          actionRegistry
+        );
 
-          const result = await safeExecuteAction(
-            api,
-            actionName,
-            beforeRenderFn,
-            modifiedStep,
-            modifiedSession,
-            enhancedApi
-          );
-          if (result) {
-            modifiedStep = result as FlowStep;
-          }
+        if (result && typeof result === "object") {
+          modifiedStep = result as FlowStep;
         }
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        api.logger.error(`BeforeRender action ${declarativeAction.type} failed: ${errorMsg}`);
+        // Continue with other actions
       }
     }
   }
@@ -297,29 +173,9 @@ export async function startFlow(
     };
   }
 
-  // Load action registry for declarative actions
-  let actionRegistry: ActionRegistry | null = null;
-  if (flow.actions?.imports || !flow.hooks) {
-    try {
-      actionRegistry = await loadActionRegistry(flow.actions?.imports);
-      api.logger.debug(`Loaded action registry with ${actionRegistry.list().length} actions`);
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      api.logger.error(`Failed to load action registry: ${errorMsg}`);
-    }
-  }
-
-  // Load hooks if configured (legacy support)
-  let hooks: LoadedHooks | null = null;
-  if (flow.hooks) {
-    const hooksPath = resolveFlowPath(api, flow.name, flow.hooks);
-    hooks = await loadHooks(api, hooksPath);
-
-    // Validate that all action references in the flow exist
-    if (hooks) {
-      validateFlowActions(flow, hooks, api);
-    }
-  }
+  // Load action registry
+  const actionRegistry = await loadActionRegistry(flow.actions?.imports);
+  api.logger.debug(`Loaded action registry with ${actionRegistry.list().length} actions`);
 
   // Inject environment variables into session
   if (flow.env) {
@@ -347,11 +203,11 @@ export async function startFlow(
   }
 
   // Execute step actions before rendering
-  const actionResult = await executeStepActions(api, firstStep, session, flow, hooks, actionRegistry);
+  const actionResult = await executeStepActions(api, firstStep, session, flow, actionRegistry);
   firstStep = actionResult.step;
   session = actionResult.session;
 
-  return renderStep(api, flow, firstStep, session, session.channel, hooks);
+  return renderStep(api, flow, firstStep, session, session.channel);
 }
 
 /**
@@ -368,28 +224,8 @@ export async function processStep(
   complete: boolean;
   updatedVariables: Record<string, string | number | boolean>;
 }> {
-  // Load action registry for declarative actions
-  let actionRegistry: ActionRegistry | null = null;
-  if (flow.actions?.imports || !flow.hooks) {
-    try {
-      actionRegistry = await loadActionRegistry(flow.actions?.imports);
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      api.logger.error(`Failed to load action registry: ${errorMsg}`);
-    }
-  }
-
-  // Load hooks if configured (legacy support)
-  let hooks: LoadedHooks | null = null;
-  if (flow.hooks) {
-    const hooksPath = resolveFlowPath(api, flow.name, flow.hooks);
-    hooks = await loadHooks(api, hooksPath);
-
-    // Validate that all action references in the flow exist
-    if (hooks) {
-      validateFlowActions(flow, hooks, api);
-    }
-  }
+  // Load action registry
+  const actionRegistry = await loadActionRegistry(flow.actions?.imports);
 
   const result = await executeTransition(
     api,
@@ -397,7 +233,6 @@ export async function processStep(
     session,
     stepId,
     value,
-    hooks,
     actionRegistry
   );
 
@@ -412,13 +247,6 @@ export async function processStep(
 
   // Handle completion
   if (result.complete) {
-    const updatedSession = { ...session, variables: result.variables };
-
-    // Call onFlowComplete hook
-    if (hooks?.lifecycle?.onFlowComplete) {
-      await safeExecuteHook(api, "onFlowComplete", hooks.lifecycle.onFlowComplete, updatedSession);
-    }
-
     const completionMessage = generateCompletionMessage(flow, result.variables);
     return {
       reply: { text: completionMessage },
@@ -448,7 +276,7 @@ export async function processStep(
   let updatedSession = { ...session, variables: result.variables };
 
   // Execute step actions before rendering
-  const actionResult = await executeStepActions(api, nextStep, updatedSession, flow, hooks, actionRegistry);
+  const actionResult = await executeStepActions(api, nextStep, updatedSession, flow, actionRegistry);
   nextStep = actionResult.step;
   updatedSession = actionResult.session;
 
@@ -457,8 +285,7 @@ export async function processStep(
     flow,
     nextStep,
     updatedSession,
-    session.channel,
-    hooks
+    session.channel
   );
 
   return {

package/src/engine/renderer.ts

@@ -8,7 +8,6 @@ import type {
   FlowStep,
   FlowSession,
   ReplyPayload,
-  LoadedHooks,
 } from "../types.js";
 import { normalizeButton } from "../validation.js";
 
@@ -107,18 +106,14 @@ function renderFallback(
 /**
  * Render a flow step for the user's channel
  *
- * Note: Step actions (fetch, beforeRender) are now executed in executor.ts
- * before this function is called. The api and hooks parameters are retained for:
- * - API consistency with other engine functions
- * - Future extensibility (e.g., channel-specific rendering hooks)
- * - Backwards compatibility if deprecated hooks are re-enabled
+ * Note: Step actions (fetch, beforeRender) are executed in executor.ts
+ * before this function is called.
  *
  * @param _api - Plugin API (reserved for future use)
  * @param flow - Flow metadata
  * @param step - Step to render (already modified by beforeRender actions)
  * @param session - Current session with variables (already populated by fetch actions)
  * @param channel - Target channel (telegram, slack, etc.)
- * @param _hooks - Loaded hooks (reserved for future use)
  * @returns Rendered message payload for the channel
  */
 export async function renderStep(
@@ -126,8 +121,7 @@ export async function renderStep(
   flow: FlowMetadata,
   step: FlowStep,
   session: FlowSession,
-  channel: string,
-  _hooks?: LoadedHooks | null
+  channel: string
 ): Promise<ReplyPayload> {
   // Channel-specific rendering
   if (channel === "telegram") {

package/src/engine/transitions.ts

@@ -8,18 +8,11 @@ import type {
   FlowStep,
   FlowSession,
   TransitionResult,
-  LoadedHooks,
-  AfterCaptureAction,
-  EnhancedPluginApi,
   DeclarativeAction,
-  ConditionalAction,
 } from "../types.js";
 import { normalizeButton, validateInput } from "../validation.js";
-import { safeExecuteAction } from "./hooks-loader.js";
 import { sanitizeInput } from "../security/input-sanitization.js";
 import { getPluginConfig } from "../config.js";
-import { shouldExecuteAction } from "./executor.js";
-import * as pluginHooks from "../hooks/index.js";
 import type { ActionRegistry } from "./action-loader.js";
 import { evaluateCondition as evaluateDeclarativeCondition } from "./condition-evaluator.js";
 import { executeDeclarativeAction } from "./action-executor.js";
@@ -106,15 +99,8 @@ export async function executeTransition(
   session: FlowSession,
   stepId: string,
   value: string | number,
-  hooks?: LoadedHooks | null,
-  actionRegistry?: ActionRegistry | null
+  actionRegistry: ActionRegistry
 ): Promise<TransitionResult> {
-  // Create enhanced API with plugin utilities
-  const enhancedApi: EnhancedPluginApi = {
-    ...api,
-    hooks: pluginHooks,
-  };
-
   // Find current step
   const step = flow.steps.find((s) => s.id === stepId);
 
@@ -171,82 +157,38 @@ export async function executeTransition(
     // Execute afterCapture actions
     if (step.actions?.afterCapture) {
       const updatedSession = { ...session, variables: updatedVariables };
+      const context = createInterpolationContext(updatedSession, flow.env || {});
 
-      // Check if actions are declarative (new) or legacy hooks
-      const firstAction = step.actions.afterCapture[0];
-      const isDeclarative = firstAction && "type" in firstAction;
-
-      if (isDeclarative && actionRegistry) {
-        // NEW: Declarative action system
-        const context = createInterpolationContext(updatedSession, flow.env || {});
-
-        for (const action of step.actions.afterCapture) {
-          const declarativeAction = action as DeclarativeAction;
+      for (const action of step.actions.afterCapture) {
+        const declarativeAction = action as DeclarativeAction;
 
-          // Evaluate condition
-          if (declarativeAction.if && !evaluateDeclarativeCondition(declarativeAction.if, updatedSession)) {
-            api.logger.debug(`Skipping afterCapture action ${declarativeAction.type} - condition not met`);
-            continue;
-          }
-
-          // Interpolate config
-          const config = interpolateConfig(declarativeAction.config, context);
-
-          try {
-            // Execute action
-            await executeDeclarativeAction(
-              declarativeAction.type,
-              config,
-              {
-                session: updatedSession,
-                api,
-                step,
-                capturedVariable: step.capture,
-                capturedValue: capturedValue,
-              },
-              actionRegistry
-            );
-          } catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            api.logger.error(`AfterCapture action ${declarativeAction.type} failed: ${errorMsg}`);
-            // Continue with other actions
-          }
+        // Evaluate condition
+        if (declarativeAction.if && !evaluateDeclarativeCondition(declarativeAction.if, updatedSession)) {
+          api.logger.debug(`Skipping afterCapture action ${declarativeAction.type} - condition not met`);
+          continue;
         }
-      } else if (hooks) {
-        // LEGACY: Hook-based action system
-        for (const action of step.actions.afterCapture) {
-          // Check if it's a legacy action (has "action" field instead of "type")
-          if (!("action" in action)) continue;
-
-          const legacyAction = action as unknown as ConditionalAction;
-          const { execute, actionName } = shouldExecuteAction(legacyAction, updatedSession);
-
-          if (!execute) {
-            api.logger.debug(
-              `Skipping afterCapture action "${actionName}" - condition not met`
-            );
-            continue;
-          }
 
-          const afterCaptureFn = hooks.actions[actionName] as AfterCaptureAction | undefined;
-          if (afterCaptureFn) {
-            if (afterCaptureFn.length > 4) {
-              api.logger.error(
-                `AfterCapture action "${actionName}" has invalid signature. Expected 3-4 parameters (variable, value, session, api?), got ${afterCaptureFn.length}`
-              );
-              continue;
-            }
+        // Interpolate config
+        const config = interpolateConfig(declarativeAction.config, context);
 
-            await safeExecuteAction(
+        try {
+          // Execute action
+          await executeDeclarativeAction(
+            declarativeAction.type,
+            config,
+            {
+              session: updatedSession,
               api,
-              actionName,
-              afterCaptureFn,
-              step.capture,
-              capturedValue,
-              updatedSession,
-              enhancedApi
-            );
-          }
+              step,
+              capturedVariable: step.capture,
+              capturedValue: capturedValue,
+            },
+            actionRegistry
+          );
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          api.logger.error(`AfterCapture action ${declarativeAction.type} failed: ${errorMsg}`);
+          // Continue with other actions
         }
       }
     }

package/src/state/history-store.ts

@@ -5,13 +5,10 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import type { ClawdbotPluginApi } from "clawdbot/plugin-sdk";
-import type { FlowSession, FlowMetadata } from "../types.js";
+import type { FlowSession, FlowMetadata, StorageBackend } from "../types.js";
 import type { SkillFlowConfig } from "../config.js";
 import { getPluginConfig } from "../config.js";
-import {
-  loadStorageBackend,
-  resolveFlowPath,
-} from "../engine/hooks-loader.js";
+import { resolvePathSafely, validatePathWithinBase } from "../security/path-validation.js";
 
 /**
  * Get the flows directory path (same logic as flow-store.ts)
@@ -26,6 +23,43 @@ function getFlowsDir(api: ClawdbotPluginApi): string {
   return path.join(stateDir, "flows");
 }
 
+/**
+ * Resolve relative path to absolute (relative to flow directory)
+ */
+function resolveFlowPath(
+  api: ClawdbotPluginApi,
+  flowName: string,
+  relativePath: string
+): string {
+  const flowsDir = getFlowsDir(api);
+  const flowDir = path.join(flowsDir, flowName);
+  return resolvePathSafely(flowDir, relativePath, "flow path");
+}
+
+/**
+ * Load custom storage backend module
+ */
+async function loadStorageBackend(
+  api: ClawdbotPluginApi,
+  backendPath: string
+): Promise<StorageBackend | null> {
+  try {
+    const flowsDir = getFlowsDir(api);
+    validatePathWithinBase(backendPath, flowsDir, "storage backend");
+
+    await fs.access(backendPath);
+
+    const backendModule = await import(backendPath);
+    const backend: StorageBackend = backendModule.default ?? backendModule;
+
+    api.logger.debug(`Loaded storage backend from ${backendPath}`);
+    return backend;
+  } catch (error) {
+    api.logger.warn(`Failed to load storage backend from ${backendPath}:`, error);
+    return null;
+  }
+}
+
 /**
  * Get history file path for a flow
  */

package/src/engine/hooks-loader.ts

@@ -1,305 +0,0 @@
-/**
- * Hooks loader - Dynamically loads and executes flow hooks
- */
-
-import type { FlowHooks, StorageBackend, LoadedHooks } from "../types.js";
-import type { ClawdbotPluginApi } from "clawdbot/plugin-sdk";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import {
-  resolvePathSafely,
-  validatePathWithinBase,
-} from "../security/path-validation.js";
-import { getPluginConfig } from "../config.js";
-import { withTimeout, TimeoutError } from "../security/timeout.js";
-import * as pluginHooks from "../hooks/index.js";
-
-/**
- * Get the flows directory path (same logic as flow-store.ts)
- */
-function getFlowsDir(api: ClawdbotPluginApi): string {
-  const config = getPluginConfig();
-  if (config.flowsDir) {
-    const expandedPath = config.flowsDir.replace(/^~/, process.env.HOME || "~");
-    return path.resolve(expandedPath);
-  }
-  const stateDir = api.runtime.state.resolveStateDir();
-  return path.join(stateDir, "flows");
-}
-
-/**
- * Load hooks from a file path
- * @param api - Plugin API for logging
- * @param hooksPath - Absolute path to hooks file
- * @returns LoadedHooks object with lifecycle hooks and actions, or null if loading fails
- */
-export async function loadHooks(
-  api: ClawdbotPluginApi,
-  hooksPath: string
-): Promise<LoadedHooks | null> {
-  try {
-    // Validate path is within flows directory
-    const flowsDir = getFlowsDir(api);
-    validatePathWithinBase(hooksPath, flowsDir, "hooks file");
-
-    // Check if file exists
-    await fs.access(hooksPath);
-
-    // Dynamically import the hooks module
-    const hooksModule = await import(hooksPath);
-
-    // Extract default export for lifecycle hooks
-    let moduleExport = hooksModule.default ?? {};
-
-    // Support factory functions that take API and return lifecycle hooks
-    // Inject plugin hooks utilities into the API for easy access
-    if (typeof moduleExport === "function") {
-      const enhancedApi = {
-        ...api,
-        hooks: pluginHooks, // Make plugin utilities available via api.hooks
-      };
-      moduleExport = moduleExport(enhancedApi);
-    }
-
-    // Extract global lifecycle hooks from default export
-    const lifecycle: FlowHooks = {
-      onFlowComplete: moduleExport?.onFlowComplete,
-      onFlowAbandoned: moduleExport?.onFlowAbandoned,
-    };
-
-    // Extract all named exports as step-level actions
-    const actions: Record<string, Function> = {};
-    for (const [key, value] of Object.entries(hooksModule)) {
-      if (key !== "default" && typeof value === "function") {
-        actions[key] = value;
-      }
-    }
-
-    api.logger.debug(`Loaded hooks from ${hooksPath}: ${Object.keys(actions).length} actions, ${Object.keys(lifecycle).filter(k => lifecycle[k as keyof FlowHooks]).length} lifecycle hooks`);
-    return { lifecycle, actions };
-  } catch (error) {
-    api.logger.warn(`Failed to load hooks from ${hooksPath}:`, error);
-    return null;
-  }
-}
-
-/**
- * Load storage backend from a file path
- * @param api - Plugin API for logging
- * @param backendPath - Absolute path to storage backend file
- * @returns StorageBackend or null if loading fails
- */
-export async function loadStorageBackend(
-  api: ClawdbotPluginApi,
-  backendPath: string
-): Promise<StorageBackend | null> {
-  try {
-    // Validate path is within flows directory
-    const flowsDir = getFlowsDir(api);
-    validatePathWithinBase(backendPath, flowsDir, "storage backend");
-
-    // Check if file exists
-    await fs.access(backendPath);
-
-    // Dynamically import the backend module
-    const backendModule = await import(backendPath);
-
-    // Support both default export and named export
-    const backend: StorageBackend = backendModule.default ?? backendModule;
-
-    api.logger.debug(`Loaded storage backend from ${backendPath}`);
-    return backend;
-  } catch (error) {
-    api.logger.warn(`Failed to load storage backend from ${backendPath}:`, error);
-    return null;
-  }
-}
-
-/**
- * Resolve relative path to absolute (relative to flow directory)
- * @param api - Plugin API
- * @param flowName - Name of the flow
- * @param relativePath - Relative path from flow config
- * @returns Absolute path
- */
-export function resolveFlowPath(
-  api: ClawdbotPluginApi,
-  flowName: string,
-  relativePath: string
-): string {
-  const flowsDir = getFlowsDir(api);
-  const flowDir = path.join(flowsDir, flowName);
-
-  // Validate that relativePath doesn't escape flowDir
-  return resolvePathSafely(flowDir, relativePath, "flow path");
-}
-
-/**
- * Safe hook executor - wraps hook calls with error handling
- * @param api - Plugin API for logging
- * @param hookName - Name of the hook being called
- * @param hookFn - The hook function to execute
- * @param args - Arguments to pass to the hook
- * @returns Result of hook or undefined if hook fails
- */
-export async function safeExecuteHook<T, Args extends unknown[]>(
-  api: ClawdbotPluginApi,
-  hookName: string,
-  hookFn: ((...args: Args) => T | Promise<T>) | undefined,
-  ...args: Args
-): Promise<T | undefined> {
-  if (!hookFn) {
-    return undefined;
-  }
-
-  const config = getPluginConfig();
-  const timeout = config.security.hookTimeout;
-
-  try {
-    const result = await withTimeout(
-      () => Promise.resolve(hookFn(...args)),
-      timeout,
-      `Hook "${hookName}" timed out after ${timeout}ms`
-    );
-    return result;
-  } catch (error) {
-    const isTimeout = error instanceof TimeoutError;
-    const errorMsg = isTimeout
-      ? `Hook ${hookName} timed out after ${timeout}ms`
-      : `Hook ${hookName} failed: ${error}`;
-
-    api.logger.error(errorMsg);
-    return undefined;
-  }
-}
-
-/**
- * Safe action executor - wraps action calls with error handling
- * @param api - Plugin API for logging
- * @param actionName - Name of the action being called
- * @param actionFn - The action function to execute
- * @param args - Arguments to pass to the action
- * @returns Result of action or undefined if action fails
- */
-export async function safeExecuteAction<T, Args extends unknown[]>(
-  api: ClawdbotPluginApi,
-  actionName: string,
-  actionFn: ((...args: Args) => T | Promise<T>) | undefined,
-  ...args: Args
-): Promise<T | undefined> {
-  if (!actionFn) {
-    api.logger.warn(`Action ${actionName} not found in hooks`);
-    return undefined;
-  }
-
-  const config = getPluginConfig();
-  const strategy = config.actions?.fetchFailureStrategy || "warn";
-  const timeout = config.security.actionTimeout;
-
-  try {
-    const result = await withTimeout(
-      () => Promise.resolve(actionFn(...args)),
-      timeout,
-      `Action "${actionName}" timed out after ${timeout}ms`
-    );
-    return result;
-  } catch (error) {
-    const isTimeout = error instanceof TimeoutError;
-    const errorMsg = isTimeout
-      ? `Action ${actionName} timed out after ${timeout}ms`
-      : `Action ${actionName} failed: ${error}`;
-
-    if (strategy === "stop") {
-      api.logger.error(errorMsg);
-      throw error; // Re-throw to stop flow execution
-    } else if (strategy === "warn") {
-      api.logger.warn(errorMsg);
-    }
-    // 'silent' strategy logs nothing
-
-    return undefined;
-  }
-}
-
-/**
- * Extract action name from ConditionalAction or DeclarativeAction
- */
-function getActionName(
-  action: import("../types.js").ConditionalAction | import("../types.js").DeclarativeAction
-): string {
-  // Check if it's a legacy ConditionalAction with "action" field
-  if ("action" in action) {
-    return action.action;
-  }
-  // Otherwise it's a DeclarativeAction with "type" field
-  if ("type" in action) {
-    return action.type;
-  }
-  return "unknown";
-}
-
-/**
- * Validate that all actions referenced in flow steps exist in hooks
- * @param flow - Flow metadata with steps
- * @param hooks - Loaded hooks with actions
- * @param api - Plugin API for logging
- * @throws Error if any action references are invalid
- */
-export function validateFlowActions(
-  flow: import("../types.js").FlowMetadata,
-  hooks: LoadedHooks,
-  api: ClawdbotPluginApi
-): void {
-  const availableActions = Object.keys(hooks.actions);
-  const errors: string[] = [];
-
-  for (const step of flow.steps) {
-    if (!step.actions) continue;
-
-    // Validate fetch actions
-    if (step.actions.fetch) {
-      for (const [varName, action] of Object.entries(step.actions.fetch)) {
-        const actionName = getActionName(action);
-        if (!availableActions.includes(actionName)) {
-          errors.push(
-            `Step "${step.id}": fetch action "${actionName}" not found (for variable "${varName}")`
-          );
-        }
-      }
-    }
-
-    // Validate beforeRender actions
-    if (step.actions.beforeRender) {
-      for (const action of step.actions.beforeRender) {
-        const actionName = getActionName(action);
-        if (!availableActions.includes(actionName)) {
-          errors.push(
-            `Step "${step.id}": beforeRender action "${actionName}" not found`
-          );
-        }
-      }
-    }
-
-    // Validate afterCapture actions
-    if (step.actions.afterCapture) {
-      for (const action of step.actions.afterCapture) {
-        const actionName = getActionName(action);
-        if (!availableActions.includes(actionName)) {
-          errors.push(
-            `Step "${step.id}": afterCapture action "${actionName}" not found`
-          );
-        }
-      }
-    }
-  }
-
-  if (errors.length > 0) {
-    const errorMsg = `Flow "${flow.name}" has invalid action references:\n${errors.join('\n')}`;
-    api.logger.error(errorMsg);
-
-    throw new Error(
-      `Flow "${flow.name}" references ${errors.length} action(s) that don't exist in hooks file. ` +
-      `Available actions: ${availableActions.join(', ') || '(none)'}`
-    );
-  }
-}