@objectstack/service-automation 7.3.0 → 7.4.1

package/dist/index.cjs

@@ -22,25 +22,51 @@ var index_exports = {};
 __export(index_exports, {
   AutomationEngine: () => AutomationEngine,
   AutomationServicePlugin: () => AutomationServicePlugin,
-  CrudNodesPlugin: () => CrudNodesPlugin,
-  HttpConnectorPlugin: () => HttpConnectorPlugin,
-  LogicNodesPlugin: () => LogicNodesPlugin,
-  ScreenNodesPlugin: () => ScreenNodesPlugin
+  installBuiltinNodes: () => installBuiltinNodes,
+  registerConnectorNodes: () => registerConnectorNodes,
+  registerCrudNodes: () => registerCrudNodes,
+  registerHttpNodes: () => registerHttpNodes,
+  registerLogicNodes: () => registerLogicNodes,
+  registerScreenNodes: () => registerScreenNodes
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/engine.ts
 var import_automation = require("@objectstack/spec/automation");
+var import_integration = require("@objectstack/spec/integration");
+var import_formula = require("@objectstack/formula");
+var FlowSuspendSignal = class {
+  constructor(nodeId, correlation, screen) {
+    this.nodeId = nodeId;
+    this.correlation = correlation;
+    this.screen = screen;
+    this.__flowSuspend = true;
+  }
+};
+function isSuspendSignal(err) {
+  return typeof err === "object" && err !== null && err.__flowSuspend === true;
+}
 var AutomationEngine = class {
   constructor(logger) {
     this.flows = /* @__PURE__ */ new Map();
     this.flowEnabled = /* @__PURE__ */ new Map();
     this.flowVersionHistory = /* @__PURE__ */ new Map();
     this.nodeExecutors = /* @__PURE__ */ new Map();
+    this.actionDescriptors = /* @__PURE__ */ new Map();
     this.triggers = /* @__PURE__ */ new Map();
+    /**
+     * Flows currently wired to a trigger, keyed by flow name → the trigger
+     * `type` that owns the binding. Used to avoid double-binding and to know
+     * which trigger to `stop()` when a flow is unregistered/disabled.
+     */
+    this.boundFlowTriggers = /* @__PURE__ */ new Map();
+    /** Connectors registered by integration plugins, keyed by connector name (ADR-0018 §Addendum). */
+    this.connectors = /* @__PURE__ */ new Map();
     this.executionLogs = [];
     this.maxLogSize = 1e3;
     this.runCounter = 0;
+    /** Runs paused at a node, keyed by runId (ADR-0019). In-memory, see {@link SuspendedRun}. */
+    this.suspendedRuns = /* @__PURE__ */ new Map();
     this.logger = logger;
   }
   // ── Plugin Extension API ──────────────────────────────
@@ -50,27 +76,200 @@ var AutomationEngine = class {
       this.logger.warn(`Node executor '${executor.type}' replaced`);
     }
     this.nodeExecutors.set(executor.type, executor);
+    if (executor.descriptor) {
+      const descriptorType = executor.descriptor.type;
+      if (descriptorType !== executor.type) {
+        this.logger.warn(
+          `Node executor '${executor.type}' publishes a descriptor for type '${descriptorType}' \u2014 registering under both.`
+        );
+      }
+      this.actionDescriptors.set(descriptorType, executor.descriptor);
+    }
     this.logger.info(`Node executor registered: ${executor.type}`);
   }
   /** Unregister a node executor (hot-unplug) */
   unregisterNodeExecutor(type) {
+    const executor = this.nodeExecutors.get(type);
     this.nodeExecutors.delete(type);
+    this.actionDescriptors.delete(type);
+    if (executor?.descriptor) {
+      this.actionDescriptors.delete(executor.descriptor.type);
+    }
     this.logger.info(`Node executor unregistered: ${type}`);
   }
   /** Register a trigger (called by plugins) */
   registerTrigger(trigger) {
     this.triggers.set(trigger.type, trigger);
     this.logger.info(`Trigger registered: ${trigger.type}`);
+    for (const name of this.flows.keys()) {
+      if (this.boundFlowTriggers.has(name)) continue;
+      const resolved = this.resolveTriggerBinding(name);
+      if (resolved?.triggerType === trigger.type) {
+        this.activateFlowTrigger(name);
+      }
+    }
   }
   /** Unregister a trigger (hot-unplug) */
   unregisterTrigger(type) {
+    for (const [name, boundType] of [...this.boundFlowTriggers]) {
+      if (boundType !== type) continue;
+      try {
+        this.triggers.get(type)?.stop(name);
+      } catch (err) {
+        this.logger.warn(`Trigger '${type}' stop('${name}') failed: ${err.message}`);
+      }
+      this.boundFlowTriggers.delete(name);
+    }
     this.triggers.delete(type);
     this.logger.info(`Trigger unregistered: ${type}`);
   }
+  /**
+   * Derive a flow's trigger binding from its `start` node, or `undefined` if
+   * the flow has no auto-trigger (manual / screen / api). The convention —
+   * established by the showcase flows — is that the start node carries the
+   * trigger details in its `config`: `{ objectName, triggerType, condition }`
+   * for record-change, or a `schedule` descriptor for time-based flows.
+   */
+  resolveTriggerBinding(flowName) {
+    const flow = this.flows.get(flowName);
+    if (!flow) return void 0;
+    const startNode = flow.nodes.find((n) => n.type === "start");
+    const config = startNode?.config ?? {};
+    const triggerType = typeof config.triggerType === "string" ? config.triggerType : void 0;
+    if (triggerType && triggerType.startsWith("record-")) {
+      return {
+        triggerType: "record_change",
+        binding: {
+          flowName,
+          object: typeof config.objectName === "string" ? config.objectName : void 0,
+          event: triggerType,
+          condition: config.condition ?? void 0,
+          config
+        }
+      };
+    }
+    if (config.schedule != null || flow.type === "schedule") {
+      return {
+        triggerType: "schedule",
+        binding: { flowName, schedule: config.schedule, condition: config.condition ?? void 0, config }
+      };
+    }
+    return void 0;
+  }
+  /**
+   * Bind a flow to its matching registered trigger (idempotent). No-op when
+   * the flow has no trigger binding or no trigger is registered for its type
+   * yet — {@link registerTrigger} re-attempts activation when one arrives.
+   */
+  activateFlowTrigger(flowName) {
+    if (this.boundFlowTriggers.has(flowName)) return;
+    const resolved = this.resolveTriggerBinding(flowName);
+    if (!resolved) return;
+    const trigger = this.triggers.get(resolved.triggerType);
+    if (!trigger) return;
+    try {
+      trigger.start(resolved.binding, (ctx) => this.execute(flowName, ctx).then(() => void 0));
+      this.boundFlowTriggers.set(flowName, resolved.triggerType);
+      this.logger.info(`Flow '${flowName}' bound to trigger '${resolved.triggerType}'`);
+    } catch (err) {
+      this.logger.warn(`Failed to bind flow '${flowName}' to trigger '${resolved.triggerType}': ${err.message}`);
+    }
+  }
+  /** Unbind a flow from its trigger, if bound. */
+  deactivateFlowTrigger(flowName) {
+    const boundType = this.boundFlowTriggers.get(flowName);
+    if (!boundType) return;
+    try {
+      this.triggers.get(boundType)?.stop(flowName);
+    } catch (err) {
+      this.logger.warn(`Trigger '${boundType}' stop('${flowName}') failed: ${err.message}`);
+    }
+    this.boundFlowTriggers.delete(flowName);
+  }
+  /** Active flow→trigger bindings (observability / tests). */
+  getActiveTriggerBindings() {
+    return [...this.boundFlowTriggers].map(([flowName, triggerType]) => ({ flowName, triggerType }));
+  }
+  /**
+   * Register a connector (called by integration plugins, ADR-0018 §Addendum).
+   * Validates the definition against {@link ConnectorSchema} and asserts every
+   * declared action has a handler, so a half-wired connector fails loudly at
+   * registration rather than silently at dispatch. Re-registering the same
+   * name replaces (mirrors {@link registerNodeExecutor}).
+   */
+  registerConnector(def, handlers) {
+    const parsed = import_integration.ConnectorSchema.parse(def);
+    for (const action of parsed.actions ?? []) {
+      if (typeof handlers[action.key] !== "function") {
+        throw new Error(
+          `Connector '${parsed.name}': action '${action.key}' is declared but no handler was provided`
+        );
+      }
+    }
+    if (this.connectors.has(parsed.name)) {
+      this.logger.warn(`Connector '${parsed.name}' replaced`);
+    }
+    this.connectors.set(parsed.name, { def: parsed, handlers });
+    this.logger.info(
+      `Connector registered: ${parsed.name} (${Object.keys(handlers).length} action handlers)`
+    );
+  }
+  /** Unregister a connector (hot-unplug). */
+  unregisterConnector(name) {
+    this.connectors.delete(name);
+    this.logger.info(`Connector unregistered: ${name}`);
+  }
+  /**
+   * Resolve the handler for a connector action, used by the baseline
+   * `connector_action` node. Returns `undefined` when the connector or action
+   * is not registered, so the node can fail the step with a clear error.
+   */
+  resolveConnectorAction(connectorId, actionId) {
+    return this.connectors.get(connectorId)?.handlers[actionId];
+  }
+  /** Get all registered connector names. */
+  getRegisteredConnectors() {
+    return [...this.connectors.keys()];
+  }
+  /**
+   * Get a designer-facing descriptor for every registered connector — its
+   * identity plus the actions it exposes (input/output JSON Schema). Backs
+   * `GET /api/v1/automation/connectors` so the designer can fill the
+   * `connector_action` node's connector / action / input pickers (ADR-0022).
+   * Handlers are omitted — they are runtime code, not metadata.
+   */
+  getConnectorDescriptors() {
+    return [...this.connectors.values()].map(({ def }) => ({
+      name: def.name,
+      label: def.label,
+      type: def.type,
+      description: def.description,
+      icon: def.icon,
+      actions: (def.actions ?? []).map((a) => ({
+        key: a.key,
+        label: a.label,
+        description: a.description,
+        inputSchema: a.inputSchema,
+        outputSchema: a.outputSchema
+      }))
+    }));
+  }
   /** Get all registered node types */
   getRegisteredNodeTypes() {
     return [...this.nodeExecutors.keys()];
   }
+  /**
+   * Get all published action descriptors (ADR-0018). Backs both flow
+   * validation and the designer palette (`GET /api/v1/automation/actions`).
+   * Only executors that published a descriptor appear here.
+   */
+  getActionDescriptors() {
+    return [...this.actionDescriptors.values()];
+  }
+  /** Get the action descriptor for a single node type, if published. */
+  getActionDescriptor(type) {
+    return this.actionDescriptors.get(type);
+  }
   /** Get all registered trigger types */
   getRegisteredTriggerTypes() {
     return [...this.triggers.keys()];
@@ -79,6 +278,7 @@ var AutomationEngine = class {
   registerFlow(name, definition) {
     const parsed = import_automation.FlowSchema.parse(definition);
     this.detectCycles(parsed);
+    this.validateNodeTypes(name, parsed);
     const history = this.flowVersionHistory.get(name) ?? [];
     history.push({
       version: parsed.version,
@@ -91,8 +291,13 @@ var AutomationEngine = class {
       this.flowEnabled.set(name, true);
     }
     this.logger.info(`Flow registered: ${name} (version ${parsed.version})`);
+    this.deactivateFlowTrigger(name);
+    if (this.flowEnabled.get(name) !== false) {
+      this.activateFlowTrigger(name);
+    }
   }
   unregisterFlow(name) {
+    this.deactivateFlowTrigger(name);
     this.flows.delete(name);
     this.flowEnabled.delete(name);
     this.flowVersionHistory.delete(name);
@@ -110,6 +315,11 @@ var AutomationEngine = class {
     }
     this.flowEnabled.set(name, enabled);
     this.logger.info(`Flow '${name}' ${enabled ? "enabled" : "disabled"}`);
+    if (enabled) {
+      this.activateFlowTrigger(name);
+    } else {
+      this.deactivateFlowTrigger(name);
+    }
   }
   /** Get flow version history */
   getFlowVersionHistory(name) {
@@ -155,8 +365,16 @@ var AutomationEngine = class {
     }
     if (context?.record) {
       variables.set("$record", context.record);
+      variables.set("record", context.record);
+      for (const [k, v] of Object.entries(context.record)) {
+        if (!variables.has(k)) variables.set(k, v);
+      }
+    }
+    if (context?.previous) {
+      variables.set("previous", context.previous);
     }
     const runId = `run_${++this.runCounter}`;
+    variables.set("$runId", runId);
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const steps = [];
     try {
@@ -164,6 +382,14 @@ var AutomationEngine = class {
       if (!startNode) {
         return { success: false, error: "Flow has no start node" };
       }
+      const startCondition = startNode.config?.condition;
+      if (startCondition !== void 0 && startCondition !== null && startCondition !== "") {
+        const condExpr = typeof startCondition === "string" ? { dialect: "cel", source: startCondition } : startCondition;
+        if (!this.evaluateCondition(condExpr, variables)) {
+          this.logger.debug(`Flow '${flowName}' skipped: start condition not met`);
+          return { success: true, output: { skipped: true, reason: "condition_not_met" } };
+        }
+      }
       this.validateNodeInputSchemas(flow, variables);
       await this.executeNode(startNode, flow, variables, context ?? {}, steps);
       const output = {};
@@ -197,6 +423,43 @@ var AutomationEngine = class {
         durationMs
       };
     } catch (err) {
+      if (isSuspendSignal(err)) {
+        const durationMs2 = Date.now() - startTime;
+        this.suspendedRuns.set(runId, {
+          runId,
+          flowName,
+          flowVersion: flow.version,
+          nodeId: err.nodeId,
+          variables: Object.fromEntries(variables),
+          steps,
+          context: context ?? {},
+          startedAt,
+          startTime,
+          correlation: err.correlation,
+          screen: err.screen
+        });
+        this.recordLog({
+          id: runId,
+          flowName,
+          flowVersion: flow.version,
+          status: "paused",
+          startedAt,
+          durationMs: durationMs2,
+          trigger: {
+            type: context?.event ?? "manual",
+            userId: context?.userId,
+            object: context?.object
+          },
+          steps
+        });
+        return {
+          success: true,
+          status: "paused",
+          runId,
+          durationMs: durationMs2,
+          screen: err.screen
+        };
+      }
       const errorMessage = err instanceof Error ? err.message : String(err);
       const durationMs = Date.now() - startTime;
       this.recordLog({
@@ -225,6 +488,135 @@ var AutomationEngine = class {
       };
     }
   }
+  /**
+   * Resume a run suspended at a node (ADR-0019 durable pause). Restores the
+   * snapshotted variables, merges `signal.output` under the suspended node's
+   * id, and continues traversal from that node's out-edges — optionally
+   * restricted to the edge labelled `signal.branchLabel` (e.g. the approval
+   * decision). The continuation may itself suspend again, in which case this
+   * returns `{ status: 'paused', runId }` afresh.
+   */
+  async resume(runId, signal) {
+    const run = this.suspendedRuns.get(runId);
+    if (!run) {
+      return { success: false, error: `No suspended run '${runId}'` };
+    }
+    const flow = this.flows.get(run.flowName);
+    if (!flow) {
+      return { success: false, error: `Flow '${run.flowName}' not found for run '${runId}'` };
+    }
+    const node = flow.nodes.find((n) => n.id === run.nodeId);
+    if (!node) {
+      return { success: false, error: `Suspended node '${run.nodeId}' no longer exists in flow '${run.flowName}'` };
+    }
+    this.suspendedRuns.delete(runId);
+    const variables = new Map(Object.entries(run.variables));
+    if (signal?.output) {
+      for (const [key, value] of Object.entries(signal.output)) {
+        variables.set(`${run.nodeId}.${key}`, value);
+      }
+    }
+    if (signal?.variables) {
+      for (const [key, value] of Object.entries(signal.variables)) {
+        variables.set(key, value);
+      }
+    }
+    const steps = run.steps;
+    const context = run.context;
+    try {
+      await this.traverseNext(node, flow, variables, context, steps, signal?.branchLabel);
+      const output = {};
+      if (flow.variables) {
+        for (const v of flow.variables) {
+          if (v.isOutput) output[v.name] = variables.get(v.name);
+        }
+      }
+      const durationMs = Date.now() - run.startTime;
+      this.recordLog({
+        id: runId,
+        flowName: run.flowName,
+        flowVersion: run.flowVersion,
+        status: "completed",
+        startedAt: run.startedAt,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs,
+        trigger: {
+          type: context.event ?? "manual",
+          userId: context.userId,
+          object: context.object
+        },
+        steps,
+        output
+      });
+      return { success: true, output, durationMs };
+    } catch (err) {
+      if (isSuspendSignal(err)) {
+        const durationMs2 = Date.now() - run.startTime;
+        this.suspendedRuns.set(runId, {
+          ...run,
+          nodeId: err.nodeId,
+          variables: Object.fromEntries(variables),
+          steps,
+          correlation: err.correlation,
+          screen: err.screen
+        });
+        this.recordLog({
+          id: runId,
+          flowName: run.flowName,
+          flowVersion: run.flowVersion,
+          status: "paused",
+          startedAt: run.startedAt,
+          durationMs: durationMs2,
+          trigger: {
+            type: context.event ?? "manual",
+            userId: context.userId,
+            object: context.object
+          },
+          steps
+        });
+        return { success: true, status: "paused", runId, durationMs: durationMs2, screen: err.screen };
+      }
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      const durationMs = Date.now() - run.startTime;
+      this.recordLog({
+        id: runId,
+        flowName: run.flowName,
+        flowVersion: run.flowVersion,
+        status: "failed",
+        startedAt: run.startedAt,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs,
+        trigger: {
+          type: context.event ?? "manual",
+          userId: context.userId,
+          object: context.object
+        },
+        steps,
+        error: errorMessage
+      });
+      return { success: false, error: errorMessage, durationMs };
+    }
+  }
+  /**
+   * List the runs currently suspended awaiting {@link resume} (ADR-0019).
+   * Backs operability surfaces such as a "pending approvals" view.
+   */
+  listSuspendedRuns() {
+    return [...this.suspendedRuns.values()].map((r) => ({
+      runId: r.runId,
+      flowName: r.flowName,
+      nodeId: r.nodeId,
+      correlation: r.correlation
+    }));
+  }
+  /**
+   * The screen a paused run is currently waiting on (screen-flow runtime), or
+   * `null` if the run isn't suspended / didn't pause at a screen node. Lets a
+   * UI flow-runner re-fetch the form after a refresh.
+   */
+  getSuspendedScreen(runId) {
+    return this.suspendedRuns.get(runId)?.screen ?? null;
+  }
   // ── DAG Traversal Core ──────────────────────────────────
   recordLog(entry) {
     this.executionLogs.push(entry);
@@ -232,6 +624,29 @@ var AutomationEngine = class {
       this.executionLogs.splice(0, this.executionLogs.length - this.maxLogSize);
     }
   }
+  /**
+   * Validate each node's `type` against the live action registry (ADR-0018).
+   * A type is known if it is structural (start/end), has a registered
+   * executor, or has a published action descriptor. Unknown types are
+   * warned about (not rejected) so flows authored against a temporarily
+   * absent plugin still register; the runtime surfaces a hard NO_EXECUTOR
+   * error if such a node is actually executed.
+   */
+  validateNodeTypes(flowName, flow) {
+    const known = /* @__PURE__ */ new Set([
+      ...import_automation.FLOW_STRUCTURAL_NODE_TYPES,
+      ...this.nodeExecutors.keys(),
+      ...this.actionDescriptors.keys()
+    ]);
+    const unknown = [...new Set(
+      flow.nodes.map((n) => n.type).filter((t) => !known.has(t))
+    )];
+    if (unknown.length > 0) {
+      this.logger.warn(
+        `Flow '${flowName}' references node type(s) with no registered executor or descriptor: ${unknown.join(", ")}. They will fail at execution time unless a plugin registers them. Registered types: ${[...known].join(", ") || "(none)"}`
+      );
+    }
+  }
   /**
    * Detect cycles in the flow graph (DAG validation).
    * Uses DFS with coloring (white/gray/black) to detect back edges.
@@ -413,10 +828,30 @@ var AutomationEngine = class {
           variables.set(`${node.id}.${key}`, value);
         }
       }
+      if (result.suspend) {
+        throw new FlowSuspendSignal(node.id, result.correlation, result.screen);
+      }
     }
-    const outEdges = flow.edges.filter(
+    await this.traverseNext(node, flow, variables, context, steps);
+  }
+  /**
+   * Traverse a node's out-edges and execute its successors. Split out of
+   * {@link executeNode} so {@link resume} can re-enter traversal from a
+   * suspended node without re-running the node body.
+   *
+   * @param branchLabel - When set (e.g. from a resume signal), restrict
+   *   traversal to out-edges whose `label` matches — this is how an Approval
+   *   node's `approve`/`reject` decision selects its downstream branch. When
+   *   no edge carries the label, traversal falls back to the normal edge set.
+   */
+  async traverseNext(node, flow, variables, context, steps, branchLabel) {
+    let outEdges = flow.edges.filter(
       (e) => e.source === node.id && e.type !== "fault"
     );
+    if (branchLabel) {
+      const labeled = outEdges.filter((e) => e.label === branchLabel);
+      if (labeled.length > 0) outEdges = labeled;
+    }
     const conditionalEdges = [];
     const unconditionalEdges = [];
     for (const edge of outEdges) {
@@ -465,7 +900,6 @@ var AutomationEngine = class {
     }
     if (dialect === "cel" || isEnvelope && !dialect) {
       try {
-        const { ExpressionEngine } = require("@objectstack/formula");
         const vars = {};
         for (const [key, value] of variables) {
           const segs = key.split(".");
@@ -478,9 +912,9 @@ var AutomationEngine = class {
           }
           cursor[segs[segs.length - 1]] = value;
         }
-        const result = ExpressionEngine.evaluate(
+        const result = import_formula.ExpressionEngine.evaluate(
           { dialect: "cel", source: exprStr },
-          { extra: { vars }, record: vars }
+          { extra: { ...vars, vars }, record: vars }
         );
         if (!result.ok) return false;
         return Boolean(result.value);
@@ -663,76 +1097,81 @@ var AutomationEngine = class {
   }
 };
 
-// src/plugin.ts
-var AutomationServicePlugin = class {
-  constructor(options = {}) {
-    this.name = "com.objectstack.service-automation";
-    this.version = "1.0.0";
-    this.type = "standard";
-    // Soft dependency on metadata: we look it up at start() and tolerate absence.
-    // Do NOT declare a hard kernel dependency, so this plugin works in environments
-    // where MetadataPlugin is not registered.
-    this.dependencies = [];
-    this.options = options;
-  }
-  async init(ctx) {
-    this.engine = new AutomationEngine(ctx.logger);
-    ctx.registerService("automation", this.engine);
-    if (this.options.debug) {
-      ctx.hook("automation:beforeExecute", async (flowName) => {
-        ctx.logger.debug(`[Automation] Before execute: ${flowName}`);
-      });
-    }
-    ctx.logger.info("[Automation] Engine initialized");
-  }
-  async start(ctx) {
-    console.warn("[Automation:start] entering start()");
-    if (!this.engine) {
-      console.warn("[Automation:start] engine missing, bailing");
-      return;
+// src/builtin/logic-nodes.ts
+var import_automation2 = require("@objectstack/spec/automation");
+function registerLogicNodes(engine, ctx) {
+  engine.registerNodeExecutor({
+    type: "decision",
+    descriptor: (0, import_automation2.defineActionDescriptor)({
+      type: "decision",
+      version: "1.0.0",
+      name: "Decision",
+      description: "Branch execution based on conditions.",
+      icon: "git-branch",
+      category: "logic",
+      source: "builtin"
+    }),
+    async execute(node, variables, _context) {
+      const config = node.config;
+      const conditions = config?.conditions ?? [];
+      for (const cond of conditions) {
+        if (engine.evaluateCondition(cond.expression, variables)) {
+          return { success: true, branchLabel: cond.label };
+        }
+      }
+      return { success: true, branchLabel: "default" };
     }
-    await ctx.trigger("automation:ready", this.engine);
-    const nodeTypes = this.engine.getRegisteredNodeTypes();
-    ctx.logger.info(
-      `[Automation] Engine started with ${nodeTypes.length} node types: ${nodeTypes.join(", ") || "(none)"}`
-    );
-    try {
-      const ql = ctx.getService("objectql");
-      if (!ql) {
-        console.warn("[Automation] objectql service not found at start()");
-      } else if (!ql.registry) {
-        console.warn("[Automation] objectql.registry is undefined at start()");
-      } else if (typeof ql.registry.listItems !== "function") {
-        console.warn("[Automation] objectql.registry.listItems is not a function");
+  });
+  engine.registerNodeExecutor({
+    type: "assignment",
+    descriptor: (0, import_automation2.defineActionDescriptor)({
+      type: "assignment",
+      version: "1.0.0",
+      name: "Assignment",
+      description: "Set flow variables.",
+      icon: "variable",
+      category: "logic",
+      source: "builtin"
+    }),
+    async execute(node, variables, _context) {
+      const config = node.config ?? {};
+      for (const [key, value] of Object.entries(config)) {
+        variables.set(key, value);
       }
-      const flows = ql?.registry?.listItems?.("flow") ?? [];
-      console.warn(`[Automation] flow pull: registry returned ${flows.length} flow(s)`);
-      let registered = 0;
-      for (const f of flows) {
-        const def = f;
-        if (!def?.name) continue;
-        try {
-          this.engine.registerFlow(def.name, def);
-          registered++;
-        } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
-          ctx.logger.warn(`[Automation] failed to register flow ${def.name}: ${msg}`);
+      return { success: true };
+    }
+  });
+  engine.registerNodeExecutor({
+    type: "loop",
+    descriptor: (0, import_automation2.defineActionDescriptor)({
+      type: "loop",
+      version: "1.0.0",
+      name: "Loop",
+      description: "Iterate over a collection.",
+      icon: "repeat",
+      category: "logic",
+      source: "builtin"
+    }),
+    async execute(node, variables, _context) {
+      const config = node.config;
+      const collectionName = config?.collection;
+      if (collectionName) {
+        const collection = variables.get(collectionName);
+        if (Array.isArray(collection)) {
+          variables.set("$loopItems", collection);
+          variables.set("$loopIndex", 0);
         }
       }
-      if (registered > 0) {
-        ctx.logger.info(`[Automation] Pulled ${registered} flow(s) from ObjectQL registry`);
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      ctx.logger.warn(`[Automation] flow pull from ObjectQL registry failed: ${msg}`);
+      return { success: true };
     }
-  }
-  async destroy() {
-    this.engine = void 0;
-  }
-};
+  });
+  ctx.logger.info("[Logic Nodes] 3 built-in node executors registered");
+}
+
+// src/builtin/crud-nodes.ts
+var import_automation3 = require("@objectstack/spec/automation");
 
-// src/plugins/template.ts
+// src/builtin/template.ts
 function resolvePath(base, path) {
   let cur = base;
   for (const seg of path) {
@@ -829,269 +1268,498 @@ function interpolate(value, variables, context) {
   return value;
 }
 
-// src/plugins/crud-nodes-plugin.ts
-var CrudNodesPlugin = class {
-  constructor() {
-    this.name = "com.objectstack.automation.crud-nodes";
-    this.version = "1.0.0";
-    this.type = "standard";
-    this.dependencies = ["com.objectstack.service-automation"];
-  }
-  async init(ctx) {
-    const engine = ctx.getService("automation");
-    const getData = () => {
-      try {
-        return ctx.getService("data") ?? ctx.getService("objectql");
-      } catch {
-        return void 0;
-      }
-    };
-    engine.registerNodeExecutor({
+// src/builtin/crud-nodes.ts
+function registerCrudNodes(engine, ctx) {
+  const getData = () => {
+    try {
+      return ctx.getService("data") ?? ctx.getService("objectql");
+    } catch {
+      return void 0;
+    }
+  };
+  engine.registerNodeExecutor({
+    type: "get_record",
+    descriptor: (0, import_automation3.defineActionDescriptor)({
       type: "get_record",
-      async execute(node, variables, context) {
-        const cfg = node.config ?? {};
-        const objectName = String(cfg.objectName ?? cfg.object ?? "");
-        if (!objectName) return { success: false, error: "get_record: objectName required" };
-        const filter = interpolate(cfg.filter ?? cfg.filters ?? {}, variables, context);
-        const fields = cfg.fields;
-        const limit = typeof cfg.limit === "number" ? cfg.limit : void 0;
-        const outputVariable = cfg.outputVariable;
-        const data = getData();
-        if (!data) {
-          ctx.logger.warn(`[get_record] no data engine; skipping ${objectName}`);
-          return { success: true, output: { records: [], object: objectName } };
-        }
-        try {
-          if (limit && limit > 1) {
-            const records = await data.find(objectName, { where: filter, fields, limit });
-            if (outputVariable) variables.set(outputVariable, records);
-            return { success: true, output: { records, object: objectName } };
-          }
-          const record = await data.findOne(objectName, { where: filter, fields });
-          if (outputVariable) variables.set(outputVariable, record);
-          return { success: true, output: { record, id: record?.id, object: objectName } };
-        } catch (err) {
-          return { success: false, error: `get_record(${objectName}) failed: ${err.message}` };
+      version: "1.0.0",
+      name: "Get Records",
+      description: "Query records from an object.",
+      icon: "search",
+      category: "data",
+      source: "builtin"
+    }),
+    async execute(node, variables, context) {
+      const cfg = node.config ?? {};
+      const objectName = String(cfg.objectName ?? cfg.object ?? "");
+      if (!objectName) return { success: false, error: "get_record: objectName required" };
+      const filter = interpolate(cfg.filter ?? cfg.filters ?? {}, variables, context);
+      const fields = cfg.fields;
+      const limit = typeof cfg.limit === "number" ? cfg.limit : void 0;
+      const outputVariable = cfg.outputVariable;
+      const data = getData();
+      if (!data) {
+        ctx.logger.warn(`[get_record] no data engine; skipping ${objectName}`);
+        return { success: true, output: { records: [], object: objectName } };
+      }
+      try {
+        if (limit && limit > 1) {
+          const records = await data.find(objectName, { where: filter, fields, limit });
+          if (outputVariable) variables.set(outputVariable, records);
+          return { success: true, output: { records, object: objectName } };
         }
+        const record = await data.findOne(objectName, { where: filter, fields });
+        if (outputVariable) variables.set(outputVariable, record);
+        return { success: true, output: { record, id: record?.id, object: objectName } };
+      } catch (err) {
+        return { success: false, error: `get_record(${objectName}) failed: ${err.message}` };
       }
-    });
-    engine.registerNodeExecutor({
+    }
+  });
+  engine.registerNodeExecutor({
+    type: "create_record",
+    descriptor: (0, import_automation3.defineActionDescriptor)({
       type: "create_record",
-      async execute(node, variables, context) {
-        const cfg = node.config ?? {};
-        const objectName = String(cfg.objectName ?? cfg.object ?? "");
-        if (!objectName) return { success: false, error: "create_record: objectName required" };
-        const fields = interpolate(cfg.fields ?? {}, variables, context);
-        const outputVariable = cfg.outputVariable;
-        const data = getData();
-        if (!data) {
-          ctx.logger.warn(`[create_record] no data engine; skipping ${objectName}`);
-          if (outputVariable) variables.set(outputVariable, `mock-${objectName}-${Date.now()}`);
-          return { success: true, output: { id: `mock-${objectName}-${Date.now()}`, object: objectName } };
-        }
-        try {
-          const created = await data.insert(objectName, fields);
-          const insertedId = Array.isArray(created) ? created[0]?.id : created?.id ?? created;
-          if (outputVariable) variables.set(outputVariable, insertedId);
-          return { success: true, output: { id: insertedId, record: created, object: objectName } };
-        } catch (err) {
-          return { success: false, error: `create_record(${objectName}) failed: ${err.message}` };
-        }
+      version: "1.0.0",
+      name: "Create Record",
+      description: "Insert a new record into an object.",
+      icon: "plus-circle",
+      category: "data",
+      source: "builtin"
+    }),
+    async execute(node, variables, context) {
+      const cfg = node.config ?? {};
+      const objectName = String(cfg.objectName ?? cfg.object ?? "");
+      if (!objectName) return { success: false, error: "create_record: objectName required" };
+      const fields = interpolate(cfg.fields ?? {}, variables, context);
+      const outputVariable = cfg.outputVariable;
+      const data = getData();
+      if (!data) {
+        ctx.logger.warn(`[create_record] no data engine; skipping ${objectName}`);
+        if (outputVariable) variables.set(outputVariable, `mock-${objectName}-${Date.now()}`);
+        return { success: true, output: { id: `mock-${objectName}-${Date.now()}`, object: objectName } };
       }
-    });
-    engine.registerNodeExecutor({
+      try {
+        const created = await data.insert(objectName, fields);
+        const insertedId = Array.isArray(created) ? created[0]?.id : created?.id ?? created;
+        if (outputVariable) variables.set(outputVariable, insertedId);
+        return { success: true, output: { id: insertedId, record: created, object: objectName } };
+      } catch (err) {
+        return { success: false, error: `create_record(${objectName}) failed: ${err.message}` };
+      }
+    }
+  });
+  engine.registerNodeExecutor({
+    type: "update_record",
+    descriptor: (0, import_automation3.defineActionDescriptor)({
       type: "update_record",
-      async execute(node, variables, context) {
-        const cfg = node.config ?? {};
-        const objectName = String(cfg.objectName ?? cfg.object ?? "");
-        if (!objectName) return { success: false, error: "update_record: objectName required" };
-        const filter = interpolate(cfg.filter ?? cfg.filters ?? {}, variables, context);
-        const fields = interpolate(cfg.fields ?? {}, variables, context);
-        const data = getData();
-        if (!data) {
-          ctx.logger.warn(`[update_record] no data engine; skipping ${objectName}`);
-          return { success: true };
-        }
-        try {
-          const result = await data.update(objectName, fields, { where: filter });
-          return { success: true, output: { result, object: objectName } };
-        } catch (err) {
-          return { success: false, error: `update_record(${objectName}) failed: ${err.message}` };
-        }
+      version: "1.0.0",
+      name: "Update Records",
+      description: "Update records matching a filter.",
+      icon: "edit",
+      category: "data",
+      source: "builtin"
+    }),
+    async execute(node, variables, context) {
+      const cfg = node.config ?? {};
+      const objectName = String(cfg.objectName ?? cfg.object ?? "");
+      if (!objectName) return { success: false, error: "update_record: objectName required" };
+      const filter = interpolate(cfg.filter ?? cfg.filters ?? {}, variables, context);
+      const fields = interpolate(cfg.fields ?? {}, variables, context);
+      const data = getData();
+      if (!data) {
+        ctx.logger.warn(`[update_record] no data engine; skipping ${objectName}`);
+        return { success: true };
       }
-    });
-    engine.registerNodeExecutor({
+      try {
+        const result = await data.update(objectName, fields, { where: filter });
+        return { success: true, output: { result, object: objectName } };
+      } catch (err) {
+        return { success: false, error: `update_record(${objectName}) failed: ${err.message}` };
+      }
+    }
+  });
+  engine.registerNodeExecutor({
+    type: "delete_record",
+    descriptor: (0, import_automation3.defineActionDescriptor)({
       type: "delete_record",
-      async execute(node, variables, context) {
-        const cfg = node.config ?? {};
-        const objectName = String(cfg.objectName ?? cfg.object ?? "");
-        if (!objectName) return { success: false, error: "delete_record: objectName required" };
-        const filter = interpolate(cfg.filter ?? cfg.filters ?? {}, variables, context);
-        const data = getData();
-        if (!data) return { success: true };
-        try {
-          const result = await data.delete(objectName, { where: filter });
-          return { success: true, output: { result, object: objectName } };
-        } catch (err) {
-          return { success: false, error: `delete_record(${objectName}) failed: ${err.message}` };
-        }
+      version: "1.0.0",
+      name: "Delete Records",
+      description: "Delete records matching a filter.",
+      icon: "trash",
+      category: "data",
+      source: "builtin"
+    }),
+    async execute(node, variables, context) {
+      const cfg = node.config ?? {};
+      const objectName = String(cfg.objectName ?? cfg.object ?? "");
+      if (!objectName) return { success: false, error: "delete_record: objectName required" };
+      const filter = interpolate(cfg.filter ?? cfg.filters ?? {}, variables, context);
+      const data = getData();
+      if (!data) return { success: true };
+      try {
+        const result = await data.delete(objectName, { where: filter });
+        return { success: true, output: { result, object: objectName } };
+      } catch (err) {
+        return { success: false, error: `delete_record(${objectName}) failed: ${err.message}` };
       }
-    });
-    ctx.logger.info("[CRUD Nodes] 4 node executors registered (data-backed)");
-  }
-};
+    }
+  });
+  ctx.logger.info("[CRUD Nodes] 4 built-in node executors registered (data-backed)");
+}
 
-// src/plugins/logic-nodes-plugin.ts
-var LogicNodesPlugin = class {
-  constructor() {
-    this.name = "com.objectstack.automation.logic-nodes";
-    this.version = "1.0.0";
-    this.type = "standard";
-    this.dependencies = ["com.objectstack.service-automation"];
-  }
-  async init(ctx) {
-    const engine = ctx.getService("automation");
-    engine.registerNodeExecutor({
-      type: "decision",
-      async execute(node, variables, _context) {
-        const config = node.config;
-        const conditions = config?.conditions ?? [];
-        for (const cond of conditions) {
-          if (engine.evaluateCondition(cond.expression, variables)) {
-            return { success: true, branchLabel: cond.label };
-          }
-        }
-        return { success: true, branchLabel: "default" };
-      }
-    });
-    engine.registerNodeExecutor({
-      type: "assignment",
-      async execute(node, variables, _context) {
-        const config = node.config ?? {};
-        for (const [key, value] of Object.entries(config)) {
-          variables.set(key, value);
-        }
+// src/builtin/screen-nodes.ts
+var import_automation4 = require("@objectstack/spec/automation");
+function registerScreenNodes(engine, ctx) {
+  engine.registerNodeExecutor({
+    type: "screen",
+    descriptor: (0, import_automation4.defineActionDescriptor)({
+      type: "screen",
+      version: "1.0.0",
+      name: "Screen",
+      description: "Collect user input via a screen (human-input element).",
+      icon: "window",
+      category: "human",
+      source: "builtin",
+      // Human-input nodes suspend the flow awaiting input.
+      supportsPause: true,
+      isAsync: true
+    }),
+    async execute(node, _variables, _context) {
+      const cfg = node.config ?? {};
+      const rawFields = Array.isArray(cfg.fields) ? cfg.fields : [];
+      const hasFields = rawFields.length > 0;
+      const shouldPause = cfg.waitForInput === true || hasFields && cfg.waitForInput !== false;
+      if (!shouldPause) {
         return { success: true };
       }
-    });
-    engine.registerNodeExecutor({
-      type: "loop",
-      async execute(node, variables, _context) {
-        const config = node.config;
-        const collectionName = config?.collection;
-        if (collectionName) {
-          const collection = variables.get(collectionName);
-          if (Array.isArray(collection)) {
-            variables.set("$loopItems", collection);
-            variables.set("$loopIndex", 0);
-          }
+      const fields = rawFields.map((f) => ({
+        name: String(f.name ?? ""),
+        label: f.label != null ? String(f.label) : void 0,
+        type: f.type != null ? String(f.type) : void 0,
+        required: f.required === true,
+        options: Array.isArray(f.options) ? f.options : void 0,
+        defaultValue: f.defaultValue,
+        placeholder: f.placeholder != null ? String(f.placeholder) : void 0
+      })).filter((f) => f.name.length > 0);
+      return {
+        success: true,
+        suspend: true,
+        screen: {
+          nodeId: node.id,
+          title: cfg.title ?? node.label ?? "Input",
+          description: cfg.description,
+          fields
         }
-        return { success: true };
+      };
+    }
+  });
+  engine.registerNodeExecutor({
+    type: "script",
+    descriptor: (0, import_automation4.defineActionDescriptor)({
+      type: "script",
+      version: "1.0.0",
+      name: "Script",
+      description: "Run a custom script action.",
+      icon: "code",
+      category: "logic",
+      source: "builtin"
+    }),
+    async execute(node, _variables, _context) {
+      const cfg = node.config ?? {};
+      const actionType = cfg.actionType ?? "noop";
+      if (actionType === "email") {
+        ctx.logger.info(
+          `[Script:email] template=${String(cfg.template)} recipients=${JSON.stringify(cfg.recipients)} vars=${JSON.stringify(cfg.variables)}`
+        );
+        return {
+          success: true,
+          output: {
+            actionType,
+            template: cfg.template,
+            recipients: cfg.recipients
+          }
+        };
       }
-    });
-    ctx.logger.info("[Logic Nodes] 3 node executors registered");
-  }
-};
+      ctx.logger.info(`[Script:${actionType}] node=${node.id} executed (no-op handler)`);
+      return { success: true, output: { actionType } };
+    }
+  });
+  ctx.logger.info("[Screen/Script Nodes] 2 built-in node executors registered");
+}
 
-// src/plugins/http-connector-plugin.ts
-var HttpConnectorPlugin = class {
-  constructor() {
-    this.name = "com.objectstack.automation.http-connector";
-    this.version = "1.0.0";
-    this.type = "standard";
-    this.dependencies = ["com.objectstack.service-automation"];
-  }
-  async init(ctx) {
-    const engine = ctx.getService("automation");
-    engine.registerNodeExecutor({
+// src/builtin/http-nodes.ts
+var import_automation5 = require("@objectstack/spec/automation");
+function registerHttpNodes(engine, ctx) {
+  engine.registerNodeExecutor({
+    type: "http_request",
+    descriptor: (0, import_automation5.defineActionDescriptor)({
       type: "http_request",
-      async execute(node, _variables, _context) {
-        const config = node.config;
-        const url = config?.url;
-        const method = config?.method ?? "GET";
-        const headers = config?.headers;
-        const body = config?.body;
-        if (!url) {
-          return { success: false, error: "http_request: url is required" };
+      version: "1.0.0",
+      name: "HTTP Request",
+      description: "Call an external HTTP endpoint. (ADR-0018: migrates to outbox-backed `http`.)",
+      icon: "globe",
+      category: "io",
+      source: "builtin",
+      // ADR-0018 §M3 target: route via service-messaging outbox for
+      // retry/idempotency/dead-letter. Today this is a bare fetch().
+      needsOutbox: false,
+      supportsRetry: true,
+      paradigms: ["flow", "workflow_rule", "approval"]
+    }),
+    async execute(node, _variables, _context) {
+      const config = node.config;
+      const url = config?.url;
+      const method = config?.method ?? "GET";
+      const headers = config?.headers;
+      const body = config?.body;
+      if (!url) {
+        return { success: false, error: "http_request: url is required" };
+      }
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0
+      });
+      const data = await response.json();
+      return {
+        success: response.ok,
+        output: { response: data, status: response.status },
+        error: response.ok ? void 0 : `HTTP ${response.status}`
+      };
+    }
+  });
+  ctx.logger.info("[HTTP] 1 built-in node executor registered (http_request)");
+}
+
+// src/builtin/connector-nodes.ts
+var import_automation6 = require("@objectstack/spec/automation");
+function registerConnectorNodes(engine, ctx) {
+  engine.registerNodeExecutor({
+    type: "connector_action",
+    descriptor: (0, import_automation6.defineActionDescriptor)({
+      type: "connector_action",
+      version: "1.0.0",
+      name: "Connector Action",
+      description: "Invoke an action on a registered connector (Slack, Salesforce, a REST API, \u2026). The connector itself is contributed by an integration plugin via registerConnector().",
+      icon: "plug",
+      category: "io",
+      source: "builtin",
+      supportsRetry: true,
+      // Present in all three authoring paradigms (ADR-0018 §registry table).
+      paradigms: ["flow", "workflow_rule", "approval"],
+      // Config contract — drives the Studio property form and flow validation.
+      configSchema: {
+        type: "object",
+        required: ["connectorId", "actionId"],
+        properties: {
+          connectorId: { type: "string", description: "Registered connector name" },
+          actionId: { type: "string", description: "Action key declared by the connector" },
+          input: { type: "object", description: "Mapped inputs for the action" }
         }
-        const response = await fetch(url, {
-          method,
-          headers,
-          body: body ? JSON.stringify(body) : void 0
-        });
-        const data = await response.json();
+      }
+    }),
+    async execute(node, variables, context) {
+      const cfg = node.connectorConfig;
+      if (!cfg?.connectorId || !cfg?.actionId) {
         return {
-          success: response.ok,
-          output: { response: data, status: response.status },
-          error: response.ok ? void 0 : `HTTP ${response.status}`
+          success: false,
+          error: `connector_action '${node.id}': connectorConfig.connectorId and .actionId are required`
         };
       }
-    });
-    engine.registerNodeExecutor({
-      type: "connector_action",
-      async execute(node, _variables, _context) {
-        const connectorConfig = node.connectorConfig;
-        if (!connectorConfig) {
-          return { success: false, error: "connector_action: connectorConfig is required" };
-        }
-        ctx.logger.info(
-          `Connector action: ${connectorConfig.connectorId}.${connectorConfig.actionId}`
+      const handler = engine.resolveConnectorAction(cfg.connectorId, cfg.actionId);
+      if (!handler) {
+        return {
+          success: false,
+          error: `connector_action '${node.id}': no handler for '${cfg.connectorId}.${cfg.actionId}' \u2014 is the connector plugin registered?`
+        };
+      }
+      const handlerCtx = {
+        variables,
+        automation: context,
+        logger: ctx.logger
+      };
+      try {
+        const output = await handler(cfg.input ?? {}, handlerCtx);
+        return { success: true, output };
+      } catch (err) {
+        return {
+          success: false,
+          error: `connector_action(${cfg.connectorId}.${cfg.actionId}) failed: ${err.message}`
+        };
+      }
+    }
+  });
+  ctx.logger.info("[Connector] 1 built-in node executor registered (connector_action)");
+}
+
+// src/builtin/notify-node.ts
+var import_automation7 = require("@objectstack/spec/automation");
+function toStringList(value) {
+  if (Array.isArray(value)) return value.map((v) => String(v)).filter(Boolean);
+  if (typeof value === "string" && value.trim()) return [value.trim()];
+  return [];
+}
+function registerNotifyNode(engine, ctx) {
+  const getMessaging = () => {
+    try {
+      return ctx.getService("messaging");
+    } catch {
+      return void 0;
+    }
+  };
+  engine.registerNodeExecutor({
+    type: "notify",
+    descriptor: (0, import_automation7.defineActionDescriptor)({
+      type: "notify",
+      version: "1.0.0",
+      name: "Notify",
+      description: "Send an outbound notification to users via the messaging service (inbox / email / push / \u2026).",
+      icon: "bell",
+      category: "io",
+      source: "builtin",
+      supportsRetry: true,
+      paradigms: ["flow", "workflow_rule", "approval"]
+    }),
+    async execute(node, variables, context) {
+      const cfg = node.config ?? {};
+      const recipients = toStringList(interpolate(cfg.recipients ?? cfg.to ?? [], variables, context));
+      const title = String(interpolate(cfg.title ?? cfg.subject ?? "", variables, context) ?? "");
+      const body = String(interpolate(cfg.message ?? cfg.body ?? "", variables, context) ?? "");
+      const channels = toStringList(cfg.channels);
+      const topic = cfg.topic ? String(cfg.topic) : void 0;
+      const severity = cfg.severity ? String(cfg.severity) : void 0;
+      const actionUrl = cfg.actionUrl ? String(interpolate(cfg.actionUrl, variables, context) ?? "") : void 0;
+      const payload = cfg.payload ? interpolate(cfg.payload, variables, context) : void 0;
+      if (!title) return { success: false, error: "notify: title (or subject) is required" };
+      if (recipients.length === 0) {
+        return { success: false, error: "notify: at least one recipient is required" };
+      }
+      const messaging = getMessaging();
+      if (!messaging) {
+        ctx.logger.warn(
+          `[notify] no messaging service registered; notification "${title}" not delivered`
         );
-        return { success: true, output: { connectorResult: {} } };
+        return {
+          success: true,
+          output: { delivered: 0, failed: 0, skipped: true }
+        };
       }
-    });
-    ctx.logger.info("[HTTP Connector] 2 node executors registered");
-  }
-};
+      try {
+        const result = await messaging.emit({
+          topic: topic ?? "notify",
+          audience: recipients,
+          payload: { ...payload ?? {}, title, body, url: actionUrl },
+          severity,
+          channels: channels.length ? channels : void 0
+        });
+        return {
+          success: true,
+          output: {
+            notificationId: result.notificationId,
+            delivered: result.delivered,
+            failed: result.failed
+          }
+        };
+      } catch (err) {
+        return { success: false, error: `notify failed: ${err.message}` };
+      }
+    }
+  });
+  ctx.logger.info("[Notify] 1 built-in node executor registered (notify)");
+}
 
-// src/plugins/screen-nodes-plugin.ts
-var ScreenNodesPlugin = class {
-  constructor() {
-    this.name = "com.objectstack.automation.screen-nodes";
+// src/builtin/index.ts
+function installBuiltinNodes(engine, ctx) {
+  registerLogicNodes(engine, ctx);
+  registerCrudNodes(engine, ctx);
+  registerScreenNodes(engine, ctx);
+  registerHttpNodes(engine, ctx);
+  registerConnectorNodes(engine, ctx);
+  registerNotifyNode(engine, ctx);
+  const types = engine.getRegisteredNodeTypes();
+  ctx.logger.info(
+    `[Automation] ${types.length} built-in node executors installed: ${types.join(", ")}`
+  );
+}
+
+// src/plugin.ts
+var AutomationServicePlugin = class {
+  constructor(options = {}) {
+    this.name = "com.objectstack.service-automation";
     this.version = "1.0.0";
     this.type = "standard";
-    this.dependencies = ["com.objectstack.service-automation"];
+    // Soft dependency on metadata: we look it up at start() and tolerate absence.
+    // Do NOT declare a hard kernel dependency, so this plugin works in environments
+    // where MetadataPlugin is not registered.
+    this.dependencies = [];
+    this.options = options;
   }
   async init(ctx) {
-    const engine = ctx.getService("automation");
-    engine.registerNodeExecutor({
-      type: "screen",
-      async execute(_node, _variables, _context) {
-        return { success: true };
+    this.engine = new AutomationEngine(ctx.logger);
+    ctx.registerService("automation", this.engine);
+    installBuiltinNodes(this.engine, ctx);
+    if (this.options.debug) {
+      ctx.hook("automation:beforeExecute", async (flowName) => {
+        ctx.logger.debug(`[Automation] Before execute: ${flowName}`);
+      });
+    }
+    ctx.logger.info("[Automation] Engine initialized");
+  }
+  async start(ctx) {
+    console.warn("[Automation:start] entering start()");
+    if (!this.engine) {
+      console.warn("[Automation:start] engine missing, bailing");
+      return;
+    }
+    await ctx.trigger("automation:ready", this.engine);
+    const nodeTypes = this.engine.getRegisteredNodeTypes();
+    ctx.logger.info(
+      `[Automation] Engine started with ${nodeTypes.length} node types: ${nodeTypes.join(", ") || "(none)"}`
+    );
+    try {
+      const ql = ctx.getService("objectql");
+      if (!ql) {
+        console.warn("[Automation] objectql service not found at start()");
+      } else if (!ql.registry) {
+        console.warn("[Automation] objectql.registry is undefined at start()");
+      } else if (typeof ql.registry.listItems !== "function") {
+        console.warn("[Automation] objectql.registry.listItems is not a function");
       }
-    });
-    engine.registerNodeExecutor({
-      type: "script",
-      async execute(node, _variables, _context) {
-        const cfg = node.config ?? {};
-        const actionType = cfg.actionType ?? "noop";
-        if (actionType === "email") {
-          ctx.logger.info(
-            `[Script:email] template=${String(cfg.template)} recipients=${JSON.stringify(cfg.recipients)} vars=${JSON.stringify(cfg.variables)}`
-          );
-          return {
-            success: true,
-            output: {
-              actionType,
-              template: cfg.template,
-              recipients: cfg.recipients
-            }
-          };
+      const flows = ql?.registry?.listItems?.("flow") ?? [];
+      console.warn(`[Automation] flow pull: registry returned ${flows.length} flow(s)`);
+      let registered = 0;
+      for (const f of flows) {
+        const def = f;
+        if (!def?.name) continue;
+        try {
+          this.engine.registerFlow(def.name, def);
+          registered++;
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          ctx.logger.warn(`[Automation] failed to register flow ${def.name}: ${msg}`);
         }
-        ctx.logger.info(`[Script:${actionType}] node=${node.id} executed (no-op handler)`);
-        return { success: true, output: { actionType } };
       }
-    });
-    ctx.logger.info("[Screen/Script Nodes] 2 node executors registered");
+      if (registered > 0) {
+        ctx.logger.info(`[Automation] Pulled ${registered} flow(s) from ObjectQL registry`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      ctx.logger.warn(`[Automation] flow pull from ObjectQL registry failed: ${msg}`);
+    }
+  }
+  async destroy() {
+    this.engine = void 0;
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AutomationEngine,
   AutomationServicePlugin,
-  CrudNodesPlugin,
-  HttpConnectorPlugin,
-  LogicNodesPlugin,
-  ScreenNodesPlugin
+  installBuiltinNodes,
+  registerConnectorNodes,
+  registerCrudNodes,
+  registerHttpNodes,
+  registerLogicNodes,
+  registerScreenNodes
 });
 //# sourceMappingURL=index.cjs.map