@synergenius/flow-weaver 0.22.5 → 0.22.7

package/dist/agent/providers/claude-cli.js

@@ -0,0 +1,155 @@
+/**
+ * Claude CLI provider — spawns the Claude Code CLI with stream-json output
+ * and MCP bridge for tool execution.
+ *
+ * Adapted from platform's streamClaudeCliChat. Platform-specific dependencies
+ * (spawnSandboxed, getBinPath, config) are replaced with injectable options.
+ */
+import { spawn as nodeSpawn } from 'node:child_process';
+import { StreamJsonParser } from '../streaming.js';
+import { createMcpBridge } from '../mcp-bridge.js';
+export class ClaudeCliProvider {
+    binPath;
+    cwd;
+    env;
+    model;
+    mcpConfigPath;
+    spawnFn;
+    timeout;
+    constructor(options = {}) {
+        this.binPath = options.binPath ?? 'claude';
+        this.cwd = options.cwd ?? process.cwd();
+        this.env = options.env ?? process.env;
+        this.model = options.model;
+        this.mcpConfigPath = options.mcpConfigPath;
+        this.spawnFn = options.spawnFn ?? ((cmd, args, opts) => nodeSpawn(cmd, args, { ...opts, stdio: opts.stdio }));
+        this.timeout = options.timeout ?? 120_000;
+    }
+    async *stream(messages, tools, options) {
+        const model = options?.model ?? this.model;
+        // Format messages into a single prompt for -p mode
+        const prompt = formatPrompt(messages);
+        const systemPrompt = options?.systemPrompt;
+        // Set up MCP bridge for tool access if tools are provided and no config given
+        let bridge = null;
+        let mcpConfigPath = this.mcpConfigPath;
+        if (tools.length > 0 && !mcpConfigPath) {
+            // Create a temporary bridge — tool execution is handled by the agent loop,
+            // but we still need to advertise tool definitions to the CLI via MCP.
+            // The bridge executor won't be called because the CLI handles its own tool
+            // loop internally when using MCP tools.
+            bridge = await createMcpBridge(tools, async () => ({ result: 'Not implemented', isError: true }));
+            mcpConfigPath = bridge.configPath;
+        }
+        const args = [
+            '-p',
+            '--verbose',
+            '--output-format',
+            'stream-json',
+            '--include-partial-messages',
+            '--setting-sources',
+            'user,local',
+            '--dangerously-skip-permissions',
+            '--permission-mode',
+            'bypassPermissions',
+            ...(systemPrompt ? ['--system-prompt', systemPrompt] : []),
+            ...(mcpConfigPath ? ['--mcp-config', mcpConfigPath, '--strict-mcp-config'] : []),
+            ...(model ? ['--model', model] : []),
+        ];
+        // Spawn the CLI process
+        const spawnResult = this.spawnFn(this.binPath, args, { cwd: this.cwd, stdio: ['pipe', 'pipe', 'pipe'], env: this.env });
+        const child = 'child' in spawnResult ? spawnResult.child : spawnResult;
+        const spawnCleanup = 'cleanup' in spawnResult ? spawnResult.cleanup : undefined;
+        const signal = options?.signal;
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                child.kill('SIGTERM');
+                setTimeout(() => {
+                    if (!child.killed)
+                        child.kill('SIGKILL');
+                }, 2000);
+            }, { once: true });
+        }
+        // Timeout
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+        }, this.timeout);
+        child.stdin.write(prompt);
+        child.stdin.end();
+        // Collect events from the parser
+        const events = [];
+        let done = false;
+        const parser = new StreamJsonParser((event) => {
+            events.push(event);
+        });
+        let stderrBuf = '';
+        child.stderr.on('data', (chunk) => {
+            stderrBuf += chunk.toString();
+        });
+        let stdoutBuffer = '';
+        child.stdout.on('data', (chunk) => {
+            stdoutBuffer += chunk.toString();
+            const lines = stdoutBuffer.split('\n');
+            stdoutBuffer = lines.pop() || '';
+            for (const line of lines) {
+                parser.feed(line);
+            }
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            // Process remaining buffer
+            if (stdoutBuffer.trim()) {
+                parser.feed(stdoutBuffer);
+            }
+            if (code !== 0 && !parser.hasText && stderrBuf.trim()) {
+                events.push({ type: 'text_delta', text: `Claude CLI error: ${stderrBuf.trim().slice(0, 500)}` });
+            }
+            if (!events.some((e) => e.type === 'message_stop')) {
+                events.push({ type: 'message_stop', finishReason: code === 0 ? 'stop' : 'error' });
+            }
+            done = true;
+        });
+        child.on('error', () => {
+            clearTimeout(timer);
+            events.push({ type: 'message_stop', finishReason: 'error' });
+            done = true;
+        });
+        // Yield events as they become available
+        try {
+            while (!done || events.length > 0) {
+                if (events.length > 0) {
+                    yield events.shift();
+                }
+                else {
+                    await new Promise((r) => setTimeout(r, 10));
+                }
+            }
+        }
+        finally {
+            bridge?.cleanup();
+            spawnCleanup?.();
+        }
+    }
+}
+/**
+ * Format agent messages into a single prompt string for the CLI's -p mode.
+ */
+function formatPrompt(messages) {
+    const parts = [];
+    for (const msg of messages) {
+        if (msg.role === 'user') {
+            parts.push(`User: ${typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)}\n`);
+        }
+        else if (msg.role === 'assistant') {
+            parts.push(`Assistant: ${typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)}\n`);
+        }
+        else if (msg.role === 'tool') {
+            parts.push(`Tool result (${msg.toolCallId}): ${typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)}\n`);
+        }
+    }
+    return parts.join('\n');
+}
+export function createClaudeCliProvider(options) {
+    return new ClaudeCliProvider(options);
+}
+//# sourceMappingURL=claude-cli.js.map

package/dist/agent/streaming.d.ts

@@ -0,0 +1,36 @@
+/**
+ * StreamJsonParser — parses Claude CLI stream-json NDJSON output into
+ * typed StreamEvent values.
+ *
+ * Extracted from the duplicated parsing logic in platform's claude.ts
+ * and cli-session.ts. Handles:
+ * - stream_event wrapper unwrapping
+ * - content_block lifecycle (text, tool_use, thinking)
+ * - Tool argument accumulation (input_json_delta → tool_use_end)
+ * - Tool result blocks from CLI's internal tool loop (user events)
+ * - Usage tracking from message_start, message_delta, and result
+ * - result event as text fallback and turn boundary
+ *
+ * The parser does NOT decide turn boundaries — consumers (one-shot vs
+ * persistent session) handle that differently.
+ */
+import type { StreamEvent } from './types.js';
+export type EventCallback = (event: StreamEvent) => void;
+export declare class StreamJsonParser {
+    private pushEvent;
+    private hasAssistantText;
+    private insideToolUse;
+    private activeToolJsonChunks;
+    constructor(pushEvent: EventCallback);
+    /** Reset per-turn state. Call before starting a new turn in persistent sessions. */
+    reset(): void;
+    /** Whether any text_delta events have been emitted this turn. */
+    get hasText(): boolean;
+    /**
+     * Feed a single NDJSON line (without trailing newline).
+     * Parses and emits StreamEvent(s) via the callback.
+     */
+    feed(line: string): void;
+    private processEvent;
+}
+//# sourceMappingURL=streaming.d.ts.map

package/dist/agent/streaming.js

@@ -0,0 +1,183 @@
+/**
+ * StreamJsonParser — parses Claude CLI stream-json NDJSON output into
+ * typed StreamEvent values.
+ *
+ * Extracted from the duplicated parsing logic in platform's claude.ts
+ * and cli-session.ts. Handles:
+ * - stream_event wrapper unwrapping
+ * - content_block lifecycle (text, tool_use, thinking)
+ * - Tool argument accumulation (input_json_delta → tool_use_end)
+ * - Tool result blocks from CLI's internal tool loop (user events)
+ * - Usage tracking from message_start, message_delta, and result
+ * - result event as text fallback and turn boundary
+ *
+ * The parser does NOT decide turn boundaries — consumers (one-shot vs
+ * persistent session) handle that differently.
+ */
+export class StreamJsonParser {
+    pushEvent;
+    hasAssistantText = false;
+    insideToolUse = false;
+    activeToolJsonChunks = new Map();
+    constructor(pushEvent) {
+        this.pushEvent = pushEvent;
+    }
+    /** Reset per-turn state. Call before starting a new turn in persistent sessions. */
+    reset() {
+        this.hasAssistantText = false;
+        this.insideToolUse = false;
+        this.activeToolJsonChunks.clear();
+    }
+    /** Whether any text_delta events have been emitted this turn. */
+    get hasText() {
+        return this.hasAssistantText;
+    }
+    /**
+     * Feed a single NDJSON line (without trailing newline).
+     * Parses and emits StreamEvent(s) via the callback.
+     */
+    feed(line) {
+        if (!line.trim())
+            return;
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            // Non-JSON line — only use as text if no other source is available
+            if (line.trim() && !this.hasAssistantText) {
+                this.pushEvent({ type: 'text_delta', text: line });
+            }
+            return;
+        }
+        // Unwrap stream_event wrapper (--include-partial-messages wraps API events)
+        if (event.type === 'stream_event' && event.event) {
+            event = event.event;
+        }
+        this.processEvent(event);
+    }
+    processEvent(event) {
+        const block = event.content_block;
+        const delta = event.delta;
+        // --- content_block_start ---
+        if (event.type === 'content_block_start' && block?.type === 'tool_use') {
+            this.insideToolUse = true;
+            const id = block.id || `cli-tool-${Date.now()}`;
+            const name = block.name || 'unknown';
+            this.pushEvent({ type: 'tool_use_start', id, name });
+            this.activeToolJsonChunks.set(id, { name, chunks: [] });
+            return;
+        }
+        if (event.type === 'content_block_start' && block?.type === 'text') {
+            this.insideToolUse = false;
+            return;
+        }
+        // --- content_block_delta ---
+        if (event.type === 'content_block_delta' && delta?.type === 'input_json_delta') {
+            const lastTool = [...this.activeToolJsonChunks.entries()].pop();
+            if (lastTool)
+                lastTool[1].chunks.push(delta.partial_json || '');
+            return;
+        }
+        if (event.type === 'content_block_delta' && delta?.type === 'thinking_delta' && delta?.thinking) {
+            this.pushEvent({ type: 'thinking_delta', text: delta.thinking });
+            return;
+        }
+        if (event.type === 'content_block_delta' && delta?.text && !this.insideToolUse) {
+            this.hasAssistantText = true;
+            this.pushEvent({ type: 'text_delta', text: delta.text });
+            return;
+        }
+        // --- content_block_stop ---
+        if (event.type === 'content_block_stop' && this.insideToolUse) {
+            const lastTool = [...this.activeToolJsonChunks.entries()].pop();
+            if (lastTool) {
+                const [id, { chunks }] = lastTool;
+                let args = {};
+                try {
+                    args = JSON.parse(chunks.join(''));
+                }
+                catch {
+                    /* malformed */
+                }
+                this.pushEvent({ type: 'tool_use_end', id, arguments: args });
+                this.activeToolJsonChunks.delete(id);
+            }
+            this.insideToolUse = false;
+            return;
+        }
+        // --- user event with tool_result blocks (CLI's internal tool loop) ---
+        if (event.type === 'user' && event.message?.content) {
+            const content = event.message.content;
+            for (const contentBlock of content) {
+                if (contentBlock.type === 'tool_result' && contentBlock.tool_use_id) {
+                    const text = Array.isArray(contentBlock.content)
+                        ? contentBlock.content
+                            .map((c) => c.text || '')
+                            .join('')
+                        : String(contentBlock.content || '');
+                    this.pushEvent({
+                        type: 'tool_result',
+                        id: contentBlock.tool_use_id,
+                        result: text,
+                        isError: !!contentBlock.is_error,
+                    });
+                }
+            }
+            return;
+        }
+        // --- message_start (usage) ---
+        if (event.type === 'message_start' && event.message?.usage) {
+            const usage = event.message.usage;
+            this.pushEvent({
+                type: 'usage',
+                promptTokens: usage.input_tokens ?? 0,
+                completionTokens: usage.output_tokens ?? 0,
+            });
+            return;
+        }
+        // --- message_delta (usage) ---
+        if (event.type === 'message_delta' && event.usage) {
+            const usage = event.usage;
+            this.pushEvent({
+                type: 'usage',
+                promptTokens: 0,
+                completionTokens: usage.output_tokens ?? 0,
+            });
+            return;
+        }
+        // --- message_stop ---
+        if (event.type === 'message_stop') {
+            this.pushEvent({ type: 'message_stop', finishReason: 'stop' });
+            return;
+        }
+        // --- result event (CLI turn boundary) ---
+        if (event.type === 'result') {
+            if (event.is_error) {
+                this.pushEvent({ type: 'message_stop', finishReason: 'error' });
+                return;
+            }
+            // result text is a fallback — only use if content_block_delta never fired
+            if (event.result && !this.hasAssistantText) {
+                this.pushEvent({ type: 'text_delta', text: event.result });
+            }
+            if (event.usage) {
+                const usage = event.usage;
+                this.pushEvent({
+                    type: 'usage',
+                    promptTokens: usage.input_tokens ?? 0,
+                    completionTokens: usage.output_tokens ?? 0,
+                });
+            }
+            this.pushEvent({ type: 'message_stop', finishReason: 'stop' });
+            return;
+        }
+        // --- assistant event (auth failure detection) ---
+        if (event.type === 'assistant') {
+            if (event.error === 'authentication_failed') {
+                this.pushEvent({ type: 'message_stop', finishReason: 'error' });
+            }
+        }
+    }
+}
+//# sourceMappingURL=streaming.js.map

package/dist/agent/types.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Shared types for the agent loop, providers, and MCP bridge.
+ *
+ * All types are pure — no runtime imports, no side effects.
+ */
+import type { ChildProcess } from 'node:child_process';
+export type StreamEvent = {
+    type: 'text_delta';
+    text: string;
+} | {
+    type: 'thinking_delta';
+    text: string;
+} | {
+    type: 'tool_use_start';
+    id: string;
+    name: string;
+} | {
+    type: 'tool_use_delta';
+    id: string;
+    partialJson: string;
+} | {
+    type: 'tool_use_end';
+    id: string;
+    arguments: Record<string, unknown>;
+} | {
+    type: 'tool_result';
+    id: string;
+    result: string;
+    isError: boolean;
+} | {
+    type: 'message_stop';
+    finishReason: 'stop' | 'tool_calls' | 'length' | 'error';
+} | {
+    type: 'usage';
+    promptTokens: number;
+    completionTokens: number;
+};
+export interface AgentMessage {
+    role: 'user' | 'assistant' | 'tool';
+    content: string | Array<Record<string, unknown>>;
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        arguments: Record<string, unknown>;
+    }>;
+    toolCallId?: string;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+export type ToolExecutor = (name: string, args: Record<string, unknown>) => Promise<{
+    result: string;
+    isError: boolean;
+}>;
+export interface ToolEvent {
+    type: 'tool_call_start' | 'tool_call_result';
+    name: string;
+    args?: Record<string, unknown>;
+    result?: string;
+    isError?: boolean;
+}
+export interface StreamOptions {
+    systemPrompt?: string;
+    model?: string;
+    maxTokens?: number;
+    signal?: AbortSignal;
+}
+export interface AgentProvider {
+    stream(messages: AgentMessage[], tools: ToolDefinition[], options?: StreamOptions): AsyncGenerator<StreamEvent>;
+}
+export interface McpBridge {
+    /** Path to the MCP config JSON file — pass to --mcp-config */
+    configPath: string;
+    /** Update the executor and event callback for a new request */
+    setHandlers: (executor: ToolExecutor, onToolEvent?: (event: ToolEvent) => void) => void;
+    /** Tear down the socket server and remove temp files */
+    cleanup: () => void;
+}
+export interface AgentLoopOptions {
+    systemPrompt?: string;
+    maxIterations?: number;
+    maxTokens?: number;
+    model?: string;
+    signal?: AbortSignal;
+    onToolEvent?: (event: ToolEvent) => void;
+    onStreamEvent?: (event: StreamEvent) => void;
+    logger?: Logger;
+}
+export interface AgentLoopResult {
+    success: boolean;
+    summary: string;
+    messages: AgentMessage[];
+    toolCallCount: number;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+}
+export type SpawnFn = (command: string, args: string[], options: {
+    cwd: string;
+    stdio: string[];
+    env: NodeJS.ProcessEnv;
+}) => ChildProcess | {
+    child: ChildProcess;
+    cleanup?: () => void;
+};
+export interface ClaudeCliProviderOptions {
+    /** Absolute path to the claude binary. Defaults to 'claude' (found via PATH). */
+    binPath?: string;
+    /** Working directory for the CLI process. */
+    cwd?: string;
+    /** Environment variables for the CLI process. */
+    env?: NodeJS.ProcessEnv;
+    /** Model override. */
+    model?: string;
+    /** Pre-configured MCP config path (skips auto-bridge creation). */
+    mcpConfigPath?: string;
+    /** Custom spawn function. Defaults to child_process.spawn. */
+    spawnFn?: SpawnFn;
+    /** CLI timeout in milliseconds. Defaults to 120000. */
+    timeout?: number;
+}
+export interface CliSessionOptions {
+    /** Absolute path to the claude binary. */
+    binPath: string;
+    /** Working directory for the CLI process. */
+    cwd: string;
+    /** Environment variables for the CLI process. */
+    env?: NodeJS.ProcessEnv;
+    /** Model to use. */
+    model: string;
+    /** Pre-configured MCP config path. */
+    mcpConfigPath?: string;
+    /** Custom spawn function. Defaults to child_process.spawn. */
+    spawnFn?: SpawnFn;
+    /** Idle timeout in milliseconds. Defaults to 600000 (10 minutes). */
+    idleTimeout?: number;
+    /** Logger instance. */
+    logger?: Logger;
+}
+export interface Logger {
+    info(msg: string, data?: unknown): void;
+    warn(msg: string, data?: unknown): void;
+    error(msg: string, data?: unknown): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/agent/types.js

@@ -0,0 +1,7 @@
+/**
+ * Shared types for the agent loop, providers, and MCP bridge.
+ *
+ * All types are pure — no runtime imports, no side effects.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/cli/flow-weaver.mjs

@@ -9886,7 +9886,7 @@ var VERSION;
 var init_generated_version = __esm({
   "src/generated-version.ts"() {
     "use strict";
-    VERSION = "0.22.5";
+    VERSION = "0.22.7";
   }
 });
 
@@ -10791,16 +10791,35 @@ function buildNodeArgumentsWithContext(opts) {
   } else if (skipPorts?.has("execute")) {
     args.push(`${safeId}_execute`);
   } else if (executeConnections.length > 0) {
-    const conn = executeConnections[0];
-    const sourceNode = conn.from.node;
-    const sourcePort = conn.from.port;
     const varName = `${safeId}_execute`;
-    const sourceIdx = isStartNode(sourceNode) ? "startIdx" : `${toValidIdentifier(sourceNode)}Idx`;
-    const isConstSource = isStartNode(sourceNode) || sourceNode === instanceParent;
-    const nonNullAssert = isConstSource ? "" : "!";
-    lines.push(
-      `${indent}const ${varName} = ${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx}${nonNullAssert} }) as boolean;`
-    );
+    if (executeConnections.length === 1) {
+      const conn = executeConnections[0];
+      const sourceNode = conn.from.node;
+      const sourcePort = conn.from.port;
+      const sourceIdx = isStartNode(sourceNode) ? "startIdx" : `${toValidIdentifier(sourceNode)}Idx`;
+      const isConstSource = isStartNode(sourceNode) || sourceNode === instanceParent;
+      if (isConstSource) {
+        lines.push(
+          `${indent}const ${varName} = ${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx} }) as boolean;`
+        );
+      } else {
+        lines.push(
+          `${indent}const ${varName} = ${sourceIdx} !== undefined ? ${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx} }) as boolean : false;`
+        );
+      }
+    } else {
+      const parts = executeConnections.map((conn) => {
+        const sourceNode = conn.from.node;
+        const sourcePort = conn.from.port;
+        const sourceIdx = isStartNode(sourceNode) ? "startIdx" : `${toValidIdentifier(sourceNode)}Idx`;
+        const isConstSource = isStartNode(sourceNode) || sourceNode === instanceParent;
+        if (isConstSource) {
+          return `(${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx} }) as boolean)`;
+        }
+        return `(${sourceIdx} !== undefined ? ${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx} }) as boolean : false)`;
+      });
+      lines.push(`${indent}const ${varName} = ${parts.join(" || ")};`);
+    }
     if (emitInputEvents) {
       lines.push(
         `${indent}${setCall}({ id: '${id}', portName: 'execute', executionIndex: ${safeId}Idx, nodeTypeName: '${effectiveNodeTypeName}' }, ${varName});`
@@ -94920,7 +94939,7 @@ var {
 // src/cli/index.ts
 init_logger();
 init_error_utils();
-var version2 = true ? "0.22.5" : "0.0.0-dev";
+var version2 = true ? "0.22.7" : "0.0.0-dev";
 var program2 = new Command();
 program2.name("fw").description("Flow Weaver Annotations - Compile and validate workflow files").option("-v, --version", "Output the current version").option("--no-color", "Disable colors").option("--color", "Force colors").on("option:version", () => {
   logger.banner(version2);

package/dist/generated-version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.22.5";
+export declare const VERSION = "0.22.7";
 //# sourceMappingURL=generated-version.d.ts.map

package/dist/generated-version.js

@@ -1,3 +1,3 @@
 // Auto-generated by scripts/generate-version.ts — do not edit manually
-export const VERSION = '0.22.5';
+export const VERSION = '0.22.7';
 //# sourceMappingURL=generated-version.js.map

package/dist/generator/code-utils.js

@@ -172,16 +172,36 @@ export function buildNodeArgumentsWithContext(opts) {
         args.push(`${safeId}_execute`);
     }
     else if (executeConnections.length > 0) {
-        // Execute port has a connection - use it
-        const conn = executeConnections[0];
-        const sourceNode = conn.from.node;
-        const sourcePort = conn.from.port;
+        // Execute port has connections - use them
         const varName = `${safeId}_execute`;
-        // startIdx is const so no ! needed; parent scope node is also const; other node indices are let so need !
-        const sourceIdx = isStartNode(sourceNode) ? 'startIdx' : `${toValidIdentifier(sourceNode)}Idx`;
-        const isConstSource = isStartNode(sourceNode) || sourceNode === instanceParent;
-        const nonNullAssert = isConstSource ? '' : '!';
-        lines.push(`${indent}const ${varName} = ${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx}${nonNullAssert} }) as boolean;`);
+        if (executeConnections.length === 1) {
+            const conn = executeConnections[0];
+            const sourceNode = conn.from.node;
+            const sourcePort = conn.from.port;
+            const sourceIdx = isStartNode(sourceNode) ? 'startIdx' : `${toValidIdentifier(sourceNode)}Idx`;
+            const isConstSource = isStartNode(sourceNode) || sourceNode === instanceParent;
+            if (isConstSource) {
+                lines.push(`${indent}const ${varName} = ${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx} }) as boolean;`);
+            }
+            else {
+                // Non-const source may be undefined (CANCELLED branch) — guard with false default
+                lines.push(`${indent}const ${varName} = ${sourceIdx} !== undefined ? ${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx} }) as boolean : false;`);
+            }
+        }
+        else {
+            // Multiple execute connections — coalesce with ||, each guarded
+            const parts = executeConnections.map((conn) => {
+                const sourceNode = conn.from.node;
+                const sourcePort = conn.from.port;
+                const sourceIdx = isStartNode(sourceNode) ? 'startIdx' : `${toValidIdentifier(sourceNode)}Idx`;
+                const isConstSource = isStartNode(sourceNode) || sourceNode === instanceParent;
+                if (isConstSource) {
+                    return `(${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx} }) as boolean)`;
+                }
+                return `(${sourceIdx} !== undefined ? ${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx} }) as boolean : false)`;
+            });
+            lines.push(`${indent}const ${varName} = ${parts.join(' || ')};`);
+        }
         // Emit VARIABLE_SET for execute input port
         if (emitInputEvents) {
             lines.push(`${indent}${setCall}({ id: '${id}', portName: 'execute', executionIndex: ${safeId}Idx, nodeTypeName: '${effectiveNodeTypeName}' }, ${varName});`);

package/dist/generator/unified.js

@@ -814,7 +814,9 @@ isAsync = false) {
         if (!instance)
             return;
         const safeId = toValidIdentifier(instanceId);
-        // Add execution index for this skipped node so the event has a valid reference
+        // Use const (block-scoped) intentionally — the outer `let ${safeId}Idx`
+        // stays undefined, which signals to downstream guards that this node was
+        // CANCELLED and its data ports should not be read.
         lines.push(`${indent}const ${safeId}Idx = ${ctxVar}.addExecution('${instanceId}');`);
         // Set STEP port variables so downstream nodes reading onSuccess/onFailure
         // from this cancelled node don't crash with "Variable not found".