@lhi/n8m 0.2.4 → 0.3.1

package/dist/commands/modify.js

@@ -72,20 +72,37 @@ export default class Modify extends Command {
             this.log(theme.info('Searching for local and remote workflows...'));
             const localChoices = [];
             const workflowsDir = path.join(process.cwd(), 'workflows');
-            const searchDirs = [workflowsDir, process.cwd()];
-            for (const dir of searchDirs) {
-                if (existsSync(dir)) {
-                    const files = await fs.readdir(dir);
-                    for (const file of files) {
-                        if (file.endsWith('.json')) {
-                            localChoices.push({
-                                name: `${theme.value('[LOCAL]')} ${file}`,
-                                value: { type: 'local', path: path.join(dir, file) }
-                            });
+            const scanDir = async (dir, rootDir) => {
+                let entries;
+                try {
+                    entries = await fs.readdir(dir, { withFileTypes: true });
+                }
+                catch {
+                    return;
+                }
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        await scanDir(fullPath, rootDir);
+                    }
+                    else if (entry.name.endsWith('.json')) {
+                        let label = path.relative(rootDir, fullPath);
+                        try {
+                            const raw = await fs.readFile(fullPath, 'utf-8');
+                            const parsed = JSON.parse(raw);
+                            if (parsed.name)
+                                label = `${parsed.name}  (${label})`;
                         }
+                        catch { /* use path as label */ }
+                        localChoices.push({
+                            name: `${theme.value('[LOCAL]')} ${label}`,
+                            value: { type: 'local', path: fullPath }
+                        });
                     }
                 }
-            }
+            };
+            if (existsSync(workflowsDir))
+                await scanDir(workflowsDir, workflowsDir);
             const remoteWorkflows = await client.getWorkflows();
             const remoteChoices = remoteWorkflows
                 .map(w => ({
@@ -119,17 +136,8 @@ export default class Modify extends Command {
         }
         // 3. Get Instruction
         let instruction = args.instruction;
-        if (!instruction && flags.multiline) {
-            const response = await inquirer.prompt([{
-                    type: 'editor',
-                    name: 'instruction',
-                    message: 'Describe the modifications you want to apply (opens editor):',
-                    validate: (d) => d.trim().length > 0
-                }]);
-            instruction = response.instruction;
-        }
         if (!instruction) {
-            instruction = await promptMultiline('Describe the modifications you want to apply:');
+            instruction = await promptMultiline('Describe the modifications you want to apply (use ``` for multiline): ');
         }
         if (!instruction) {
             this.error('Modification instructions are required.');
@@ -157,51 +165,130 @@ export default class Modify extends Command {
                 const nodeName = Object.keys(event)[0];
                 const stateUpdate = event[nodeName];
                 if (nodeName === 'architect') {
-                    this.log(theme.agent(`🏗️  Architect: Analysis complete.`));
-                    if (stateUpdate.spec) {
-                        this.log(`   Plan: ${theme.value(stateUpdate.spec.suggestedName || 'Modifying structure')}`);
-                    }
+                    this.log(theme.agent(`🏗️  Architect: Modification plan ready.`));
                 }
                 else if (nodeName === 'engineer') {
                     this.log(theme.agent(`⚙️  Engineer: Applying changes to workflow...`));
-                    if (stateUpdate.workflowJson) {
+                    if (stateUpdate.workflowJson)
                         lastWorkflowJson = stateUpdate.workflowJson;
-                    }
                 }
                 else if (nodeName === 'qa') {
-                    const status = stateUpdate.validationStatus;
-                    if (status === 'passed') {
+                    if (stateUpdate.validationStatus === 'passed') {
                         this.log(theme.success(`🧪 QA: Modification Validated.`));
                     }
                     else {
                         this.log(theme.fail(`🧪 QA: Validation Issues Found.`));
-                        if (stateUpdate.validationErrors && stateUpdate.validationErrors.length > 0) {
+                        if (stateUpdate.validationErrors?.length) {
                             stateUpdate.validationErrors.forEach((e) => this.log(theme.error(`   - ${e}`)));
                         }
                         this.log(theme.warn(`   Looping back for refinements...`));
                     }
                 }
             }
-            // HITL Pause
-            const snapshot = await graph.getState({ configurable: { thread_id: threadId } });
-            if (snapshot.next.length > 0) {
-                this.log(theme.warn(`\n⏸️  Modification Paused at step: ${snapshot.next.join(', ')}`));
-                const { resume } = await inquirer.prompt([{
-                        type: 'confirm',
-                        name: 'resume',
-                        message: 'Review pending changes. Proceed with finalization?',
-                        default: true
-                    }]);
-                if (resume) {
-                    this.log(theme.agent("Finalizing..."));
-                    const result = await resumeAgenticWorkflow(threadId);
-                    if (result.workflowJson)
-                        lastWorkflowJson = result.workflowJson;
+            // HITL loop — same pattern as create.ts
+            let snapshot = await graph.getState({ configurable: { thread_id: threadId } });
+            while (snapshot.next.length > 0) {
+                const nextNode = snapshot.next[0];
+                if (nextNode === 'engineer') {
+                    const isRepair = (snapshot.values.validationErrors || []).length > 0;
+                    if (isRepair) {
+                        // Repair iteration — auto-continue
+                        const repairStream = await graph.stream(null, { configurable: { thread_id: threadId } });
+                        for await (const event of repairStream) {
+                            const n = Object.keys(event)[0];
+                            const u = event[n];
+                            if (n === 'engineer' && u.workflowJson)
+                                lastWorkflowJson = u.workflowJson;
+                        }
+                    }
+                    else {
+                        // Show modification plan and give options
+                        const plan = snapshot.values.spec;
+                        if (plan) {
+                            this.log(theme.header('\nMODIFICATION PLAN:'));
+                            this.log(`  ${theme.value(plan.description || '')}`);
+                            if (plan.proposedChanges?.length) {
+                                this.log(theme.info('\nProposed Changes:'));
+                                plan.proposedChanges.forEach(c => this.log(`  ${theme.muted('•')} ${c}`));
+                            }
+                            if (plan.affectedNodes?.length) {
+                                this.log(`\n${theme.label('Affected Nodes')} ${plan.affectedNodes.join(', ')}`);
+                            }
+                            this.log('');
+                        }
+                        const choices = [
+                            { name: 'Proceed with this plan', value: { type: 'proceed' } },
+                            { name: 'Add feedback before modifying', value: { type: 'feedback' } },
+                            new inquirer.Separator(),
+                            { name: 'Exit (discard)', value: { type: 'exit' } },
+                        ];
+                        const { choice } = await inquirer.prompt([{
+                                type: 'list',
+                                name: 'choice',
+                                message: 'Blueprint ready. How would you like to proceed?',
+                                choices,
+                            }]);
+                        if (choice.type === 'exit') {
+                            this.log(theme.info(`\nSession saved. Resume later with: n8m resume ${threadId}`));
+                            return;
+                        }
+                        let stateUpdate = {};
+                        if (choice.type === 'feedback') {
+                            const { feedback } = await inquirer.prompt([{
+                                    type: 'input',
+                                    name: 'feedback',
+                                    message: 'Describe your refinements:',
+                                }]);
+                            stateUpdate = { userFeedback: feedback };
+                            this.log(theme.agent(`Feedback noted. Applying modifications with your refinements...`));
+                        }
+                        else {
+                            this.log(theme.agent(`⚙️  Engineer: Applying modifications...`));
+                        }
+                        if (Object.keys(stateUpdate).length > 0) {
+                            await graph.updateState({ configurable: { thread_id: threadId } }, stateUpdate);
+                        }
+                        const engineerStream = await graph.stream(null, { configurable: { thread_id: threadId } });
+                        for await (const event of engineerStream) {
+                            const n = Object.keys(event)[0];
+                            const u = event[n];
+                            if (n === 'engineer' && u.workflowJson)
+                                lastWorkflowJson = u.workflowJson;
+                            else if (n === 'reviewer' && u.validationStatus === 'failed') {
+                                this.log(theme.warn(`   Reviewer flagged issues — Engineer will revise...`));
+                            }
+                        }
+                    }
+                }
+                else if (nextNode === 'qa') {
+                    this.log(theme.agent(`⚙️  Running QA validation...`));
+                    const qaStream = await graph.stream(null, { configurable: { thread_id: threadId } });
+                    for await (const event of qaStream) {
+                        const n = Object.keys(event)[0];
+                        const u = event[n];
+                        if (n === 'qa') {
+                            if (u.validationStatus === 'passed') {
+                                this.log(theme.success(`🧪 QA: Validation Passed.`));
+                                if (u.workflowJson)
+                                    lastWorkflowJson = u.workflowJson;
+                            }
+                            else {
+                                this.log(theme.fail(`🧪 QA: Validation Failed.`));
+                                if (u.validationErrors?.length) {
+                                    u.validationErrors.forEach(e => this.log(theme.error(`   - ${e}`)));
+                                }
+                                this.log(theme.warn(`   Looping back to Engineer for repairs...`));
+                            }
+                        }
+                    }
                 }
                 else {
-                    this.log(theme.info(`Session persisted. Thread: ${threadId}`));
-                    return;
+                    // Unknown interrupt — auto-resume
+                    const result = await resumeAgenticWorkflow(threadId, null);
+                    if (result.workflowJson)
+                        lastWorkflowJson = result.workflowJson;
                 }
+                snapshot = await graph.getState({ configurable: { thread_id: threadId } });
             }
         }
         catch (error) {
@@ -222,44 +309,98 @@ export default class Modify extends Command {
         if (!modifiedWorkflow.name.toLowerCase().includes('modified')) {
             // maybe add a suffix? Or just keep it. 
         }
+        // Find an existing local file matching by workflow ID or name
+        const findExistingLocalPath = async () => {
+            const workflowsDir = path.join(process.cwd(), 'workflows');
+            const searchId = modifiedWorkflow.id || workflowData.id;
+            const searchName = modifiedWorkflow.name || workflowName;
+            const search = async (dir) => {
+                let entries;
+                try {
+                    entries = await fs.readdir(dir, { withFileTypes: true });
+                }
+                catch {
+                    return undefined;
+                }
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        const found = await search(fullPath);
+                        if (found)
+                            return found;
+                    }
+                    else if (entry.name.endsWith('.json')) {
+                        try {
+                            const parsed = JSON.parse(await fs.readFile(fullPath, 'utf-8'));
+                            if ((searchId && parsed.id === searchId) || parsed.name === searchName)
+                                return fullPath;
+                        }
+                        catch { /* skip */ }
+                    }
+                }
+            };
+            return search(workflowsDir);
+        };
+        const saveLocally = async (promptPath = true) => {
+            const existingPath = originalPath || await findExistingLocalPath();
+            const defaultPath = flags.output || existingPath || path.join(process.cwd(), 'workflows', `${workflowName}.json`);
+            let targetPath = defaultPath;
+            if (promptPath && !existingPath) {
+                const { p } = await inquirer.prompt([{
+                        type: 'input',
+                        name: 'p',
+                        message: 'Save modified workflow to:',
+                        default: defaultPath
+                    }]);
+                targetPath = p;
+            }
+            await fs.mkdir(path.dirname(targetPath), { recursive: true });
+            await fs.writeFile(targetPath, JSON.stringify(modifiedWorkflow, null, 2));
+            this.log(theme.success(`✔ Saved to ${targetPath}`));
+        };
         const { action } = await inquirer.prompt([{
                 type: 'select',
                 name: 'action',
                 message: 'Modification complete. What would you like to do?',
                 choices: [
-                    { name: 'Save locally', value: 'save' },
-                    { name: 'Deploy to n8n instance', value: 'deploy' },
+                    { name: 'Deploy to n8n instance (also saves locally)', value: 'deploy' },
+                    { name: 'Save locally only', value: 'save' },
                     { name: 'Run ephemeral test (n8m test)', value: 'test' },
                     { name: 'Discard changes', value: 'discard' }
                 ]
             }]);
         if (action === 'save') {
-            const defaultPath = flags.output || originalPath || path.join(process.cwd(), 'workflows', `${workflowName}-modified.json`);
-            const { targetPath } = await inquirer.prompt([{
-                    type: 'input',
-                    name: 'targetPath',
-                    message: 'Save modified workflow to:',
-                    default: defaultPath
-                }]);
-            await fs.mkdir(path.dirname(targetPath), { recursive: true });
-            await fs.writeFile(targetPath, JSON.stringify(modifiedWorkflow, null, 2));
-            this.log(theme.success(`✔ Saved to ${targetPath}`));
+            await saveLocally();
         }
         else if (action === 'deploy') {
-            if (remoteId) {
-                this.log(theme.info(`Updating remote workflow ${remoteId}...`));
-                await client.updateWorkflow(remoteId, modifiedWorkflow);
-                this.log(theme.success(`✔ Remote workflow updated.`));
+            const targetId = remoteId || modifiedWorkflow.id;
+            if (targetId) {
+                let existsRemotely = false;
+                try {
+                    await client.getWorkflow(targetId);
+                    existsRemotely = true;
+                }
+                catch { /* not found */ }
+                if (existsRemotely) {
+                    this.log(theme.info(`Updating remote workflow ${targetId}...`));
+                    await client.updateWorkflow(targetId, modifiedWorkflow);
+                    this.log(theme.success(`✔ Remote workflow updated.`));
+                    this.log(`${theme.label('Link')} ${theme.secondary(client.getWorkflowLink(targetId))}`);
+                }
+                else {
+                    const result = await client.createWorkflow(modifiedWorkflow.name, modifiedWorkflow);
+                    modifiedWorkflow.id = result.id;
+                    this.log(theme.success(`✔ Created workflow [ID: ${result.id}]`));
+                    this.log(`${theme.label('Link')} ${theme.secondary(client.getWorkflowLink(result.id))}`);
+                }
             }
             else {
-                this.log(theme.info(`Creating new workflow on instance...`));
-                const payload = { ...modifiedWorkflow };
-                // Remove ID to ensure a fresh creation
-                delete payload.id;
-                const result = await client.createWorkflow(payload.name, payload);
+                const result = await client.createWorkflow(modifiedWorkflow.name, modifiedWorkflow);
+                modifiedWorkflow.id = result.id;
                 this.log(theme.success(`✔ Created workflow [ID: ${result.id}]`));
                 this.log(`${theme.label('Link')} ${theme.secondary(client.getWorkflowLink(result.id))}`);
             }
+            await saveLocally(false);
         }
         else if (action === 'test') {
             // Automatically run the test command
@@ -272,5 +413,6 @@ export default class Modify extends Command {
             await this.config.runCommand('test', [tempPath]);
         }
         this.log(theme.done('Modification Process Complete.'));
+        process.exit(0);
     }
 }

package/dist/commands/test.d.ts

@@ -81,6 +81,10 @@ export default class Test extends Command {
      */
     private sanitizeMockPayload;
     private deployWorkflows;
+    /** Run all fixture files in a directory as a suite. */
+    private runFixtureSuite;
+    /** Run an in-memory list of fixtures as a suite and print a summary. */
+    private runFixtureSuiteFromList;
     private offerSaveFixture;
     private testWithFixture;
     private findPredecessorNode;

package/dist/commands/test.js

@@ -372,30 +372,47 @@ export default class Test extends Command {
                 let directResult;
                 const fixtureFlagPath = flags['fixture'];
                 if (fixtureFlagPath) {
-                    // --fixture flag: load from explicit path, run offline immediately (no prompt)
-                    const fixture = fixtureManager.loadFromPath(fixtureFlagPath);
-                    if (!fixture) {
-                        this.log(theme.fail(`Could not load fixture from: ${fixtureFlagPath}`));
-                        return;
+                    // --fixture flag: directory = run all as suite; file = single fixture
+                    const { statSync } = await import('fs');
+                    let isDir = false;
+                    try {
+                        isDir = statSync(fixtureFlagPath).isDirectory();
+                    }
+                    catch { /* not found */ }
+                    if (isDir) {
+                        directResult = await this.runFixtureSuite(fixtureFlagPath, fixtureManager, workflowName, aiService);
+                    }
+                    else {
+                        const fixture = fixtureManager.loadFromPath(fixtureFlagPath);
+                        if (!fixture) {
+                            this.log(theme.fail(`Could not load fixture from: ${fixtureFlagPath}`));
+                            return;
+                        }
+                        directResult = await this.testWithFixture(fixture, workflowName, aiService);
                     }
-                    directResult = await this.testWithFixture(fixture, workflowName, aiService);
                 }
                 else {
                     const capturedDate = fixtureManager.getCapturedDate(rootRealTargetId);
                     if (capturedDate && !validateOnly) {
+                        const allFixtures = fixtureManager.loadAll(rootRealTargetId);
                         const dateStr = capturedDate.toLocaleString('en-US', {
                             year: 'numeric', month: 'short', day: 'numeric',
                             hour: '2-digit', minute: '2-digit',
                         });
+                        const caseLabel = allFixtures.length === 1 ? '1 fixture' : `${allFixtures.length} fixture cases`;
                         const { useFixture } = await inquirer.prompt([{
                                 type: 'confirm',
                                 name: 'useFixture',
-                                message: `Fixture found from ${dateStr}. Run offline?`,
+                                message: `${caseLabel} found from ${dateStr}. Run offline?`,
                                 default: true,
                             }]);
                         if (useFixture) {
-                            const fixture = fixtureManager.load(rootRealTargetId);
-                            directResult = await this.testWithFixture(fixture, workflowName, aiService);
+                            if (allFixtures.length === 1) {
+                                directResult = await this.testWithFixture(allFixtures[0], workflowName, aiService);
+                            }
+                            else {
+                                directResult = await this.runFixtureSuiteFromList(allFixtures, workflowName, aiService);
+                            }
                         }
                         else {
                             directResult = await this.testRemoteWorkflowDirectly(rootRealTargetId, workflowData, workflowName, client, aiService, n8nUrl, testScenarios);
@@ -406,8 +423,13 @@ export default class Test extends Command {
                     }
                     else if (capturedDate && validateOnly) {
                         // validate-only + fixture: use fixture silently (no prompt)
-                        const fixture = fixtureManager.load(rootRealTargetId);
-                        directResult = await this.testWithFixture(fixture, workflowName, aiService);
+                        const allFixtures = fixtureManager.loadAll(rootRealTargetId);
+                        if (allFixtures.length === 1) {
+                            directResult = await this.testWithFixture(allFixtures[0], workflowName, aiService);
+                        }
+                        else {
+                            directResult = await this.runFixtureSuiteFromList(allFixtures, workflowName, aiService);
+                        }
                     }
                     else {
                         directResult = await this.testRemoteWorkflowDirectly(rootRealTargetId, workflowData, workflowName, client, aiService, n8nUrl, testScenarios);
@@ -590,7 +612,7 @@ export default class Test extends Command {
         }
         return { ...workflowData, nodes, connections };
     }
-    async saveWorkflows(deployedDefinitions, _originalPath) {
+    async saveWorkflows(deployedDefinitions, originalPath) {
         if (deployedDefinitions.size === 0)
             return;
         const { save } = await inquirer.prompt([{
@@ -618,8 +640,24 @@ export default class Test extends Command {
                     type: 'input',
                     name: 'confirmPath',
                     message: `Save '${workflowName}' to:`,
-                    default: targetPath
+                    default: originalPath ?? targetPath
                 }]);
+            // Restore the original deployed ID if we're overwriting an existing file,
+            // so the ephemeral test ID doesn't replace the production deployment link.
+            const resolvedConfirmPath = path.resolve(confirmPath);
+            const resolvedOriginal = originalPath ? path.resolve(originalPath) : null;
+            if (resolvedConfirmPath === resolvedOriginal && originalPath) {
+                try {
+                    const existing = JSON.parse(await fs.readFile(originalPath, 'utf-8'));
+                    if (existing.id)
+                        cleanData.id = existing.id;
+                }
+                catch { /* original file unreadable — leave cleanData as-is */ }
+            }
+            else if (!resolvedOriginal) {
+                // New file — strip ephemeral ID so next deploy creates fresh
+                delete cleanData.id;
+            }
             try {
                 await fs.mkdir(path.dirname(confirmPath), { recursive: true });
                 await fs.writeFile(confirmPath, JSON.stringify(cleanData, null, 2));
@@ -1197,13 +1235,27 @@ Previous error: "${errSnapshot}"`;
                 }
                 // Remove injected shim nodes and restore original connections.
                 if (preShimNodes !== null) {
+                    // Merge: restore original node definitions for shimmed nodes, but keep
+                    // any legitimate Code node repairs that happened during the test run.
+                    const restoredNodes = preShimNodes.map((originalNode) => {
+                        const currentNode = currentWorkflow.nodes.find((n) => n.id === originalNode.id);
+                        if (!currentNode)
+                            return originalNode;
+                        const isShimReplacement = currentNode.type === 'n8n-nodes-base.code' &&
+                            typeof currentNode.parameters?.jsCode === 'string' &&
+                            currentNode.parameters.jsCode.startsWith('// [n8m:shim]');
+                        return isShimReplacement ? originalNode : currentNode;
+                    });
                     try {
                         await client.updateWorkflow(workflowId, {
                             name: currentWorkflow.name,
-                            nodes: preShimNodes,
+                            nodes: restoredNodes,
                             connections: preShimConnections,
                             settings: currentWorkflow.settings || {},
                         });
+                        // Also restore in-memory so finalWorkflow/saveWorkflows gets production nodes
+                        currentWorkflow.nodes = restoredNodes;
+                        currentWorkflow.connections = preShimConnections;
                     }
                     catch { /* restore best-effort */ }
                 }
@@ -1551,6 +1603,48 @@ Previous error: "${errSnapshot}"`;
     // ---------------------------------------------------------------------------
     // Fixture helpers
     // ---------------------------------------------------------------------------
+    /** Run all fixture files in a directory as a suite. */
+    async runFixtureSuite(dirPath, fixtureManager, workflowName, aiService) {
+        const { readdirSync } = await import('fs');
+        const files = readdirSync(dirPath).filter((f) => f.endsWith('.json')).sort();
+        if (files.length === 0) {
+            this.log(theme.fail(`No fixture files found in ${dirPath}`));
+            return { passed: false, errors: ['No fixture files found'] };
+        }
+        const fixtures = files.flatMap((f) => {
+            const loaded = fixtureManager.loadFromPath(path.join(dirPath, f));
+            return loaded ? [loaded] : [];
+        });
+        return this.runFixtureSuiteFromList(fixtures, workflowName, aiService);
+    }
+    /** Run an in-memory list of fixtures as a suite and print a summary. */
+    async runFixtureSuiteFromList(fixtures, workflowName, aiService) {
+        this.log(theme.subHeader(`Running ${fixtures.length} fixture case(s) for ${workflowName}`));
+        const results = [];
+        for (const fixture of fixtures) {
+            const label = fixture.description ?? fixture.execution?.status ?? 'case';
+            const expected = fixture.expectedOutcome ?? 'pass';
+            this.log(`\n${theme.label('Case')} ${theme.value(label)}  ${theme.muted(`(expected: ${expected})`)}`);
+            const result = await this.testWithFixture(fixture, workflowName, aiService);
+            results.push({ label, passed: result.passed, error: result.errors[0] });
+        }
+        // Summary table
+        this.log(`\n${theme.subHeader('Suite Results')}`);
+        let suitePass = true;
+        for (const r of results) {
+            if (r.passed) {
+                this.log(`  ${theme.done(r.label)}`);
+            }
+            else {
+                this.log(`  ${theme.fail(r.label)}${r.error ? theme.muted(`  — ${r.error}`) : ''}`);
+                suitePass = false;
+            }
+        }
+        const passCount = results.filter(r => r.passed).length;
+        this.log(`\n${theme.label('Total')} ${theme.value(`${passCount}/${results.length} passed`)}`);
+        const allErrors = results.filter(r => !r.passed).map(r => r.error ?? r.label);
+        return { passed: suitePass, errors: allErrors };
+    }
     async offerSaveFixture(fixtureManager, workflowId, workflowName, finalWorkflow, lastExecution) {
         const { saveFixture } = await inquirer.prompt([{
                 type: 'confirm',
@@ -1622,10 +1716,20 @@ Previous error: "${errSnapshot}"`;
                 ? (failingNode ? `[${failingNode}] ${rawMsg}` : rawMsg)
                 : null;
         }
+        const expectedOutcome = fixture.expectedOutcome ?? 'pass';
         if (!fixtureError) {
+            if (expectedOutcome === 'fail') {
+                const msg = `Expected execution to fail, but it succeeded.`;
+                this.log(theme.fail(msg));
+                return { passed: false, errors: [msg], finalWorkflow: currentWorkflow };
+            }
             this.log(theme.done('Offline fixture: execution was successful.'));
             return { passed: true, errors: [], finalWorkflow: currentWorkflow };
         }
+        if (expectedOutcome === 'fail') {
+            this.log(theme.done(`Expected failure confirmed: ${fixtureError}`));
+            return { passed: true, errors: [], finalWorkflow: currentWorkflow };
+        }
         this.log(theme.agent(`Fixture captured a failure: ${fixtureError}`));
         const lastError = fixtureError;
         let scenarioPassed = false;

package/dist/services/ai.service.d.ts

@@ -2,6 +2,7 @@ export interface GenerateOptions {
     model?: string;
     provider?: string;
     temperature?: number;
+    maxTokens?: number;
 }
 export interface TestErrorEvaluation {
     action: 'fix_node' | 'regenerate_payload' | 'structural_pass' | 'escalate';
@@ -44,16 +45,48 @@ export declare class AIService {
     getDefaultModel(): string;
     getDefaultProvider(): string;
     generateSpec(goal: string): Promise<WorkflowSpec>;
+    chatAboutSpec(spec: WorkflowSpec, history: {
+        role: 'user' | 'assistant';
+        content: string;
+    }[], userMessage: string): Promise<{
+        reply: string;
+        updatedSpec: WorkflowSpec;
+    }>;
     generateWorkflow(goal: string): Promise<any>;
     generateAlternativeSpec(goal: string, primarySpec: WorkflowSpec): Promise<WorkflowSpec>;
+    generateModificationPlan(instruction: string, workflowJson: any): Promise<any>;
+    applyModification(workflowJson: any, userGoal: string, spec: any, userFeedback?: string, validNodeTypes?: string[]): Promise<any>;
+    /**
+     * Merge connections from the original workflow into the modified one for any
+     * nodes that exist in both but lost their connections during LLM generation.
+     * Then does a position-based stitch for any remaining nodes with no outgoing
+     * main connection, using canvas x/y position to infer the intended chain order.
+     */
+    private repairConnections;
     generateWorkflowFix(workflow: any, error: string, model?: string, _stream?: boolean, validNodeTypes?: string[]): Promise<any>;
     validateAndShim(workflow: any, validNodeTypes?: string[], explicitlyInvalid?: string[]): any;
     fixHallucinatedNodes(workflow: any): any;
+    /**
+     * Wire orphaned error-handler nodes that the LLM created but forgot to connect.
+     * Detects nodes with no incoming connections whose name suggests they are error
+     * handlers (contains "Error", "Cleanup", "Rollback", "Fallback", etc.) and wires
+     * every non-terminal, non-handler node's error output to them.
+     * Also sets onError:"continueErrorOutput" on each wired source node.
+     */
+    wireOrphanedErrorHandlers(workflow: any): any;
     fixN8nConnections(workflow: any): any;
     generateMockData(context: string): Promise<any>;
     fixExecuteCommandScript(command: string, error?: string): Promise<string>;
     fixCodeNodeJavaScript(code: string, error: string): Promise<string>;
     shimCodeNodeWithMockData(code: string): Promise<string>;
+    /**
+     * Analyze a validated working workflow and generate a reusable pattern file.
+     * Returns markdown content ready to save to docs/patterns/.
+     */
+    generatePattern(workflowJson: any): Promise<{
+        content: string;
+        slug: string;
+    }>;
     evaluateCandidates(goal: string, candidates: any[]): Promise<{
         selectedIndex: number;
         reason: string;