@lhi/n8m 0.2.1 → 0.2.2

package/dist/agentic/nodes/qa.js

@@ -2,6 +2,7 @@ import { AIService } from "../../services/ai.service.js";
 import { ConfigManager } from "../../utils/config.js";
 import { N8nClient } from "../../utils/n8nClient.js";
 import { theme } from "../../utils/theme.js";
+import { Spinner } from "../../utils/spinner.js";
 export const qaNode = async (state) => {
     const aiService = AIService.getInstance();
     const workflowJson = state.workflowJson;
@@ -19,6 +20,7 @@ export const qaNode = async (state) => {
     const client = new N8nClient({ apiUrl: n8nUrl, apiKey: n8nKey });
     let createdWorkflowId = null;
     const validationErrors = [];
+    let healedNodes = null; // set when inline fixes mutate deployed nodes
     try {
         // 2. Prepare Workflow Data (Extract from state structure)
         // engineerNode returns { workflows: [ { name, nodes, connections } ] }
@@ -32,11 +34,11 @@ export const qaNode = async (state) => {
         // Drop timezone — sanitizeSettings in N8nClient strips it unconditionally
         const rawSettings = { ...(targetWorkflow.settings || {}) };
         delete rawSettings.timezone;
-        // Strip credentials from all nodes — n8n 2.x refuses to activate ("publish")
-        // a workflow that references credentials that don't exist on the instance.
-        // Structural validation can still run; only live execution of credentialed
-        // nodes will be skipped/fail, which is expected for an ephemeral test.
-        const strippedNodes = targetWorkflow.nodes.map((node) => {
+        // Shim external-network nodes FIRST (credentials present on the original node
+        // are the signal that a node calls an external service), then strip credentials
+        // from whatever remains so n8n doesn't reject the workflow at activation time.
+        const shimmedNodes = N8nClient.shimNetworkNodes(targetWorkflow.nodes.filter((node) => node != null));
+        const strippedNodes = shimmedNodes.map((node) => {
             const { credentials: _creds, ...rest } = node;
             return rest;
         });
@@ -58,7 +60,6 @@ export const qaNode = async (state) => {
             rootPayload.connections = shimmed.connections;
         }
         // 3. Deploy Ephemeral Workflow
-        console.log(theme.agent(`Deploying ephemeral root: ${rootPayload.name}...`));
         const result = await client.createWorkflow(rootPayload.name, rootPayload);
         createdWorkflowId = result.id;
         // 4. Determine Test Scenarios
@@ -73,52 +74,272 @@ export const qaNode = async (state) => {
             const mockPayload = await aiService.generateMockData(context);
             scenarios = [{ name: "Default Test", payload: mockPayload }];
         }
+        // Track whether we mutated the deployed workflow so we can surface the healed JSON
         const webhookNode = rootPayload.nodes.find((n) => n.type === 'n8n-nodes-base.webhook');
         if (webhookNode) {
             const path = webhookNode.parameters?.path;
             if (path) {
-                // Activate for webhook testing
-                await client.activateWorkflow(createdWorkflowId);
+                // Activate for webhook testing — n8n validates the workflow at this point
+                try {
+                    await client.activateWorkflow(createdWorkflowId);
+                }
+                catch (activateErr) {
+                    const raw = activateErr.message || String(activateErr);
+                    // Try to extract a clean message from a JSON error body
+                    let reason = raw;
+                    const jsonMatch = raw.match(/\{.*\}/s);
+                    if (jsonMatch) {
+                        try {
+                            reason = JSON.parse(jsonMatch[0]).message ?? raw;
+                        }
+                        catch { /* keep raw */ }
+                    }
+                    const msg = `Activation rejected by n8n: ${reason}`;
+                    validationErrors.push(msg);
+                    console.log(theme.fail(msg));
+                    return { validationStatus: 'failed', validationErrors };
+                }
                 const baseUrl = new URL(n8nUrl).origin;
                 const webhookUrl = `${baseUrl}/webhook/${path}`;
                 for (const scenario of scenarios) {
-                    console.log(theme.info(`🧪 Running Scenario: ${theme.value(scenario.name)}...`));
-                    const response = await fetch(webhookUrl, {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify(scenario.payload)
-                    });
-                    if (!response.ok) {
-                        validationErrors.push(`Scenario "${scenario.name}" failed to trigger: ${response.status}`);
-                        continue;
-                    }
-                    // 5. Verify Execution for this scenario
-                    const executionStartTime = Date.now();
-                    let executionFound = false;
-                    const maxPoll = 15;
-                    for (let i = 0; i < maxPoll; i++) {
-                        await new Promise(r => setTimeout(r, 2000));
-                        const executions = await client.getWorkflowExecutions(createdWorkflowId);
-                        const recentExec = executions.find((e) => new Date(e.startedAt).getTime() > (executionStartTime - 5000));
-                        if (recentExec) {
-                            executionFound = true;
-                            const fullExec = await client.getExecution(recentExec.id);
-                            if (fullExec.status === 'success') {
-                                console.log(theme.success(`   ✔ Passed`));
+                    let fixAttempted = false;
+                    let binaryShimInjected = false;
+                    let codeNodeFixApplied = false; // tracks whether a code_node_js fix was actually committed
+                    let codeNodeFixAppliedName;
+                    let mockDataShimApplied = false; // tracks whether mock-data shim replaced the Code node
+                    // Up to 5 rounds: initial + fix + mock-shim + downstream + buffer
+                    fixRound: for (let fixRound = 0; fixRound < 5; fixRound++) {
+                        console.log(theme.agent(`Testing: ${scenario.name}${fixRound > 0 ? ` (retry ${fixRound})` : ''}`));
+                        const response = await fetch(webhookUrl, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify(scenario.payload)
+                        });
+                        if (!response.ok) {
+                            validationErrors.push(`Scenario "${scenario.name}" failed to trigger: ${response.status}`);
+                            break fixRound;
+                        }
+                        // 5. Verify Execution for this scenario
+                        const executionStartTime = Date.now();
+                        let executionFound = false;
+                        let scenarioErrorMsg = '';
+                        const maxPoll = 15;
+                        Spinner.start('Waiting for execution result');
+                        for (let i = 0; i < maxPoll; i++) {
+                            await new Promise(r => setTimeout(r, 2000));
+                            const executions = await client.getWorkflowExecutions(createdWorkflowId);
+                            const recentExec = executions.find((e) => new Date(e.startedAt).getTime() > (executionStartTime - 5000));
+                            if (recentExec) {
+                                executionFound = true;
+                                const fullExec = await client.getExecution(recentExec.id);
+                                Spinner.stop();
+                                if (fullExec.status === 'success') {
+                                    console.log(theme.done('Passed'));
+                                    break fixRound; // scenario passed — move to next
+                                }
+                                // Extract error details including failing node name
+                                const execError = fullExec.data?.resultData?.error;
+                                const nodeRef = execError?.node;
+                                const failingNodeName = typeof nodeRef === 'string' ? nodeRef : nodeRef?.name ?? nodeRef?.type;
+                                let rawMsg = execError?.message || '';
+                                const topDesc = execError?.description ?? execError?.cause?.message;
+                                if (rawMsg && topDesc && !rawMsg.includes(topDesc))
+                                    rawMsg = `${rawMsg} — ${topDesc}`;
+                                if (!rawMsg) {
+                                    const runData = fullExec.data?.resultData?.runData;
+                                    if (runData) {
+                                        outer: for (const [nodeName, nodeRuns] of Object.entries(runData)) {
+                                            for (const run of nodeRuns) {
+                                                if (run?.error?.message) {
+                                                    rawMsg = run.error.message;
+                                                    const desc = run.error.description ?? run.error.cause?.message;
+                                                    if (desc && !rawMsg.includes(desc))
+                                                        rawMsg = `${rawMsg} — ${desc}`;
+                                                    if (!failingNodeName)
+                                                        scenarioErrorMsg = `[${nodeName}] ${rawMsg}`;
+                                                    break outer;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                scenarioErrorMsg = scenarioErrorMsg || (failingNodeName ? `[${failingNodeName}] ${rawMsg}` : rawMsg) || 'Unknown flow failure';
+                                console.log(theme.fail(`Failed: ${scenarioErrorMsg}`));
+                                break; // exit poll loop, handle error below
+                            }
+                        }
+                        if (!executionFound) {
+                            Spinner.stop();
+                            validationErrors.push(`Scenario "${scenario.name}": No execution detected after trigger.`);
+                            console.log(theme.warn('No execution detected after trigger.'));
+                            break fixRound;
+                        }
+                        if (!scenarioErrorMsg)
+                            break fixRound; // success path handled above
+                        // ── AI-powered error evaluation & targeted self-healing ───────────────
+                        if (!fixAttempted) {
+                            const nodeNameMatch = scenarioErrorMsg.match(/^\[([^\]]+)\]/);
+                            const failingName = nodeNameMatch?.[1];
+                            const evaluation = await aiService.evaluateTestError(scenarioErrorMsg, rootPayload.nodes, failingName);
+                            fixAttempted = true;
+                            if (evaluation.action === 'structural_pass') {
+                                console.log(theme.warn(`${evaluation.reason}: ${scenarioErrorMsg}`));
+                                console.log(theme.done('Structural validation passed.'));
+                                break fixRound; // pass — don't add to validationErrors
                             }
-                            else {
-                                const errorMsg = fullExec.data?.resultData?.error?.message || "Unknown flow failure";
-                                validationErrors.push(`Scenario "${scenario.name}" Failed: ${errorMsg}`);
-                                console.log(theme.error(`   ✘ Failed: ${errorMsg}`));
+                            if (evaluation.action === 'fix_node') {
+                                const targetName = evaluation.targetNodeName ?? failingName;
+                                if (evaluation.nodeFixType === 'code_node_js') {
+                                    const target = rootPayload.nodes.find((n) => n.type === 'n8n-nodes-base.code' && (!targetName || n.name === targetName)) ?? rootPayload.nodes.find((n) => n.type === 'n8n-nodes-base.code');
+                                    if (target?.parameters?.jsCode) {
+                                        try {
+                                            console.log(theme.agent(`Self-healing Code node "${target.name}"...`));
+                                            target.parameters.jsCode = await aiService.fixCodeNodeJavaScript(target.parameters.jsCode, scenarioErrorMsg);
+                                            await client.updateWorkflow(createdWorkflowId, rootPayload);
+                                            healedNodes = rootPayload.nodes;
+                                            codeNodeFixApplied = true;
+                                            codeNodeFixAppliedName = target.name;
+                                            console.log(theme.muted('Code node fixed. Retesting...'));
+                                            continue fixRound; // retry
+                                        }
+                                        catch { /* fix failed — fall through to escalation */ }
+                                    }
+                                }
+                                else if (evaluation.nodeFixType === 'execute_command') {
+                                    const target = rootPayload.nodes.find((n) => n.type === 'n8n-nodes-base.executeCommand' && (!targetName || n.name === targetName)) ?? rootPayload.nodes.find((n) => n.type === 'n8n-nodes-base.executeCommand');
+                                    if (target?.parameters?.command) {
+                                        try {
+                                            console.log(theme.agent(`Self-healing Execute Command node "${target.name}"...`));
+                                            target.parameters.command = await aiService.fixExecuteCommandScript(target.parameters.command, scenarioErrorMsg);
+                                            await client.updateWorkflow(createdWorkflowId, rootPayload);
+                                            healedNodes = rootPayload.nodes;
+                                            console.log(theme.muted('Execute Command script fixed. Retesting...'));
+                                            continue fixRound; // retry
+                                        }
+                                        catch { /* fix failed — fall through to escalation */ }
+                                    }
+                                }
+                                else if (evaluation.nodeFixType === 'binary_field') {
+                                    const fieldMatch = scenarioErrorMsg.match(/has no binary field ['"]?(\w+)['"]?/i);
+                                    const expectedField = fieldMatch?.[1];
+                                    const failingNode = targetName
+                                        ? rootPayload.nodes.find((n) => n.name === targetName)
+                                        : null;
+                                    // Delegate binary-field tracing to the AI — it traces the full graph
+                                    // (handling passthrough nodes like Merge, Set, IF) to find the actual
+                                    // binary-producing node and the field name it outputs.
+                                    console.log(theme.agent(`Tracing binary data flow to infer correct field name for "${targetName ?? failingName}"...`));
+                                    const correctField = await aiService.inferBinaryFieldNameFromWorkflow(targetName ?? failingName ?? 'unknown', rootPayload.nodes, targetWorkflow.connections || {});
+                                    if (failingNode && expectedField && correctField && correctField !== expectedField) {
+                                        const paramKey = Object.entries(failingNode.parameters || {})
+                                            .find(([, v]) => typeof v === 'string' && v === expectedField)?.[0];
+                                        if (paramKey) {
+                                            try {
+                                                console.log(theme.agent(`Fixing binary field "${failingName}": '${expectedField}' → '${correctField}' (${paramKey})...`));
+                                                failingNode.parameters[paramKey] = correctField;
+                                                await client.updateWorkflow(createdWorkflowId, rootPayload);
+                                                healedNodes = rootPayload.nodes;
+                                                console.log(theme.muted('Binary field name fixed. Retesting...'));
+                                                continue fixRound;
+                                            }
+                                            catch {
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    // Inject a Code node shim that produces synthetic binary data so the
+                                    // downstream node can actually execute instead of structural-passing.
+                                    const shimField = correctField ?? expectedField ?? 'data';
+                                    console.log(theme.agent(`Injecting binary test shim for field "${shimField}" before "${targetName ?? failingName}"...`));
+                                    try {
+                                        const shimCode = aiService.generateBinaryShimCode(shimField);
+                                        const shimName = `[n8m:shim] Binary for ${targetName ?? failingName}`;
+                                        const shimPos = failingNode?.position ?? [500, 300];
+                                        const shimNode = {
+                                            id: `shim-binary-${Date.now()}`,
+                                            name: shimName,
+                                            type: 'n8n-nodes-base.code',
+                                            typeVersion: 2,
+                                            position: [shimPos[0] - 220, shimPos[1]],
+                                            parameters: { mode: 'runOnceForAllItems', jsCode: shimCode },
+                                        };
+                                        // Rewire: redirect connections pointing at the failing node to the shim,
+                                        // then add shim → failing node.
+                                        const failName = targetName ?? failingName ?? '';
+                                        const conns = JSON.parse(JSON.stringify(rootPayload.connections ?? {}));
+                                        for (const targets of Object.values(conns)) {
+                                            for (const segment of (targets?.main ?? [])) {
+                                                if (!Array.isArray(segment))
+                                                    continue;
+                                                for (const conn of segment) {
+                                                    if (conn?.node === failName)
+                                                        conn.node = shimName;
+                                                }
+                                            }
+                                        }
+                                        conns[shimName] = { main: [[{ node: failName, type: 'main', index: 0 }]] };
+                                        rootPayload.nodes = [...rootPayload.nodes, shimNode];
+                                        rootPayload.connections = conns;
+                                        await client.updateWorkflow(createdWorkflowId, rootPayload);
+                                        // Strip shim from healed nodes — it's a test artifact
+                                        healedNodes = rootPayload.nodes.filter((n) => !n.name?.startsWith('[n8m:shim]'));
+                                        binaryShimInjected = true;
+                                        console.log(theme.muted('Binary shim injected. Retesting...'));
+                                        continue fixRound;
+                                    }
+                                    catch {
+                                        // Shim generation/injection failed — fall through to structural pass
+                                    }
+                                    console.log(theme.warn(`Binary data not available in test environment (upstream pipeline required): ${scenarioErrorMsg}`));
+                                    console.log(theme.done('Structural validation passed.'));
+                                    break fixRound;
+                                }
                             }
-                            break;
+                            // evaluation.action === 'escalate' or fix attempt failed — fall through
                         }
-                    }
-                    if (!executionFound) {
-                        validationErrors.push(`Scenario "${scenario.name}": No execution detected after trigger.`);
-                        console.log(theme.warn(`   ⚠ No execution detected.`));
-                    }
-                }
+                        // A Code node still fails after its JS was patched.
+                        // Try replacing it with hardcoded mock data so downstream nodes
+                        // (e.g. Slack at the end of the flow) can still be exercised.
+                        if (codeNodeFixApplied && !mockDataShimApplied) {
+                            const shimTarget = rootPayload.nodes.find((n) => n.type === 'n8n-nodes-base.code' && n.name === codeNodeFixAppliedName);
+                            if (shimTarget?.parameters?.jsCode) {
+                                console.log(theme.agent(`"${codeNodeFixAppliedName}" still fails — replacing with mock data to continue test...`));
+                                try {
+                                    shimTarget.parameters.jsCode = await aiService.shimCodeNodeWithMockData(shimTarget.parameters.jsCode);
+                                    await client.updateWorkflow(createdWorkflowId, rootPayload);
+                                    healedNodes = rootPayload.nodes;
+                                    mockDataShimApplied = true;
+                                    console.log(theme.muted(`"${codeNodeFixAppliedName}" replaced with mock data. Retesting...`));
+                                    continue fixRound;
+                                }
+                                catch { /* fall through to structural pass */ }
+                            }
+                        }
+                        if (codeNodeFixApplied || mockDataShimApplied) {
+                            console.log(theme.warn(`Code node "${codeNodeFixAppliedName ?? 'unknown'}" relies on external APIs unavailable in test environment: ${scenarioErrorMsg}`));
+                            console.log(theme.done('Structural validation passed.'));
+                            break fixRound;
+                        }
+                        // Binary-field errors that survive fixAttempted (e.g. second round after a
+                        // successful fix) indicate a test-environment limitation, not a workflow bug.
+                        if (scenarioErrorMsg.match(/has no binary field/i)) {
+                            console.log(theme.warn(`Binary data not available in test environment (upstream pipeline required): ${scenarioErrorMsg}`));
+                            console.log(theme.done('Structural validation passed.'));
+                            break fixRound;
+                        }
+                        // If a binary shim was injected and the downstream node still fails
+                        // (e.g. invalid URL, credential errors from external APIs like Slack),
+                        // that's a test-environment limitation, not a workflow bug.
+                        if (binaryShimInjected) {
+                            console.log(theme.warn(`External service error after binary shim (credentials/API required): ${scenarioErrorMsg}`));
+                            console.log(theme.done('Structural validation passed.'));
+                            break fixRound;
+                        }
+                        // Unfixable — escalate to engineer
+                        validationErrors.push(`Scenario "${scenario.name}" Failed: ${scenarioErrorMsg}`);
+                        break fixRound;
+                    } // end fixRound
+                } // end scenarios
             }
         }
         else {
@@ -142,21 +363,35 @@ export const qaNode = async (state) => {
     }
     catch (error) {
         const errorMsg = error.message;
-        console.error(theme.error(`QA Node Error: ${errorMsg}`));
+        // Connectivity errors can't be fixed by modifying the workflow — rethrow so
+        // the graph surfaces a clear failure instead of looping through the engineer.
+        const isConnectivityError = errorMsg.includes('Cannot connect to n8n') ||
+            errorMsg.includes('fetch failed') ||
+            errorMsg.includes('ECONNREFUSED') ||
+            errorMsg.includes('ENOTFOUND');
+        if (isConnectivityError)
+            throw error;
         validationErrors.push(errorMsg);
     }
     finally {
-        // Cleanup
         if (createdWorkflowId) {
             try {
                 await client.deleteWorkflow(createdWorkflowId);
-                console.log(theme.info(`Purged temporary workflow ${createdWorkflowId}`));
             }
             catch { /* intentionally empty */ }
         }
     }
+    // If we patched nodes inline (Code / Execute Command fixes), propagate the
+    // healed workflow back into state so the final saved workflow reflects the fix.
+    const healedWorkflow = healedNodes ? (() => {
+        const clone = JSON.parse(JSON.stringify(workflowJson));
+        const target = clone.workflows?.[0] ?? clone;
+        target.nodes = healedNodes;
+        return clone;
+    })() : undefined;
     return {
         validationStatus: validationErrors.length === 0 ? 'passed' : 'failed',
         validationErrors,
+        ...(healedWorkflow ? { workflowJson: healedWorkflow } : {}),
     };
 };

package/dist/agentic/nodes/reviewer.d.ts

@@ -2,4 +2,8 @@ import { TeamState } from "../state.js";
 export declare const reviewerNode: (state: typeof TeamState.State) => Promise<{
     validationStatus: string;
     validationErrors: string[];
+} | {
+    workflowJson?: any;
+    validationStatus: string;
+    validationErrors: never[];
 }>;

package/dist/agentic/nodes/reviewer.js

@@ -24,9 +24,12 @@ export const reviewerNode = async (state) => {
         "n8n-nodes-base.gemini",
         "cheerioHtml", "n8n-nodes-base.cheerioHtml"
     ];
-    nodes.forEach(node => {
+    nodes.filter(Boolean).forEach(node => {
+        if (!node.type) {
+            validationErrors.push(`A node is missing a "type" property — AI may have generated an incomplete node.`);
+            return;
+        }
         if (knownHallucinations.includes(node.type)) {
-            console.log(theme.warn(`[Reviewer] Detected hallucinated node type: ${node.type}`));
             validationErrors.push(`Hallucinated node type detected: "${node.type}". Use standard n8n-nodes-base types.`);
         }
         // Check for empty names
@@ -38,7 +41,6 @@ export const reviewerNode = async (state) => {
             if (!state.availableNodeTypes.includes(node.type)) {
                 // Double check it's not a known exception or recent core node
                 if (!node.type.startsWith('n8n-nodes-base.stick')) { // generic bypass for sticky notes etc if needed
-                    console.log(theme.warn(`[Reviewer] Node type not found in instance: ${node.type}`));
                     validationErrors.push(`Node type "${node.type}" is not available on your n8n instance.`);
                 }
             }
@@ -48,6 +50,10 @@ export const reviewerNode = async (state) => {
     // Build adjacency list (which nodes are destinations?)
     const destinations = new Set();
     const connections = targetWorkflow.connections || {};
+    // Nodes that appear as keys in connections have at least one outgoing connection.
+    // Sub-nodes (AI models, tools, etc.) connect TO their parent this way — they should
+    // never be treated as orphans even though nothing connects back to them.
+    const sources = new Set(Object.keys(connections));
     for (const sourceNode in connections) {
         const outputConfig = connections[sourceNode];
         // iterate over outputs (main, ai_tool, etc)
@@ -74,16 +80,13 @@ export const reviewerNode = async (state) => {
             lower.includes('n8n-nodes-base.start') ||
             lower.includes('n8n-nodes-base.poll');
     };
+    const orphanedNodes = [];
     nodes.forEach(node => {
         // 2.1 Orphan Check
-        if (!destinations.has(node.name) && !isTrigger(node.type)) {
-            // It's an orphan unless it's a known trigger-like node
-            // Sticky notes and Merge nodes can be tricky, but generally Merge needs input.
-            if (!node.type.includes('StickyNote')) {
-                // Double check for "On Execution" (custom trigger name sometimes used)
+        if (!destinations.has(node.name) && !sources.has(node.name) && !isTrigger(node.type)) {
+            if (!node.type?.includes('StickyNote')) {
                 if (!node.name || (!node.name.toLowerCase().includes('trigger') && !node.name.toLowerCase().includes('webhook'))) {
-                    console.log(theme.warn(`[Reviewer] Validated disconnection: Node "${node.name || 'Unnamed'}" has no incoming connections.`));
-                    validationErrors.push(`Node "${node.name || 'Unnamed'}" (${node.type || 'unknown type'}) is disconnected (orphaned). Connect it or remove it.`);
+                    orphanedNodes.push(node);
                 }
             }
         }
@@ -96,6 +99,61 @@ export const reviewerNode = async (state) => {
             }
         }
     });
+    // 2.3 Auto-Shim: Attempt to chain orphaned nodes rather than failing
+    let shimmedWorkflow = null;
+    if (orphanedNodes.length > 0) {
+        const triggerNodes = nodes.filter(n => isTrigger(n.type));
+        const actionableOrphans = orphanedNodes.filter(n => !n.type?.includes('StickyNote'));
+        // Sort orphans by x position (left-to-right layout order)
+        const sorted = [...actionableOrphans].sort((a, b) => (a.position?.[0] ?? 0) - (b.position?.[0] ?? 0));
+        // Build a patched connections object
+        const patchedConnections = { ...(targetWorkflow.connections || {}) };
+        // Find the last node in the existing chain (a source node whose targets don't include any orphan)
+        // Simplification: if there's a trigger with no outgoing connections, attach the first orphan to it
+        let attachToName = null;
+        if (triggerNodes.length > 0) {
+            const trigger = triggerNodes[0];
+            if (!patchedConnections[trigger.name]) {
+                attachToName = trigger.name;
+            }
+            else {
+                // Trigger already connects to something — find the tail of its chain
+                // Walk the chain and stop at the first node with no outgoing connection
+                let current = trigger.name;
+                for (let depth = 0; depth < 20; depth++) {
+                    const outgoing = patchedConnections[current];
+                    if (!outgoing?.main?.[0]?.[0]?.node)
+                        break;
+                    const next = outgoing.main[0][0].node;
+                    if (orphanedNodes.some(o => o.name === next))
+                        break; // avoid infinite loop into orphans
+                    current = next;
+                }
+                attachToName = current;
+            }
+        }
+        if (attachToName && sorted.length > 0) {
+            // Attach first orphan to the chain tail
+            patchedConnections[attachToName] = {
+                main: [[{ node: sorted[0].name, type: 'main', index: 0 }]]
+            };
+            // Chain remaining orphans linearly
+            for (let i = 0; i < sorted.length - 1; i++) {
+                patchedConnections[sorted[i].name] = {
+                    main: [[{ node: sorted[i + 1].name, type: 'main', index: 0 }]]
+                };
+            }
+            console.log(theme.done(`Auto-connected ${sorted.length} orphaned node(s).`));
+            shimmedWorkflow = { ...targetWorkflow, connections: patchedConnections };
+            // Don't push these to validationErrors — we fixed them
+        }
+        else {
+            // Can't determine where to attach — escalate to engineer
+            for (const node of actionableOrphans) {
+                validationErrors.push(`Node "${node.name || 'Unnamed'}" (${node.type || 'unknown type'}) is disconnected (orphaned). Connect it or remove it.`);
+            }
+        }
+    }
     // 3. Credentials Check
     // If we see an OpenAI node, warn if no credential ID is placeholder? (Skip for now)
     if (validationErrors.length > 0) {
@@ -104,10 +162,10 @@ export const reviewerNode = async (state) => {
             validationErrors: validationErrors,
         };
     }
-    // console.log(theme.success("Reviewer passed the blueprint."));
+    // Return the shimmed workflow if we auto-fixed orphaned nodes
     return {
         validationStatus: 'passed',
-        // Clear errors from previous runs
-        validationErrors: []
+        validationErrors: [],
+        ...(shimmedWorkflow ? { workflowJson: shimmedWorkflow } : {}),
     };
 };

package/dist/agentic/nodes/supervisor.js

@@ -6,13 +6,12 @@ export const supervisorNode = async (state) => {
         // Fallback: use existing workflowJson if available
         return {};
     }
-    console.log(theme.agent(`Supervisor evaluating ${candidates.length} candidate(s)...`));
     const aiService = AIService.getInstance();
     const evaluation = await aiService.evaluateCandidates(state.userGoal, candidates);
     const bestCandidate = candidates[evaluation.selectedIndex] ?? candidates[0];
     const logEntry = `Supervisor: Selected candidate ${evaluation.selectedIndex + 1}/${candidates.length} ("${bestCandidate.name || 'Unnamed'}"). Reason: ${evaluation.reason}`;
-    console.log(theme.success(`Supervisor selected: ${bestCandidate.name || "Unnamed Workflow"} (candidate ${evaluation.selectedIndex + 1})`));
-    console.log(theme.agent(`  → ${evaluation.reason}`));
+    const displayName = bestCandidate.name || bestCandidate.workflows?.[0]?.name || 'Unnamed Workflow';
+    console.log(theme.agent(`Selected: ${displayName}`));
     return {
         workflowJson: bestCandidate,
         collaborationLog: [logEntry],

package/dist/agentic/state.d.ts

@@ -59,4 +59,5 @@ export declare const TeamState: import("@langchain/langgraph").AnnotationRoot<{
         (annotation: import("@langchain/langgraph").SingleReducer<any[], any[]>): import("@langchain/langgraph").BinaryOperatorAggregate<any[], any[]>;
         Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
     };
+    maxRevisions: import("@langchain/langgraph").BinaryOperatorAggregate<number, number>;
 }>;

package/dist/agentic/state.js

@@ -30,4 +30,8 @@ export const TeamState = Annotation.Root({
     }),
     userFeedback: (Annotation),
     testScenarios: (Annotation),
+    maxRevisions: Annotation({
+        value: (_x, y) => y ?? 3,
+        default: () => 3,
+    }),
 });

package/dist/commands/create.js

@@ -8,6 +8,8 @@ import { randomUUID } from 'node:crypto';
 import { graph, resumeAgenticWorkflow } from '../agentic/graph.js';
 import { promptMultiline } from '../utils/multilinePrompt.js';
 import { DocService } from '../services/doc.service.js';
+import { ConfigManager } from '../utils/config.js';
+import { N8nClient } from '../utils/n8nClient.js';
 export default class Create extends Command {
     static args = {
         description: Args.string({
@@ -76,7 +78,6 @@ export default class Create extends Command {
         const threadId = randomUUID();
         this.log(theme.info(`\nInitializing Agentic Workflow for: "${description}" (Session: ${threadId})`));
         let lastWorkflowJson = null;
-        let lastSpec = null;
         try {
             const stream = await runAgenticWorkflowStream(description, threadId);
             for await (const event of stream) {
@@ -86,7 +87,6 @@ export default class Create extends Command {
                 if (nodeName === 'architect') {
                     this.log(theme.agent(`🏗️  Architect: Blueprint designed.`));
                     if (stateUpdate.strategies && stateUpdate.strategies.length > 0) {
-                        lastSpec = stateUpdate.strategies[0]; // Default to primary
                         this.log(theme.header('\nPROPOSED STRATEGIES:'));
                         stateUpdate.strategies.forEach((s, i) => {
                             this.log(`${i === 0 ? theme.success('  [Primary]') : theme.info('  [Alternative]')} ${theme.value(s.suggestedName)}`);
@@ -225,7 +225,6 @@ export default class Create extends Command {
         const savedResources = [];
         const docService = DocService.getInstance();
         for (const workflow of workflows) {
-            const workflowName = workflow.name || (lastSpec && lastSpec.suggestedName) || 'generated-workflow';
             const projectTitle = await docService.generateProjectTitle(workflow);
             workflow.name = projectTitle; // Standardize name
             const slug = docService.generateSlug(projectTitle);
@@ -243,6 +242,41 @@ export default class Create extends Command {
             await fs.writeFile(path.join(targetDir, 'README.md'), fullDoc);
             savedResources.push({ path: targetFile, name: projectTitle, original: workflow });
         }
+        // 4. DEPLOY PROMPT
+        const deployConfig = await ConfigManager.load();
+        const n8nUrl = process.env.N8N_API_URL || deployConfig.n8nUrl;
+        const n8nKey = process.env.N8N_API_KEY || deployConfig.n8nKey;
+        if (n8nUrl && n8nKey) {
+            const { shouldDeploy } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'shouldDeploy',
+                    message: 'Deploy validated workflow to n8n?',
+                    default: true,
+                }]);
+            if (shouldDeploy) {
+                const { activate } = await inquirer.prompt([{
+                        type: 'confirm',
+                        name: 'activate',
+                        message: 'Activate workflow after deployment?',
+                        default: false,
+                    }]);
+                const client = new N8nClient({ apiUrl: n8nUrl, apiKey: n8nKey });
+                for (const { name, original } of savedResources) {
+                    try {
+                        const result = await client.createWorkflow(name, original);
+                        this.log(theme.done(`Deployed: ${name} [ID: ${result.id}]`));
+                        this.log(`${theme.label('Link')} ${theme.secondary(client.getWorkflowLink(result.id))}`);
+                        if (activate) {
+                            await client.activateWorkflow(result.id);
+                            this.log(theme.info('Workflow activated.'));
+                        }
+                    }
+                    catch (err) {
+                        this.log(theme.error(`Deploy failed for "${name}": ${err.message}`));
+                    }
+                }
+            }
+        }
         this.log(theme.done('Agentic Workflow Complete.'));
         process.exit(0);
     }