@lhi/n8m 0.2.1 → 0.2.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)}`);
@@ -98,117 +98,150 @@ export default class Create extends Command {
                         });
                     }
                 }
-                else if (nodeName === 'engineer') {
-                    this.log(theme.agent(`⚙️  Engineer: Workflow code generated/updated.`));
-                    if (stateUpdate.workflowJson) {
-                        lastWorkflowJson = stateUpdate.workflowJson;
-                    }
-                }
-                else if (nodeName === 'qa') {
-                    const status = stateUpdate.validationStatus;
-                    if (status === 'passed') {
-                        this.log(theme.success(`🧪 QA: Validation Passed!`));
-                    }
-                    else {
-                        this.log(theme.fail(`🧪 QA: Validation Failed.`));
-                        if (stateUpdate.validationErrors && stateUpdate.validationErrors.length > 0) {
-                            stateUpdate.validationErrors.forEach((e) => this.log(theme.error(`   - ${e}`)));
-                        }
-                        this.log(theme.warn(`   Looping back to Engineer for repairs...`));
-                    }
-                }
             }
-            // Check for interrupt/pause
+            // Handle interrupt/pause loop
             let snapshot = await graph.getState({ configurable: { thread_id: threadId } });
             while (snapshot.next.length > 0) {
                 const nextNode = snapshot.next[0];
-                this.log(theme.warn(`\n⏸️  Workflow Paused at step: ${nextNode}`));
                 if (nextNode === 'engineer') {
-                    const { action } = await inquirer.prompt([{
-                            type: 'list',
-                            name: 'action',
-                            message: 'How would you like to proceed with the Blueprint?',
-                            choices: [
-                                { name: 'Approve and Generate Workflow', value: 'approve' },
-                                { name: 'Provide Feedback / Refine Strategy', value: 'feedback' },
-                                { name: 'Exit and Resume Later', value: 'exit' }
-                            ]
-                        }]);
-                    if (action === 'approve') {
-                        this.log(theme.agent("Approve! Proceeding to engineering..."));
-                        await graph.updateState({ configurable: { thread_id: threadId } }, { userFeedback: undefined }, nextNode);
-                        const stream = await graph.stream(null, { configurable: { thread_id: threadId } });
-                        for await (const event of stream) {
-                            const nodeName = Object.keys(event)[0];
-                            const stateUpdate = event[nodeName];
-                            if (nodeName === 'engineer') {
-                                this.log(theme.agent(`⚙️  Engineer: Workflow code generated/updated.`));
-                                if (stateUpdate.workflowJson)
-                                    lastWorkflowJson = stateUpdate.workflowJson;
+                    const isRepair = (snapshot.values.validationErrors || []).length > 0;
+                    if (isRepair) {
+                        // Repair iteration — auto-continue without asking the user
+                        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') {
+                                this.log(theme.agent(`⚙️  Engineer: Applying fixes...`));
+                                if (u.workflowJson)
+                                    lastWorkflowJson = u.workflowJson;
                             }
-                            else if (nodeName === 'qa') {
-                                const status = stateUpdate.validationStatus;
-                                if (status === 'passed')
-                                    this.log(theme.success(`🧪 QA: Validation Passed!`));
-                                else
-                                    this.log(theme.fail(`🧪 QA: Validation Failed.`));
+                            else if (n === 'supervisor' && u.workflowJson) {
+                                lastWorkflowJson = u.workflowJson;
                             }
                         }
                     }
-                    else if (action === 'feedback') {
-                        const { feedback } = await inquirer.prompt([{
-                                type: 'input',
-                                name: 'feedback',
-                                message: 'Enter your feedback/instructions:',
+                    else {
+                        // Initial build — let user choose which strategy to use
+                        const strategies = snapshot.values.strategies || [];
+                        const spec = snapshot.values.spec;
+                        const choices = [];
+                        if (strategies.length > 0) {
+                            strategies.forEach((s, i) => {
+                                const tag = i === 0 ? 'Primary' : 'Alternative';
+                                const nodes = s.nodes
+                                    ?.map((n) => n.type?.split('.').pop())
+                                    .join(', ');
+                                choices.push({
+                                    name: `[${tag}] ${s.suggestedName}${nodes ? `  ·  ${nodes}` : ''}`,
+                                    value: { type: 'build', strategy: s },
+                                    short: s.suggestedName,
+                                });
+                            });
+                        }
+                        else if (spec) {
+                            choices.push({
+                                name: spec.suggestedName,
+                                value: { type: 'build', strategy: spec },
+                                short: spec.suggestedName,
+                            });
+                        }
+                        choices.push(new inquirer.Separator());
+                        choices.push({
+                            name: 'Add feedback before building',
+                            value: { type: 'feedback' },
+                            short: 'Add feedback',
+                        });
+                        choices.push({
+                            name: 'Exit (save session to resume later)',
+                            value: { type: 'exit' },
+                            short: 'Exit',
+                        });
+                        const { choice } = await inquirer.prompt([{
+                                type: 'list',
+                                name: 'choice',
+                                message: strategies.length > 1
+                                    ? 'The Architect designed two approaches — which should the Engineer build?'
+                                    : 'Blueprint ready. How would you like to proceed?',
+                                choices,
                             }]);
-                        this.log(theme.agent("Updating strategy with your feedback..."));
-                        // In a real implementation, we'd loop back to Architect or update the goal.
-                        // For now, let's update userFeedback and resume. 
-                        // To actually RE-ARCHITECT, we might need to jump back.
-                        // LangGraph can handle this by updating state and using a conditional edge.
-                        await graph.updateState({ configurable: { thread_id: threadId } }, { userFeedback: feedback }, nextNode);
-                        // For now, just resume and let Engineer see the feedback.
-                        const stream = await graph.stream(null, { configurable: { thread_id: threadId } });
-                        for await (const event of stream) {
-                            const nodeName = Object.keys(event)[0];
-                            const stateUpdate = event[nodeName];
-                            if (nodeName === 'engineer') {
-                                this.log(theme.agent(`⚙️  Engineer: Workflow code generated/updated (Feedback incorporated).`));
-                                if (stateUpdate.workflowJson)
-                                    lastWorkflowJson = stateUpdate.workflowJson;
+                        if (choice.type === 'exit') {
+                            this.log(theme.info(`\nSession saved. Resume later with: n8m resume ${threadId}`));
+                            return;
+                        }
+                        let chosenSpec = choice.strategy ?? spec;
+                        let stateUpdate = { spec: chosenSpec, userFeedback: undefined };
+                        if (choice.type === 'feedback') {
+                            const { feedback } = await inquirer.prompt([{
+                                    type: 'input',
+                                    name: 'feedback',
+                                    message: 'Describe your refinements (the Engineer will incorporate them):',
+                                }]);
+                            chosenSpec = strategies[0] ?? spec;
+                            stateUpdate = { spec: chosenSpec, userFeedback: feedback };
+                            this.log(theme.agent(`Feedback noted. Building "${chosenSpec?.suggestedName}" with your refinements...`));
+                        }
+                        else {
+                            this.log(theme.agent(`Building "${chosenSpec?.suggestedName}"...`));
+                        }
+                        await graph.updateState({ configurable: { thread_id: threadId } }, stateUpdate, nextNode);
+                        const buildStream = await graph.stream(null, { configurable: { thread_id: threadId } });
+                        for await (const event of buildStream) {
+                            const n = Object.keys(event)[0];
+                            const u = event[n];
+                            if (n === 'engineer') {
+                                this.log(theme.agent(`⚙️  Engineer: Building workflow...`));
+                                if (u.workflowJson)
+                                    lastWorkflowJson = u.workflowJson;
+                            }
+                            else if (n === 'supervisor' && u.workflowJson) {
+                                lastWorkflowJson = u.workflowJson;
                             }
-                            else if (nodeName === 'qa') {
-                                if (stateUpdate.validationStatus === 'passed')
-                                    this.log(theme.success(`🧪 QA: Validation Passed!`));
+                            else if (n === 'reviewer' && u.validationStatus === 'failed') {
+                                this.log(theme.warn(`   Reviewer flagged issues — Engineer will revise...`));
                             }
                         }
                     }
-                    else {
-                        this.log(theme.info(`Session persisted. Resume later with: n8m resume ${threadId}`));
-                        return;
-                    }
                 }
-                else {
-                    // Handle other interrupts (like QA)
-                    const { resume } = await inquirer.prompt([{
+                else if (nextNode === 'qa') {
+                    const { proceed } = await inquirer.prompt([{
                             type: 'confirm',
-                            name: 'resume',
-                            message: `Review completed for ${nextNode}. Resume workflow execution?`,
-                            default: true
+                            name: 'proceed',
+                            message: 'Workflow generated! Ready to run QA tests?',
+                            default: true,
                         }]);
-                    if (resume) {
-                        this.log(theme.agent("Resuming..."));
-                        const result = await resumeAgenticWorkflow(threadId);
-                        if (result.validationStatus === 'passed') {
-                            this.log(theme.success(`🧪 QA (Resumed): Validation Passed!`));
-                            if (result.workflowJson)
-                                lastWorkflowJson = result.workflowJson;
-                        }
-                    }
-                    else {
-                        this.log(theme.info(`Session persisted. Resume later with: n8m resume ${threadId}`));
+                    if (!proceed) {
+                        this.log(theme.info(`\nSession saved. Resume later with: n8m resume ${threadId}`));
                         return;
                     }
+                    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 if (n === 'supervisor' && u.workflowJson) {
+                            lastWorkflowJson = u.workflowJson;
+                        }
+                    }
+                }
+                else {
+                    // Unknown interrupt — auto-resume
+                    const result = await resumeAgenticWorkflow(threadId);
+                    if (result.workflowJson)
+                        lastWorkflowJson = result.workflowJson;
                 }
                 snapshot = await graph.getState({ configurable: { thread_id: threadId } });
             }
@@ -225,7 +258,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 +275,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);
     }

package/dist/commands/doc.js

@@ -22,7 +22,7 @@ export default class Doc extends Command {
         }),
     };
     async run() {
-        const { args, flags } = await this.parse(Doc);
+        const { args } = await this.parse(Doc);
         this.log(theme.brand());
         this.log(theme.header('WORKFLOW DOCUMENTATION'));
         // 1. Load Credentials & Client

package/dist/commands/fixture.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class Fixture extends Command {
+    static args: {
+        action: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        workflowId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private initFixture;
+    private captureFixture;
+}

package/dist/commands/fixture.js

@@ -0,0 +1,258 @@
+import { Args, Command } from '@oclif/core';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { existsSync } from 'node:fs';
+import inquirer from 'inquirer';
+import { theme } from '../utils/theme.js';
+import { N8nClient } from '../utils/n8nClient.js';
+import { ConfigManager } from '../utils/config.js';
+import { FixtureManager } from '../utils/fixtureManager.js';
+export default class Fixture extends Command {
+    static args = {
+        action: Args.string({
+            description: 'Action to perform (init, capture)',
+            required: true,
+            options: ['init', 'capture'],
+        }),
+        workflowId: Args.string({
+            description: 'n8n workflow ID (optional — omit to browse and select)',
+            required: false,
+        }),
+    };
+    static description = 'Manage n8m workflow fixtures for offline testing';
+    static examples = [
+        '<%= config.bin %> fixture init abc123       # scaffold an empty fixture template',
+        '<%= config.bin %> fixture capture           # browse local files + n8n instance to pick a workflow',
+        '<%= config.bin %> fixture capture abc123    # pull latest real execution for a specific workflow ID',
+    ];
+    async run() {
+        const { args } = await this.parse(Fixture);
+        if (args.action === 'init') {
+            await this.initFixture(args.workflowId);
+        }
+        else if (args.action === 'capture') {
+            await this.captureFixture(args.workflowId);
+        }
+    }
+    async initFixture(workflowId) {
+        if (!workflowId) {
+            this.log(theme.fail('Usage: n8m fixture init <workflowId>'));
+            return;
+        }
+        const fixturesDir = path.join(process.cwd(), '.n8m', 'fixtures');
+        const fixturePath = path.join(fixturesDir, `${workflowId}.json`);
+        if (existsSync(fixturePath)) {
+            const { overwrite } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: `Fixture already exists at ${fixturePath}. Overwrite?`,
+                    default: false,
+                }]);
+            if (!overwrite) {
+                this.log(theme.muted('Aborted.'));
+                return;
+            }
+        }
+        const schemaPath = '../../node_modules/n8m/dist/fixture-schema.json';
+        const capturedAt = new Date().toISOString();
+        const template = {
+            $schema: schemaPath,
+            version: '1.0',
+            capturedAt,
+            workflowId,
+            workflowName: 'My Workflow',
+            workflow: {
+                name: 'My Workflow',
+                nodes: [],
+                connections: {},
+            },
+            execution: {
+                status: 'success',
+                data: {
+                    resultData: {
+                        error: null,
+                        runData: {
+                            'Your Node Name': [
+                                { json: { key: 'value' } },
+                            ],
+                        },
+                    },
+                },
+            },
+        };
+        await fs.mkdir(fixturesDir, { recursive: true });
+        await fs.writeFile(fixturePath, JSON.stringify(template, null, 2), 'utf-8');
+        this.log(theme.success(`Created ${fixturePath}`));
+        this.log('');
+        this.log(theme.muted('  Fill in each node\'s output under execution.data.resultData.runData.'));
+        this.log(theme.muted('  Keys must match exact node names in your workflow.'));
+        this.log('');
+        this.log(theme.muted('  To test with this fixture:'));
+        this.log(theme.muted(`    n8m test --fixture ${fixturePath}`));
+        this.log(theme.muted(`  Or n8m will auto-detect it when you run: n8m test (workflow ID: ${workflowId})`));
+    }
+    async captureFixture(workflowId) {
+        const config = await ConfigManager.load();
+        const n8nUrl = config.n8nUrl ?? process.env.N8N_API_URL;
+        const n8nKey = config.n8nKey ?? process.env.N8N_API_KEY;
+        if (!n8nUrl || !n8nKey) {
+            this.log(theme.fail('n8n instance not configured. Run: n8m config --n8n-url <url> --n8n-key <key>'));
+            return;
+        }
+        const client = new N8nClient({ apiUrl: n8nUrl, apiKey: n8nKey });
+        // If no workflowId provided, show interactive picker (local + remote)
+        let resolvedId = workflowId;
+        let resolvedName;
+        if (!resolvedId) {
+            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')) {
+                            try {
+                                const raw = await fs.readFile(path.join(dir, file), 'utf-8');
+                                const parsed = JSON.parse(raw);
+                                if (parsed.id) {
+                                    localChoices.push({
+                                        name: `${theme.value('[LOCAL]')} ${parsed.name ?? file} (${parsed.id})`,
+                                        value: { type: 'local', id: parsed.id, name: parsed.name ?? file },
+                                    });
+                                }
+                            }
+                            catch {
+                                // skip unparseable files
+                            }
+                        }
+                    }
+                }
+            }
+            let remoteChoices = [];
+            try {
+                const remoteWorkflows = await client.getWorkflows();
+                remoteChoices = remoteWorkflows
+                    .filter((w) => !w.name.startsWith('[TEST'))
+                    .map((w) => ({
+                    name: `${theme.info('[n8n]')} ${w.name} (${w.id})${w.active ? ' [Active]' : ''}`,
+                    value: { type: 'remote', id: w.id, name: w.name },
+                }));
+            }
+            catch (e) {
+                this.log(theme.warn(`Could not fetch remote workflows: ${e.message}`));
+            }
+            const choices = [
+                ...(localChoices.length > 0 ? [new inquirer.Separator('--- Local Files ---'), ...localChoices] : []),
+                ...(remoteChoices.length > 0 ? [new inquirer.Separator('--- n8n Instance ---'), ...remoteChoices] : []),
+            ];
+            if (choices.length === 0) {
+                this.log(theme.fail('No workflows found locally or on your n8n instance.'));
+                return;
+            }
+            const { selection } = await inquirer.prompt([{
+                    type: 'select',
+                    name: 'selection',
+                    message: 'Select a workflow to capture:',
+                    choices,
+                    pageSize: 15,
+                }]);
+            resolvedId = selection.id;
+            resolvedName = selection.name;
+        }
+        if (!resolvedId)
+            return;
+        this.log(theme.agent(`Fetching workflow ${resolvedId} from n8n...`));
+        let workflow;
+        try {
+            workflow = await client.getWorkflow(resolvedId);
+        }
+        catch (e) {
+            this.log(theme.fail(`Could not fetch workflow: ${e.message}`));
+            return;
+        }
+        resolvedName = resolvedName ?? workflow.name ?? resolvedId;
+        this.log(theme.agent(`Fetching executions for workflow ${resolvedId}...`));
+        let executions;
+        try {
+            executions = await client.getWorkflowExecutions(resolvedId);
+        }
+        catch (e) {
+            this.log(theme.fail(`Could not fetch executions: ${e.message}`));
+            return;
+        }
+        if (!executions?.length) {
+            this.log(theme.warn('No executions found for this workflow. Run it in n8n first, then capture.'));
+            return;
+        }
+        const executionChoices = executions.map((ex) => {
+            const date = ex.startedAt ? new Date(ex.startedAt).toLocaleString() : 'unknown time';
+            const rawStatus = ex.status ?? (ex.finished === true ? 'success' : ex.finished === false ? 'running' : undefined);
+            const statusLabel = rawStatus === 'success' ? theme.success(rawStatus)
+                : rawStatus ? theme.fail(rawStatus)
+                    : theme.muted('unknown');
+            return {
+                name: `#${ex.id}  ${statusLabel}  ${theme.muted(date)}`,
+                value: ex,
+            };
+        });
+        const { selectedExecution } = await inquirer.prompt([{
+                type: 'select',
+                name: 'selectedExecution',
+                message: 'Select an execution to capture:',
+                choices: executionChoices,
+                pageSize: 15,
+            }]);
+        const latest = selectedExecution;
+        this.log(theme.muted(`  Selected execution ${latest.id} (${latest.status}, ${latest.startedAt})`));
+        let fullExec;
+        try {
+            fullExec = await client.getExecution(latest.id);
+        }
+        catch (e) {
+            this.log(theme.fail(`Could not fetch execution data: ${e.message}`));
+            return;
+        }
+        const fixtureManager = new FixtureManager();
+        const fixturePath = path.join(process.cwd(), '.n8m', 'fixtures', `${resolvedId}.json`);
+        if (existsSync(fixturePath)) {
+            const { overwrite } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: `Fixture already exists for workflow ${resolvedId}. Overwrite?`,
+                    default: true,
+                }]);
+            if (!overwrite) {
+                this.log(theme.muted('Aborted.'));
+                return;
+            }
+        }
+        await fixtureManager.save({
+            version: '1.0',
+            capturedAt: new Date().toISOString(),
+            workflowId: resolvedId,
+            workflowName: resolvedName ?? resolvedId,
+            workflow,
+            execution: {
+                id: fullExec.id,
+                status: fullExec.status,
+                startedAt: fullExec.startedAt,
+                data: {
+                    resultData: {
+                        error: fullExec.data?.resultData?.error ?? null,
+                        runData: fullExec.data?.resultData?.runData ?? {},
+                    },
+                },
+            },
+        });
+        const nodeCount = Object.keys(fullExec.data?.resultData?.runData ?? {}).length;
+        this.log(theme.success(`Fixture saved to .n8m/fixtures/${resolvedId}.json`));
+        this.log(theme.muted(`  Workflow: ${resolvedName}`));
+        this.log(theme.muted(`  Execution: ${fullExec.status} · ${nodeCount} node(s) captured`));
+        this.log('');
+        this.log(theme.muted('  To test with this fixture:'));
+        this.log(theme.muted(`    n8m test --fixture .n8m/fixtures/${resolvedId}.json`));
+        this.log(theme.muted(`  Or just run: n8m test  (auto-detected by workflow ID)`));
+    }
+}