@mndrk/agx 2.0.19 → 2.0.21

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/package-lock.json

@@ -21,6 +21,7 @@
         "ai": "^6.0.86",
         "better-sqlite3": "12.6.2",
         "cel-js": "^0.8.2",
+        "cron-parser": "^5.5.0",
         "diff": "^8.0.3",
         "fast-glob": "^3.3.3",
         "lucide-react": "^0.575.0",
@@ -5878,6 +5879,18 @@
       "integrity": "sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==",
       "license": "MIT"
     },
+    "node_modules/cron-parser": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/cron-parser/-/cron-parser-5.5.0.tgz",
+      "integrity": "sha512-oML4lKUXxizYswqmxuOCpgFS8BNUJpIu6k/2HVHyaL8Ynnf3wdf9tkns0yRdJLSIjkJ+b0DXHMZEHGpMwjnPww==",
+      "license": "MIT",
+      "dependencies": {
+        "luxon": "^3.7.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/cross-spawn": {
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
@@ -10344,6 +10357,15 @@
         "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
       }
     },
+    "node_modules/luxon": {
+      "version": "3.7.2",
+      "resolved": "https://registry.npmjs.org/luxon/-/luxon-3.7.2.tgz",
+      "integrity": "sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/lz-string": {
       "version": "1.5.0",
       "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/package.json

@@ -39,6 +39,7 @@
     "ai": "^6.0.86",
     "better-sqlite3": "12.6.2",
     "cel-js": "^0.8.2",
+    "cron-parser": "^5.5.0",
     "diff": "^8.0.3",
     "fast-glob": "^3.3.3",
     "lucide-react": "^0.575.0",

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/scripts/debug-schedule.sh

@@ -0,0 +1,108 @@
+#!/bin/bash
+# Debug a schedule tick step-by-step
+#
+# Usage:
+#   ./scripts/debug-schedule.sh <rootMessageId>          # dry run
+#   ./scripts/debug-schedule.sh <rootMessageId> --run     # live execution
+#
+# Shows: workflow overview → tick check → each node (input → processing → output) → completion
+
+ROOT_ID="${1:?Usage: debug-schedule.sh <rootMessageId> [--run]}"
+RUN_FLAG=""
+[ "$2" = "--run" ] && RUN_FLAG="&run=1"
+
+BASE="http://localhost:41741"
+RAW=$(curl -sf "${BASE}/api/schedules/debug?rootMessageId=${ROOT_ID}${RUN_FLAG}")
+
+if [ $? -ne 0 ]; then
+  echo "Error: could not reach ${BASE} or graph not found"
+  exit 1
+fi
+
+echo "$RAW" | python3 -c "
+import json, sys
+
+data = json.load(sys.stdin)
+W = data.get('workflow', {})
+TC = data.get('tickCheck', {})
+nodes = data.get('nodes', [])
+C = data.get('completion', {})
+
+# ── Workflow
+print('━' * 60)
+print('  WORKFLOW:', W.get('id', '?'))
+print('━' * 60)
+sched = W.get('schedule', {})
+print(f\"  state={sched.get('state')}  interval={sched.get('intervalMs')}ms  runs={sched.get('runCount')}  tickInProgress={sched.get('tickInProgress')}\")
+if sched.get('lastTickAt'):
+    print(f\"  lastTick={sched['lastTickAt']}\")
+print()
+print('  Pipeline:')
+for line in W.get('pipeline', []):
+    print(f'    {line}')
+print()
+print('  Nodes:')
+for nid, info in W.get('nodes', {}).items():
+    parts = [f\"type={info['type']}\", f\"status={info['status']}\"]
+    if 'command' in info:
+        cmd = info['command']
+        if len(cmd) > 60: cmd = cmd[:57] + '...'
+        parts.append(f\"cmd=\\\"{cmd}\\\"\")
+    if 'expression' in info:
+        parts.append(f\"expr=\\\"{info['expression']}\\\"\")
+    if 'inputFrom' in info:
+        parts.append(f\"from={info['inputFrom']}\")
+    print(f\"    [{nid}] {', '.join(parts)}\")
+
+# ── Tick check
+print()
+print('━' * 60)
+print('  TICK CHECK')
+print('━' * 60)
+if TC.get('tickFired'):
+    print('  ✓ Tick fired — nodes reset to pending')
+else:
+    print(f\"  ✗ Tick skipped: {TC.get('skipReason', '?')}\")
+    sys.exit(0)
+
+# ── Nodes step-by-step
+for i, node in enumerate(nodes):
+    print()
+    print('━' * 60)
+    ntype = node.get('type', '?').upper()
+    print(f\"  NODE {i+1}: [{node.get('node')}] ({ntype})\")
+    print('━' * 60)
+
+    inp = node.get('input', {})
+    print('  Input:')
+    if isinstance(inp, dict):
+        for k, v in inp.items():
+            val = json.dumps(v) if isinstance(v, (dict, list)) else str(v)
+            if len(val) > 80: val = val[:77] + '...'
+            print(f'    {k}: {val}')
+    else:
+        print(f'    {inp}')
+
+    print(f\"  Processing: {node.get('processing', '?')}\")
+
+    out = node.get('output', {})
+    print('  Output:')
+    if isinstance(out, dict):
+        for k, v in out.items():
+            val = json.dumps(v) if isinstance(v, (dict, list)) else str(v)
+            if len(val) > 100: val = val[:97] + '...'
+            print(f'    {k}: {val}')
+    else:
+        print(f'    {out}')
+
+# ── Completion
+print()
+print('━' * 60)
+print('  COMPLETION')
+print('━' * 60)
+icon = '✓' if C.get('complete') else '✗'
+print(f\"  {icon} Tick complete: {C.get('complete')}\")
+for rn in C.get('resetNodes', []):
+    print(f\"    [{rn['id']}] → {rn['status']}\")
+print()
+"

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/src/graph/api-schemas.ts

@@ -11,7 +11,7 @@ const isoTimestampSchema = z
 const nonEmptyStringSchema = z.string().trim().min(1);
 
 export const GraphModeSchema = z.enum(["SIMPLE", "PROJECT"]);
-export const NodeTypeSchema = z.enum(["work", "gate", "fork", "join", "conditional", "root"]);
+export const NodeTypeSchema = z.enum(["work", "gate", "fork", "join", "conditional", "root", "function"]);
 export const NodeStatusSchema = z.enum([
   "pending",
   "running",
@@ -153,6 +153,18 @@ const ConditionalNodeSchema = BaseNodeSchema.extend({
   evaluatedTo: z.enum(["then", "else"]).optional(),
 });
 
+const FunctionNodeSchema = BaseNodeSchema.extend({
+  type: z.literal("function"),
+  status: z.enum(["pending", "running", "done", "failed", "skipped"]),
+  kind: z.enum(["bash", "mcp"]),
+  title: nonEmptyStringSchema,
+  description: z.string().optional(),
+  command: nonEmptyStringSchema,
+  args: z.record(z.string(), z.unknown()).optional(),
+  timeoutMs: z.number().optional(),
+  output: z.record(z.string(), z.unknown()).optional(),
+});
+
 export const GraphNodeSchema = z.discriminatedUnion("type", [
   RootNodeSchema,
   WorkNodeSchema,
@@ -160,6 +172,7 @@ export const GraphNodeSchema = z.discriminatedUnion("type", [
   ForkNodeSchema,
   JoinNodeSchema,
   ConditionalNodeSchema,
+  FunctionNodeSchema,
 ]);
 
 export const EdgeSchema = z.object({
@@ -281,6 +294,19 @@ const RuntimeEventSchema = z.union([
   BudgetConsumedEventSchema,
 ]);
 
+export const GraphScheduleSchema = z.object({
+  intervalMs: z.number().int().positive(),
+  state: z.enum(["active", "paused", "stopped"]),
+  resetNodeIds: z.array(z.string()),
+  maxRuns: z.number().int().positive().optional(),
+  runCount: z.number().int().nonnegative(),
+  lastTickAt: z.number().optional(),
+  tickInProgress: z.boolean(),
+  createdAt: isoTimestampSchema,
+  activeUntil: isoTimestampSchema.optional(),
+  rootMessageId: nonEmptyStringSchema.optional(),
+});
+
 export const ExecutionGraphSchema = z.object({
   id: nonEmptyStringSchema,
   taskId: nonEmptyStringSchema,
@@ -290,6 +316,7 @@ export const ExecutionGraphSchema = z.object({
   edges: z.array(EdgeSchema),
   policy: ExecutionPolicySchema,
   doneCriteria: DoneCriteriaSchema,
+  schedule: GraphScheduleSchema.optional(),
   versionHistory: z.array(VersionHistoryEventSchema),
   runtimeEvents: z.array(RuntimeEventSchema).optional(),
   createdAt: isoTimestampSchema,
@@ -337,6 +364,11 @@ const GraphNodePartialInputSchema = z
     thenBranch: z.array(z.string()).optional(),
     elseBranch: z.array(z.string()).optional(),
     evaluatedTo: z.enum(["then", "else"]).optional(),
+    // Function node fields
+    kind: z.enum(["bash", "mcp"]).optional(),
+    command: z.string().optional(),
+    args: z.record(z.string(), z.unknown()).optional(),
+    timeoutMs: z.number().optional(),
     // Root node fields
     objective: z.string().optional(),
     graphCreated: z.boolean().optional(),
@@ -351,6 +383,7 @@ export const CreateGraphRequestSchema = z.object({
   edges: z.array(EdgeSchema).optional(),
   policy: ExecutionPolicySchema.partial().optional(),
   doneCriteria: DoneCriteriaSchema.partial().optional(),
+  schedule: GraphScheduleSchema.optional(),
   ifMatchGraphVersion: z.number().int().positive().optional(),
   projectId: nonEmptyStringSchema.optional(),
   project_id: nonEmptyStringSchema.optional(),
@@ -392,6 +425,7 @@ export const DaemonGraphPatchRequestSchema = z.object({
   edges: z.array(EdgeSchema).optional(),
   policy: ExecutionPolicySchema.partial().optional(),
   doneCriteria: DoneCriteriaSchema.partial().optional(),
+  schedule: GraphScheduleSchema.optional(),
   runtimeEvents: z.array(RuntimeEventSchema).optional(),
   status: z.string().optional(),
   startedAt: isoTimestampSchema.optional(),

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/src/graph/executor.ts

@@ -1,3 +1,6 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
 import { evaluateCondition } from './condition';
 import {
   verifyGate,
@@ -10,12 +13,14 @@ import { isDepSatisfied } from './scheduler';
 import {
   transitionConditionalNode,
   transitionForkNode,
+  transitionFunctionNode,
   transitionGateNode,
   transitionJoinNode,
   transitionWorkNode,
 } from './state-machine';
 import type {
   ExecutionGraph,
+  FunctionNode,
   GraphNode,
   NodeMetrics,
   RuntimeEvent,
@@ -40,8 +45,20 @@ export type WorkDispatchResult =
       error?: unknown;
     };
 
+export type FunctionDispatchResult =
+  | {
+      status: 'success';
+      output?: Record<string, unknown>;
+    }
+  | {
+      status: 'failure';
+      message?: string;
+      error?: unknown;
+    };
+
 export interface ExecutorContext {
   dispatchWork?: (node: WorkNode, graph: ExecutionGraph) => Promise<WorkDispatchResult>;
+  dispatchFunction?: (node: FunctionNode, graph: ExecutionGraph) => Promise<FunctionDispatchResult>;
   sleep?: (ms: number) => Promise<void>;
   nowMs?: () => number;
   graphStartedAtMs?: number;
@@ -101,6 +118,8 @@ export class NodeExecutionTimeoutError extends Error {
 }
 
 const noOpSleep = async (): Promise<void> => undefined;
+const execFileAsync = promisify(execFile);
+const FUNCTION_STDOUT_MAX_BUFFER_BYTES = 64 * 1024;
 
 function nowMs(context: ExecutorContext): number {
   return context.nowMs?.() ?? Date.now();
@@ -119,6 +138,7 @@ function resolveGraphStartedAtMs(graph: ExecutionGraph, context: ExecutorContext
 }
 
 function assertGraphWithinTimeout(graph: ExecutionGraph, context: ExecutorContext): void {
+  if (!graph.policy.graphTimeoutMs) return; // 0 or undefined = no timeout
   const startedAtMs = resolveGraphStartedAtMs(graph, context);
   const elapsedMs = nowMs(context) - startedAtMs;
   if (elapsedMs > graph.policy.graphTimeoutMs) {
@@ -137,6 +157,85 @@ function resolveNodeTimeoutMs(graph: ExecutionGraph, node: GraphNode): number {
   return Math.max(1, graph.policy.nodeTimeoutMs);
 }
 
+function extractFunctionOutputFromStdout(stdout: string, nodeId: string): Record<string, unknown> {
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    throw new Error(`Function node "${nodeId}" produced empty stdout.`);
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Function node "${nodeId}" stdout is not valid JSON: ${message}`);
+  }
+
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`Function node "${nodeId}" stdout JSON must be an object.`);
+  }
+
+  return parsed as Record<string, unknown>;
+}
+
+function formatFunctionDispatchError(error: unknown): string {
+  if (error && typeof error === 'object') {
+    const candidate = error as {
+      code?: string | number;
+      message?: string;
+      stderr?: string;
+      stdout?: string;
+      killed?: boolean;
+      signal?: string;
+    };
+
+    if (candidate.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
+      return `Function stdout exceeded ${FUNCTION_STDOUT_MAX_BUFFER_BYTES} bytes.`;
+    }
+
+    if (candidate.killed && candidate.signal) {
+      return `Function command timed out and was terminated (${candidate.signal}).`;
+    }
+
+    const stderr = candidate.stderr?.trim();
+    if (stderr) {
+      return stderr;
+    }
+
+    if (candidate.message) {
+      return candidate.message;
+    }
+  }
+
+  return typeof error === 'string' ? error : 'Unknown function execution error.';
+}
+
+async function dispatchBashFunctionNode(
+  node: FunctionNode,
+  graph: ExecutionGraph,
+): Promise<FunctionDispatchResult> {
+  const timeoutMs = Math.max(1, node.timeoutMs ?? graph.policy.nodeTimeoutMs);
+  try {
+    const { stdout } = await execFileAsync('bash', ['-lc', node.command], {
+      timeout: timeoutMs,
+      maxBuffer: FUNCTION_STDOUT_MAX_BUFFER_BYTES,
+      env: process.env,
+      windowsHide: true,
+    });
+
+    return {
+      status: 'success',
+      output: extractFunctionOutputFromStdout(stdout, node.command),
+    };
+  } catch (error) {
+    return {
+      status: 'failure',
+      message: formatFunctionDispatchError(error),
+      error,
+    };
+  }
+}
+
 async function withTimeout<T>(
   task: Promise<T>,
   timeoutMs: number,
@@ -217,7 +316,9 @@ function resolveConditionContext(
   }
   const sourceNode = graph.nodes[node.condition.inputFrom];
   const sourceOutput =
-    sourceNode && sourceNode.type === 'work' ? (sourceNode.output ?? {}) : sourceNode ?? null;
+    sourceNode && 'output' in sourceNode
+      ? (sourceNode.output ?? null)
+      : null;
 
   return {
     graph,
@@ -234,6 +335,10 @@ function resolveConditionContext(
   };
 }
 
+function hasStructuredConditionInput(input: unknown): input is Record<string, unknown> {
+  return Boolean(input) && typeof input === 'object' && !Array.isArray(input);
+}
+
 function skipBranchNodes(
   graph: ExecutionGraph,
   skippedNodeIds: string[],
@@ -246,6 +351,8 @@ function skipBranchNodes(
 
     if (node.type === 'work') {
       graph.nodes[skippedNodeId] = transitionWorkNode(node, { type: 'SKIP' });
+    } else if (node.type === 'function') {
+      graph.nodes[skippedNodeId] = transitionFunctionNode(node, { type: 'SKIP' });
     } else if (node.type === 'gate') {
       graph.nodes[skippedNodeId] = transitionGateNode(node, { type: 'SKIP' });
     } else if (node.type === 'fork') {
@@ -505,6 +612,72 @@ function executeJoinNode(
   return next;
 }
 
+async function executeFunctionNode(
+  graph: ExecutionGraph,
+  nodeId: string,
+  node: FunctionNode,
+  context: ExecutorContext,
+): Promise<{ node: FunctionNode; timedOut: boolean }> {
+  let current = node;
+  if (current.status === 'pending') {
+    current = transitionFunctionNode(current, { type: 'START', depsSatisfied: true });
+  }
+  if (!current.startedAt) {
+    current = { ...current, startedAt: nowIso(context) };
+  }
+
+  const startedAtMs = nowMs(context);
+  const timeoutMs = current.timeoutMs ?? graph.policy.nodeTimeoutMs;
+  let timedOut = false;
+
+  try {
+    const dispatch = context.dispatchFunction
+      ?? (current.kind === 'bash'
+        ? dispatchBashFunctionNode
+        : (async () => ({
+            status: 'failure' as const,
+            message: `No function dispatcher is configured for kind "${current.kind}".`,
+          })));
+    const result = await withTimeout(
+      dispatch(current, graph),
+      timeoutMs,
+      () => new NodeExecutionTimeoutError(nodeId, timeoutMs),
+    );
+
+    if (result.status === 'success') {
+      const done = transitionFunctionNode(current, { type: 'COMPLETE' });
+      return {
+        node: finalizeMetrics(
+          { ...done, output: result.output ?? done.output },
+          startedAtMs,
+          context,
+        ) as FunctionNode,
+        timedOut,
+      };
+    }
+
+    const failed = transitionFunctionNode(current, { type: 'FAIL' });
+    const withError = result.message ? appendError(failed, result.message) : failed;
+    if (result.message?.toLowerCase().includes('timed out')) {
+      timedOut = true;
+    }
+    return {
+      node: finalizeMetrics(withError, startedAtMs, context) as FunctionNode,
+      timedOut,
+    };
+  } catch (error) {
+    const normalizedError =
+      error instanceof Error ? error : new Error(typeof error === 'string' ? error : 'Unknown function execution error');
+    timedOut = normalizedError instanceof NodeExecutionTimeoutError;
+    const failed = transitionFunctionNode(current, { type: 'FAIL' });
+    const withError = appendError(failed, normalizedError.message);
+    return {
+      node: finalizeMetrics(withError, startedAtMs, context) as FunctionNode,
+      timedOut,
+    };
+  }
+}
+
 function executeConditionalNode(
   graph: ExecutionGraph,
   nodeId: string,
@@ -527,10 +700,15 @@ function executeConditionalNode(
   }).node;
 
   try {
-    const evaluatedTrue = evaluateCondition(
-      node.condition.expression,
-      resolveConditionContext(graph, nodeId, context.conditionContextByNodeId ?? {}),
+    const conditionContext = resolveConditionContext(
+      graph,
+      nodeId,
+      context.conditionContextByNodeId ?? {},
     );
+    // Fail-safe: missing/unstructured input resolves to else branch without throwing.
+    const evaluatedTrue = hasStructuredConditionInput(conditionContext.input)
+      ? evaluateCondition(node.condition.expression, conditionContext)
+      : false;
     const completed = transitionConditionalNode(started, {
       type: evaluatedTrue ? 'CONDITION_TRUE' : 'CONDITION_FALSE',
     });
@@ -559,6 +737,19 @@ export async function executeNode(
     throw new Error(`Unknown node "${nodeId}".`);
   }
 
+  if (node.type === 'function') {
+    const result = await executeFunctionNode(nextGraph, nodeId, node, context);
+    nextGraph.nodes[nodeId] = result.node;
+    return {
+      graph: nextGraph,
+      nodeId,
+      node: nextGraph.nodes[nodeId],
+      events: [],
+      replanApplied: false,
+      timedOut: result.timedOut,
+    };
+  }
+
   if (node.type === 'work') {
     const result = await executeWorkNode(nextGraph, nodeId, node, context);
     nextGraph.nodes[nodeId] = result.node;

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/src/graph/function-executor.ts

@@ -0,0 +1,154 @@
+import { spawn } from 'child_process';
+import type { FunctionNode, ExecutionGraph } from './types';
+
+export interface FunctionDispatchResult {
+  status: 'success' | 'failure';
+  output?: Record<string, unknown>;
+  message?: string;
+  error?: unknown;
+}
+
+/**
+ * Maximum stdout buffer size (64KB) to prevent runaway endpoints from eating memory.
+ */
+const MAX_STDOUT_BYTES = 64 * 1024;
+
+/**
+ * Execute a bash function node by running the command and parsing JSON stdout.
+ *
+ * Invariants:
+ * - Command is executed with timeout
+ * - Stdout is capped at MAX_STDOUT_BYTES
+ * - JSON output is parsed and stored in node.output
+ * - On timeout, non-zero exit, or malformed output: status=failure
+ */
+export async function dispatchBashFunction(
+  node: FunctionNode,
+  _graph: ExecutionGraph,
+): Promise<FunctionDispatchResult> {
+  if (node.kind !== 'bash') {
+    return {
+      status: 'failure',
+      message: `Unsupported function node kind: ${node.kind}`,
+    };
+  }
+
+  const command = node.command;
+  if (!command || command.trim() === '') {
+    return {
+      status: 'failure',
+      message: 'Empty command',
+    };
+  }
+
+  const timeoutMs = node.timeoutMs ?? 30000;
+
+  return new Promise((resolve) => {
+    let stdout = '';
+    let stderr = '';
+    let stdoutBytes = 0;
+    let truncated = false;
+    let killed = false;
+
+    const proc = spawn(command, [], {
+      shell: true,
+      timeout: timeoutMs,
+      killSignal: 'SIGTERM',
+    });
+
+    const timeoutId = setTimeout(() => {
+      killed = true;
+      proc.kill('SIGTERM');
+    }, timeoutMs);
+
+    proc.stdout.on('data', (chunk: Buffer | string) => {
+      if (truncated) return;
+
+      const chunkBytes = Buffer.byteLength(chunk.toString(), 'utf8');
+      if (stdoutBytes + chunkBytes > MAX_STDOUT_BYTES) {
+        truncated = true;
+        return;
+      }
+
+      stdout += chunk.toString();
+      stdoutBytes += chunkBytes;
+    });
+
+    proc.stderr.on('data', (chunk: Buffer | string) => {
+      stderr += chunk.toString();
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(timeoutId);
+      resolve({
+        status: 'failure',
+        message: `Failed to spawn command: ${err.message}`,
+        error: err,
+      });
+    });
+
+    proc.on('close', (code) => {
+      clearTimeout(timeoutId);
+
+      if (killed) {
+        resolve({
+          status: 'failure',
+          message: `Command timed out after ${timeoutMs}ms`,
+        });
+        return;
+      }
+
+      if (truncated) {
+        resolve({
+          status: 'failure',
+          message: `Stdout exceeded ${MAX_STDOUT_BYTES} bytes limit`,
+        });
+        return;
+      }
+
+      if (code !== 0) {
+        resolve({
+          status: 'failure',
+          message: `Command exited with code ${code}: ${stderr || '(no stderr)'}`,
+        });
+        return;
+      }
+
+      // Parse stdout — try JSON first, fall back to raw text
+      const trimmed = stdout.trim();
+      if (trimmed === '') {
+        resolve({ status: 'success', output: {} });
+        return;
+      }
+
+      try {
+        const output = JSON.parse(trimmed) as Record<string, unknown>;
+        resolve({ status: 'success', output });
+      } catch {
+        // Non-JSON output is fine — store as raw text
+        resolve({ status: 'success', output: { raw: trimmed } });
+      }
+    });
+  });
+}
+
+/**
+ * Create a dispatchFunction implementation that handles both bash and (future) MCP.
+ * Currently only bash is supported.
+ */
+export function createDispatchFunction(): (
+  node: FunctionNode,
+  graph: ExecutionGraph,
+) => Promise<FunctionDispatchResult> {
+  return async (node, graph) => {
+    switch (node.kind) {
+      case 'bash':
+        return dispatchBashFunction(node, graph);
+      default:
+        return {
+          status: 'failure',
+          message: `Unsupported function node kind: ${node.kind}`,
+        };
+    }
+  };
+}