@outputai/cli 0.8.2-next.e1cd79b.0 → 0.8.2-next.e658cc2.0

package/dist/commands/workflow/test_eval.js

@@ -9,12 +9,13 @@ import { getEvalWorkflowName, renderEvalOutput, computeExitCode, EvalOutputSchem
 export default class WorkflowTest extends Command {
     static aliases = ['workflow:test'];
     static description = 'Run evaluations against a workflow using its datasets';
+    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> simple',
         '<%= config.bin %> <%= command.id %> simple --cached',
         '<%= config.bin %> <%= command.id %> simple --save',
         '<%= config.bin %> <%= command.id %> simple --dataset basic_input,edge_case',
-        '<%= config.bin %> <%= command.id %> simple --format json'
+        '<%= config.bin %> <%= command.id %> simple --json'
     ];
     static args = {
         workflowName: Args.string({
@@ -23,6 +24,14 @@ export default class WorkflowTest extends Command {
         })
     };
     static flags = {
+        catalog: Flags.string({
+            char: 'c',
+            aliases: ['task-queue'],
+            charAliases: ['q'],
+            deprecateAliases: true,
+            description: 'Catalog name for workflow execution (defaults to OUTPUT_CATALOG_ID)',
+            env: 'OUTPUT_CATALOG_ID'
+        }),
         cached: Flags.boolean({
             description: 'Use cached output from dataset files (skip workflow execution)',
             default: false,
@@ -36,19 +45,13 @@ export default class WorkflowTest extends Command {
         dataset: Flags.string({
             description: 'Comma-separated list of dataset names to run',
             char: 'd'
-        }),
-        format: Flags.string({
-            char: 'f',
-            description: 'Output format',
-            options: ['json', 'text'],
-            default: 'text'
         })
     };
     async run() {
         const { args, flags } = await this.parse(WorkflowTest);
         const filterNames = flags.dataset?.split(',').map(s => s.trim());
         const evalName = getEvalWorkflowName(args.workflowName);
-        await this.ensureEvalWorkflowRegistered(args.workflowName, evalName);
+        await this.ensureEvalWorkflowRegistered(args.workflowName, evalName, flags.catalog);
         const { datasets, dir } = await readAllDatasets(args.workflowName, filterNames);
         if (datasets.length === 0) {
             this.error(`No datasets found for workflow "${args.workflowName}".\n` +
@@ -56,11 +59,12 @@ export default class WorkflowTest extends Command {
         }
         const preparedDatasets = flags.cached ?
             this.validateDatasets(datasets) :
-            await this.runWorkflowForDatasets(args.workflowName, datasets, flags.save, dir);
+            await this.runWorkflowForDatasets(args.workflowName, datasets, flags.save, dir, flags.catalog);
         this.log(`Running eval workflow "${evalName}"...\n`);
         const response = await postWorkflowRun({
             workflowName: evalName,
-            input: { datasets: preparedDatasets }
+            input: { datasets: preparedDatasets },
+            catalog: flags.catalog
         }, {
             config: { timeout: 600000 }
         });
@@ -72,20 +76,15 @@ export default class WorkflowTest extends Command {
         if (flags.save) {
             await this.saveEvalResults(evalOutput, preparedDatasets, dir);
         }
-        if (flags.format === 'json') {
-            this.log(JSON.stringify(evalOutput, null, 2));
-        }
-        else {
+        if (!this.jsonEnabled()) {
             this.log(renderEvalOutput(evalOutput, evalName));
         }
-        const exitCode = computeExitCode(evalOutput);
-        if (exitCode !== 0) {
-            this.exit(exitCode);
-        }
+        process.exitCode = computeExitCode(evalOutput);
+        return evalOutput;
     }
-    async ensureEvalWorkflowRegistered(workflowName, evalName) {
-        const catalog = await fetchWorkflowCatalog().catch(() => null);
-        if (catalog && !catalog.some(w => w.name === evalName)) {
+    async ensureEvalWorkflowRegistered(workflowName, evalName, catalog) {
+        const workflows = await fetchWorkflowCatalog(catalog).catch(() => null);
+        if (workflows && !workflows.some(w => w.name === evalName)) {
             this.error(await diagnoseMissingEvalWorkflow(workflowName), { exit: 1 });
         }
     }
@@ -98,7 +97,7 @@ export default class WorkflowTest extends Command {
         }
         return datasets;
     }
-    async runWorkflowForDatasets(workflowName, datasets, save, dir) {
+    async runWorkflowForDatasets(workflowName, datasets, save, dir, catalog) {
         this.log(`Running workflow "${workflowName}" for ${datasets.length} dataset(s)...\n`);
         const results = [];
         for (const dataset of datasets) {
@@ -106,7 +105,8 @@ export default class WorkflowTest extends Command {
             const startMs = Date.now();
             const response = await postWorkflowRun({
                 workflowName,
-                input: dataset.input
+                input: dataset.input,
+                catalog
             }, {
                 config: { timeout: 600000 }
             });

package/dist/commands/workflow/test_eval.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/workflow/test_eval.spec.js

@@ -0,0 +1,121 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { getEvalWorkflowName, renderEvalOutput } from '@outputai/evals';
+vi.mock('#api/generated/api.js', () => ({
+    postWorkflowRun: vi.fn()
+}));
+vi.mock('#api/workflow_catalog.js', () => ({
+    fetchWorkflowCatalog: vi.fn()
+}));
+vi.mock('#services/datasets.js', () => ({
+    readAllDatasets: vi.fn(),
+    writeDataset: vi.fn()
+}));
+vi.mock('#utils/eval_diagnostics.js', () => ({
+    diagnoseMissingEvalWorkflow: vi.fn().mockResolvedValue('missing eval workflow')
+}));
+const passingOutput = {
+    cases: [{ datasetName: 'd1', verdict: 'pass', evaluators: [] }],
+    summary: { total: 1, passed: 1, partial: 0, failed: 0, acceptableRate: 1 }
+};
+const failingOutput = {
+    cases: [{ datasetName: 'd1', verdict: 'fail', evaluators: [] }],
+    summary: { total: 1, passed: 0, partial: 0, failed: 1, acceptableRate: 0 }
+};
+describe('workflow test command', () => {
+    const exitState = { original: undefined };
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        exitState.original = process.exitCode;
+        process.exitCode = undefined;
+        const { readAllDatasets } = await import('#services/datasets.js');
+        const { fetchWorkflowCatalog } = await import('#api/workflow_catalog.js');
+        vi.mocked(readAllDatasets).mockResolvedValue({
+            datasets: [{ name: 'd1', input: {}, last_output: { output: {}, date: '2026-01-01' } }],
+            dir: '/tmp/datasets'
+        });
+        // Catalog includes both eval names so ensureEvalWorkflowRegistered passes deterministically.
+        vi.mocked(fetchWorkflowCatalog).mockResolvedValue([
+            { name: getEvalWorkflowName('simple') },
+            { name: getEvalWorkflowName('my_workflow') }
+        ]);
+    });
+    afterEach(() => {
+        process.exitCode = exitState.original;
+    });
+    describe('command definition', () => {
+        it('enables the built-in --json flag', async () => {
+            const WorkflowTest = (await import('./test_eval.js')).default;
+            expect(WorkflowTest.enableJsonFlag).toBe(true);
+        });
+        it('binds the catalog flag to OUTPUT_CATALOG_ID', async () => {
+            const WorkflowTest = (await import('./test_eval.js')).default;
+            expect(WorkflowTest.flags).toHaveProperty('catalog');
+            expect(WorkflowTest.flags.catalog.env).toBe('OUTPUT_CATALOG_ID');
+            expect(WorkflowTest.flags.catalog.char).toBe('c');
+        });
+    });
+    describe('run()', () => {
+        const createCommand = async (jsonEnabled) => {
+            const WorkflowTest = (await import('./test_eval.js')).default;
+            const { postWorkflowRun } = await import('#api/generated/api.js');
+            const cmd = new WorkflowTest(['simple'], {});
+            cmd.log = vi.fn();
+            cmd.jsonEnabled = vi.fn().mockReturnValue(jsonEnabled);
+            cmd.parse = vi.fn().mockResolvedValue({
+                args: { workflowName: 'simple' },
+                flags: { cached: true, save: false, dataset: undefined }
+            });
+            return { cmd, postWorkflowRun: vi.mocked(postWorkflowRun) };
+        };
+        it('sets a non-zero exit code and returns the eval output when a case fails', async () => {
+            const { cmd, postWorkflowRun } = await createCommand(false);
+            postWorkflowRun.mockResolvedValue({ data: { output: failingOutput } });
+            const result = await cmd.run();
+            expect(result).toEqual(failingOutput);
+            expect(process.exitCode).toBe(1);
+        });
+        it('leaves the exit code at zero and returns the eval output when all cases pass', async () => {
+            const { cmd, postWorkflowRun } = await createCommand(false);
+            postWorkflowRun.mockResolvedValue({ data: { output: passingOutput } });
+            const result = await cmd.run();
+            expect(result).toEqual(passingOutput);
+            expect(process.exitCode).toBe(0);
+        });
+        it('renders the human-readable summary in text mode', async () => {
+            const { cmd, postWorkflowRun } = await createCommand(false);
+            postWorkflowRun.mockResolvedValue({ data: { output: passingOutput } });
+            await cmd.run();
+            const rendered = renderEvalOutput(passingOutput, getEvalWorkflowName('simple'));
+            expect(cmd.log).toHaveBeenCalledWith(rendered);
+        });
+        it('suppresses the rendered summary in JSON mode but still returns and sets exit code', async () => {
+            const { cmd, postWorkflowRun } = await createCommand(true);
+            postWorkflowRun.mockResolvedValue({ data: { output: failingOutput } });
+            const result = await cmd.run();
+            const rendered = renderEvalOutput(failingOutput, getEvalWorkflowName('simple'));
+            expect(cmd.log).not.toHaveBeenCalledWith(rendered);
+            expect(result).toEqual(failingOutput);
+            expect(process.exitCode).toBe(1);
+        });
+        it('routes registration, dataset runs, and the eval run to the resolved catalog', async () => {
+            const WorkflowTest = (await import('./test_eval.js')).default;
+            const { postWorkflowRun } = await import('#api/generated/api.js');
+            const { fetchWorkflowCatalog } = await import('#api/workflow_catalog.js');
+            const cmd = new WorkflowTest(['my_workflow'], {});
+            cmd.log = vi.fn();
+            cmd.jsonEnabled = vi.fn().mockReturnValue(false);
+            cmd.parse = vi.fn().mockResolvedValue({
+                args: { workflowName: 'my_workflow' },
+                flags: { catalog: 'my-catalog', cached: false, save: false, dataset: undefined }
+            });
+            vi.mocked(postWorkflowRun)
+                .mockResolvedValueOnce({ data: { output: {} }, status: 200, headers: new Headers() })
+                .mockResolvedValueOnce({ data: { output: passingOutput }, status: 200, headers: new Headers() });
+            await cmd.run();
+            expect(vi.mocked(fetchWorkflowCatalog)).toHaveBeenCalledWith('my-catalog');
+            expect(postWorkflowRun).toHaveBeenNthCalledWith(1, expect.objectContaining({ workflowName: 'my_workflow', catalog: 'my-catalog' }), expect.anything());
+            expect(postWorkflowRun).toHaveBeenNthCalledWith(2, expect.objectContaining({ workflowName: getEvalWorkflowName('my_workflow'), catalog: 'my-catalog' }), expect.anything());
+        });
+    });
+});

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.8.2-next.e1cd79b.0"
+    "framework": "0.8.2-next.e658cc2.0"
 }

package/dist/hooks/init.d.ts

@@ -2,6 +2,7 @@ import { Hook } from '@oclif/core';
 export declare const INTERACTIVE_FLAGS: string[];
 export declare const GLOBAL_FLAGS: Set<string>;
 export declare const hasInteractiveFlag: (argv: string[]) => boolean;
+export declare const hasJsonFlag: (argv: string[]) => boolean;
 export declare const stripGlobalFlags: (argv: string[]) => void;
 declare const hook: Hook<'init'>;
 export default hook;

package/dist/hooks/init.js

@@ -6,6 +6,10 @@ const debug = debugFactory('output-cli:init');
 export const INTERACTIVE_FLAGS = ['--yes', '--non-interactive'];
 export const GLOBAL_FLAGS = new Set(INTERACTIVE_FLAGS);
 export const hasInteractiveFlag = (argv) => argv.some(arg => INTERACTIVE_FLAGS.includes(arg));
+// The version banner must never reach stdout in JSON mode, where it would
+// corrupt the machine-readable output. oclif only suppresses `this.log` inside
+// the command, not hook output, so we detect `--json` ourselves.
+export const hasJsonFlag = (argv) => argv.includes('--json');
 export const stripGlobalFlags = (argv) => {
     const kept = argv.filter(arg => !GLOBAL_FLAGS.has(arg));
     if (kept.length !== argv.length) {
@@ -19,37 +23,43 @@ const hook = async function (opts) {
     if (interactive) {
         setNonInteractive(true);
     }
-    try {
-        // Only the local cache is read here; the registry roundtrip happens in a
-        // detached child so it never delays the invoked command.
-        const result = await readCachedResult(this.config.version, this.config.cacheDir);
-        if (!result) {
-            spawnBackgroundRefresh(this.config.version, this.config.cacheDir);
-            return;
-        }
-        if (!result.updateAvailable) {
-            return;
-        }
-        const border = ux.colorize('dim', '─'.repeat(80));
-        const warning = ux.colorize('yellow', 'Uhoh! Your Output.ai CLI is behind!');
-        const latestVer = ux.colorize('green', `v${result.latestVersion}`);
-        const currentVer = ux.colorize('yellow', `v${result.currentVersion}`);
-        const updateCmd = ux.colorize('cyan', 'npx output update');
-        ux.stdout('');
-        ux.stdout(border);
-        ux.stdout('');
-        ux.stdout(`  ⚠️  ${warning}`);
-        ux.stdout('');
-        ux.stdout(`     Latest is ${latestVer}, and you're using ${currentVer}`);
-        ux.stdout('');
-        ux.stdout(`     Run \`${updateCmd}\` to update`);
-        ux.stdout('');
-        ux.stdout(border);
-        ux.stdout('');
+    // Guard only the version-check IO: a broken or unreadable cache must never
+    // block CLI execution, so a failure is treated as "no cached result". Banner
+    // rendering below is intentionally left unguarded — a fault there is a real
+    // bug that should surface, not fail dark.
+    const result = await readCachedResult(this.config.version, this.config.cacheDir)
+        .catch((error) => {
+        debug('Version check failed: %O', error);
+        return null;
+    });
+    if (!result) {
+        spawnBackgroundRefresh(this.config.version, this.config.cacheDir);
+        return;
     }
-    catch (error) {
-        // Never block CLI execution
-        debug('Version banner failed: %O', error);
+    if (!result.updateAvailable) {
+        return;
     }
+    // Skip the banner entirely in JSON mode: even on stderr it is pure noise to
+    // a script consuming the command's structured output.
+    if (hasJsonFlag(opts.argv) || hasJsonFlag(process.argv)) {
+        return;
+    }
+    const border = ux.colorize('dim', '─'.repeat(80));
+    const warning = ux.colorize('yellow', 'Uhoh! Your Output.ai CLI is behind!');
+    const latestVer = ux.colorize('green', `v${result.latestVersion}`);
+    const currentVer = ux.colorize('yellow', `v${result.currentVersion}`);
+    const updateCmd = ux.colorize('cyan', 'npx output update');
+    // Advisory notice goes to stderr so stdout stays clean for piping in every mode.
+    ux.stderr('');
+    ux.stderr(border);
+    ux.stderr('');
+    ux.stderr(`  ⚠️  ${warning}`);
+    ux.stderr('');
+    ux.stderr(`     Latest is ${latestVer}, and you're using ${currentVer}`);
+    ux.stderr('');
+    ux.stderr(`     Run \`${updateCmd}\` to update`);
+    ux.stderr('');
+    ux.stderr(border);
+    ux.stderr('');
 };
 export default hook;

package/dist/hooks/init.spec.js

@@ -12,11 +12,12 @@ vi.mock('#utils/interactive.js', () => ({
 vi.mock('@oclif/core', () => ({
     ux: {
         stdout: vi.fn(),
+        stderr: vi.fn(),
         colorize: vi.fn((_color, text) => text)
     }
 }));
 import { ux } from '@oclif/core';
-import hook, { hasInteractiveFlag, stripGlobalFlags } from './init.js';
+import hook, { hasInteractiveFlag, hasJsonFlag, stripGlobalFlags } from './init.js';
 describe('init hook', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -24,7 +25,7 @@ describe('init hook', () => {
     const createHookContext = (version = '0.8.4') => ({
         config: { version, cacheDir: '/tmp/test-cache' }
     });
-    it('should display warning when cached result says an update is available', async () => {
+    it('should display warning on stderr when cached result says an update is available', async () => {
         vi.mocked(readCachedResult).mockResolvedValue({
             updateAvailable: true,
             currentVersion: '0.8.4',
@@ -34,13 +35,25 @@ describe('init hook', () => {
         await hook.call(ctx, { argv: [], id: undefined });
         expect(readCachedResult).toHaveBeenCalledWith('0.8.4', '/tmp/test-cache');
         expect(spawnBackgroundRefresh).not.toHaveBeenCalled();
-        expect(ux.stdout).toHaveBeenCalled();
-        const output = vi.mocked(ux.stdout).mock.calls.map(c => c[0]).join('\n');
+        expect(ux.stderr).toHaveBeenCalled();
+        expect(ux.stdout).not.toHaveBeenCalled();
+        const output = vi.mocked(ux.stderr).mock.calls.map(c => c[0]).join('\n');
         expect(output).toContain('Uhoh');
         expect(output).toContain('v1.0.0');
         expect(output).toContain('v0.8.4');
         expect(output).toContain('npx output update');
     });
+    it('should suppress the warning entirely in JSON mode', async () => {
+        vi.mocked(readCachedResult).mockResolvedValue({
+            updateAvailable: true,
+            currentVersion: '0.8.4',
+            latestVersion: '1.0.0'
+        });
+        const ctx = createHookContext();
+        await hook.call(ctx, { argv: ['--json'], id: undefined });
+        expect(ux.stderr).not.toHaveBeenCalled();
+        expect(ux.stdout).not.toHaveBeenCalled();
+    });
     it('should not display anything when up to date', async () => {
         vi.mocked(readCachedResult).mockResolvedValue({
             updateAvailable: false,
@@ -121,6 +134,17 @@ describe('init hook', () => {
             expect(hasInteractiveFlag([])).toBe(false);
         });
     });
+    describe('hasJsonFlag', () => {
+        it('returns true when --json is present', () => {
+            expect(hasJsonFlag(['workflow', 'runs', 'list', '--json'])).toBe(true);
+        });
+        it('returns false when --json is absent', () => {
+            expect(hasJsonFlag(['workflow', 'runs', 'list', '--format', 'table'])).toBe(false);
+        });
+        it('returns false for an empty argv', () => {
+            expect(hasJsonFlag([])).toBe(false);
+        });
+    });
     describe('stripGlobalFlags', () => {
         it('mutates argv in place to remove global flags', () => {
             const argv = ['init', '--yes', 'foo', '--non-interactive'];

package/dist/services/coding_agents.spec.js

@@ -3,13 +3,13 @@ import { checkAgentStructure, prepareTemplateVariables, initializeAgentConfig, e
 import { access } from 'node:fs/promises';
 import fs from 'node:fs/promises';
 vi.mock('node:fs/promises');
-vi.mock('../utils/paths.js', () => ({
+vi.mock('#utils/paths.js', () => ({
     getTemplateDir: vi.fn().mockReturnValue('/templates')
 }));
-vi.mock('../utils/template.js', () => ({
+vi.mock('#utils/template.js', () => ({
     processTemplate: vi.fn().mockImplementation((content) => content)
 }));
-vi.mock('../utils/claude.js', () => ({
+vi.mock('#utils/claude.js', () => ({
     executeClaudeCommand: vi.fn().mockResolvedValue(undefined)
 }));
 vi.mock('@oclif/core', () => ({
@@ -152,14 +152,14 @@ describe('coding_agents service', () => {
             vi.mocked(fs.writeFile).mockResolvedValue(undefined);
         });
         it('should call registerPluginMarketplace and installOutputAIPlugin', async () => {
-            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { executeClaudeCommand } = await import('#utils/claude.js');
             await ensureClaudePlugin('/test/project');
             expect(executeClaudeCommand).toHaveBeenCalledWith(['plugin', 'marketplace', 'add', 'growthxai/output'], '/test/project', { ignoreFailure: true });
             expect(executeClaudeCommand).toHaveBeenCalledWith(['plugin', 'marketplace', 'update', 'outputai'], '/test/project');
             expect(executeClaudeCommand).toHaveBeenCalledWith(['plugin', 'install', 'outputai@outputai', '--scope', 'project'], '/test/project');
         });
         it('should show error and prompt user when plugin commands fail', async () => {
-            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { executeClaudeCommand } = await import('#utils/claude.js');
             const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockResolvedValueOnce(undefined) // marketplace add
@@ -171,7 +171,7 @@ describe('coding_agents service', () => {
             }));
         });
         it('should allow user to proceed without plugin setup if they confirm', async () => {
-            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { executeClaudeCommand } = await import('#utils/claude.js');
             const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockRejectedValue(new Error('All plugin commands fail'));
@@ -221,7 +221,7 @@ describe('coding_agents service', () => {
             vi.mocked(fs.writeFile).mockResolvedValue(undefined);
         });
         it('should show error and prompt user when registerPluginMarketplace fails', async () => {
-            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { executeClaudeCommand } = await import('#utils/claude.js');
             const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockResolvedValueOnce(undefined) // marketplace add
@@ -233,7 +233,7 @@ describe('coding_agents service', () => {
             }));
         });
         it('should show error and prompt user when installOutputAIPlugin fails', async () => {
-            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { executeClaudeCommand } = await import('#utils/claude.js');
             const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockResolvedValueOnce(undefined) // marketplace add
@@ -246,7 +246,7 @@ describe('coding_agents service', () => {
             }));
         });
         it('should allow user to proceed without plugin setup if they confirm', async () => {
-            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { executeClaudeCommand } = await import('#utils/claude.js');
             const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockRejectedValue(new Error('All plugin commands fail'));
@@ -256,7 +256,7 @@ describe('coding_agents service', () => {
             expect(fs.mkdir).toHaveBeenCalled();
         });
         it('should rethrow plugin error in non-interactive mode without prompting', async () => {
-            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { executeClaudeCommand } = await import('#utils/claude.js');
             const { confirm } = await import('#utils/prompt.js');
             const { isInteractive } = await import('#utils/interactive.js');
             vi.mocked(isInteractive).mockReturnValueOnce(false);

package/dist/utils/format_workflow_result.spec.js

@@ -1,6 +1,5 @@
 import { describe, it, expect } from 'vitest';
 import { formatWorkflowResult } from './format_workflow_result.js';
-import { formatOutput } from './output_formatter.js';
 describe('formatWorkflowResult', () => {
     it('should display output for completed workflows', () => {
         const result = formatWorkflowResult({
@@ -76,16 +75,4 @@ describe('formatWorkflowResult', () => {
         expect(result).toContain('Status: failed');
         expect(result).not.toContain('Error:');
     });
-    it('should work with formatOutput for json format', () => {
-        const data = {
-            workflowId: 'wf-456',
-            status: 'failed',
-            output: null,
-            error: 'Activity task failed'
-        };
-        const output = formatOutput(data, 'json', formatWorkflowResult);
-        const parsed = JSON.parse(output);
-        expect(parsed.status).toBe('failed');
-        expect(parsed.error).toBe('Activity task failed');
-    });
 });

package/dist/utils/resolve_input.d.ts

@@ -1 +1 @@
-export declare function resolveInput(workflowName: string, scenario: string | undefined, inputFlag: string | undefined, commandName: string): Promise<unknown>;
+export declare function resolveInput(workflowName: string, scenario: string | undefined, inputFlag: string | undefined, commandName: string, catalog?: string): Promise<unknown>;

package/dist/utils/resolve_input.js

@@ -1,7 +1,7 @@
 import { ux } from '@oclif/core';
 import { parseInputFlag } from '#utils/input_parser.js';
 import { resolveScenarioPath, getScenarioNotFoundMessage } from '#utils/scenario_resolver.js';
-export async function resolveInput(workflowName, scenario, inputFlag, commandName) {
+export async function resolveInput(workflowName, scenario, inputFlag, commandName, catalog) {
     if (inputFlag && scenario) {
         return ux.error('Cannot use both scenario argument and --input flag. Choose one.', { exit: 1 });
     }
@@ -9,7 +9,7 @@ export async function resolveInput(workflowName, scenario, inputFlag, commandNam
         return parseInputFlag(inputFlag);
     }
     if (scenario) {
-        const resolution = await resolveScenarioPath(workflowName, scenario);
+        const resolution = await resolveScenarioPath(workflowName, scenario, undefined, undefined, catalog);
         if (!resolution.found) {
             return ux.error(getScenarioNotFoundMessage(workflowName, scenario, resolution.searchedPaths), { exit: 1 });
         }

package/dist/utils/scenario_resolver.d.ts

@@ -4,6 +4,6 @@ export interface ScenarioResolutionResult {
     path?: string;
     searchedPaths: string[];
 }
-export declare function resolveScenarioPath(workflowName: string, scenarioName: string, basePath?: string, workflowPath?: string): Promise<ScenarioResolutionResult>;
+export declare function resolveScenarioPath(workflowName: string, scenarioName: string, basePath?: string, workflowPath?: string, catalog?: string): Promise<ScenarioResolutionResult>;
 export declare function listScenariosForWorkflow(workflowName: string, workflowPath?: string, basePath?: string): string[];
 export declare function getScenarioNotFoundMessage(workflowName: string, scenarioName: string, searchedPaths: string[]): string;

package/dist/utils/scenario_resolver.js

@@ -26,7 +26,7 @@ function resolveScenarioFromScenarioDirs(scenariosDirs, scenarioFileName) {
         { found: true, path, searchedPaths } :
         { found: false, searchedPaths };
 }
-export async function resolveScenarioPath(workflowName, scenarioName, basePath = getWorkflowsBasePath(), workflowPath) {
+export async function resolveScenarioPath(workflowName, scenarioName, basePath = getWorkflowsBasePath(), workflowPath, catalog) {
     const scenarioFileName = scenarioName.endsWith('.json') ?
         scenarioName :
         `${scenarioName}.json`;
@@ -36,7 +36,7 @@ export async function resolveScenarioPath(workflowName, scenarioName, basePath =
             return pathResult;
         }
     }
-    const catalogPath = workflowPath ? null : await fetchWorkflowPath(workflowName);
+    const catalogPath = workflowPath ? null : await fetchWorkflowPath(workflowName, catalog);
     if (catalogPath) {
         const result = resolveScenarioFromScenarioDirs(candidateScenarioDirsFromPath(catalogPath, basePath), scenarioFileName);
         if (result.found) {

package/dist/utils/scenario_resolver.spec.js

@@ -156,6 +156,20 @@ describe('resolveScenarioPath', () => {
             expect(result.path).toContain('complex/deep_test.json');
         });
     });
+    describe('catalog routing', () => {
+        it('forwards the provided catalog to the catalog lookup', async () => {
+            mockCatalog([{ name: 'my_workflow', path: '/app/dist/workflows/my_workflow/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            await resolveScenarioPath('my_workflow', 'test', '/project', undefined, 'os-workflows');
+            expect(catalog.fetchWorkflowCatalog).toHaveBeenCalledWith('os-workflows');
+        });
+        it('looks up the default catalog when no catalog is provided', async () => {
+            mockCatalog([{ name: 'my_workflow', path: '/app/dist/workflows/my_workflow/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            await resolveScenarioPath('my_workflow', 'test', '/project');
+            expect(catalog.fetchWorkflowCatalog).toHaveBeenCalledWith(undefined);
+        });
+    });
 });
 describe('listScenariosForWorkflow', () => {
     beforeEach(() => {

package/dist/utils/trace_formatter.js

@@ -1,6 +1,5 @@
 import Table from 'cli-table3';
 import { ux } from '@oclif/core';
-import { formatOutput } from '#utils/output_formatter.js';
 import { formatDuration } from '#utils/date_formatter.js';
 import { getErrorMessage } from '#utils/error_utils.js';
 import { isTraceEvent, isValidTimestamp } from '#types/trace.js';
@@ -369,7 +368,7 @@ const formatAsText = (trace) => {
 export function format(traceData, outputFormat = 'text') {
     const trace = typeof traceData === 'string' ? JSON.parse(traceData) : traceData;
     if (outputFormat === 'json') {
-        return formatOutput(trace, 'json');
+        return JSON.stringify(trace, null, 2);
     }
     return formatAsText(trace);
 }

package/dist/utils/workflow_dir.d.ts

@@ -2,7 +2,7 @@ export declare const WORKFLOWS_PATHS: string[];
 export declare function extractWorkflowRelativePath(path: string): string | null;
 export declare function candidateWorkflowDirsFromPath(workflowPath: string, basePath: string): string[];
 export declare function findWorkflowDirectoryFromPath(workflowPath: string | undefined, basePath?: string): string | null;
-export declare function fetchWorkflowPath(workflowName: string): Promise<string | null>;
+export declare function fetchWorkflowPath(workflowName: string, catalog?: string): Promise<string | null>;
 /**
  * Resolve the on-disk directory of a registered workflow by name.
  *

package/dist/utils/workflow_dir.js

@@ -23,9 +23,9 @@ export function findWorkflowDirectoryFromPath(workflowPath, basePath = getWorkfl
     }
     return candidateWorkflowDirsFromPath(workflowPath, basePath).find(existsSync) ?? null;
 }
-export async function fetchWorkflowPath(workflowName) {
+export async function fetchWorkflowPath(workflowName, catalog) {
     try {
-        const workflows = await fetchWorkflowCatalog();
+        const workflows = await fetchWorkflowCatalog(catalog);
         const workflow = workflows.find(w => w.name === workflowName);
         return workflow?.path ?? null;
     }

package/dist/views/dev/modals/run_modal.d.ts

@@ -1,5 +1,14 @@
 import React from 'react';
+type EntryKind = 'scenario' | 'custom';
+interface Entry {
+    kind: EntryKind;
+    label: string;
+    scenarioName?: string;
+}
+export declare const buildEntries: (scenarios: string[]) => Entry[];
+export declare const validateScenarioName: (raw: string, existing: string[]) => string | null;
 export declare const RunModal: React.FC<{
     workflowName: string;
     workflowPath?: string;
 }>;
+export {};