@outputai/cli 0.8.2-next.42a0ddf.0 → 0.8.2-next.7929835.0

package/dist/assets/docker/docker-compose-dev.yml

@@ -80,7 +80,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.8.2-next.42a0ddf.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.8.2-next.7929835.0}
     init: true
     networks:
       - main

package/dist/commands/workflow/dataset/generate.d.ts

@@ -7,6 +7,7 @@ export default class DatasetGenerate extends Command {
         scenario: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         trace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         download: import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/commands/workflow/dataset/generate.js

@@ -26,6 +26,14 @@ export default class DatasetGenerate 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'
+        }),
         trace: Flags.string({
             char: 't',
             description: 'Path to a local trace file to extract dataset from',
@@ -61,15 +69,16 @@ export default class DatasetGenerate extends Command {
             await this.generateFromTrace(args.workflowName, flags.trace, flags.name);
             return;
         }
-        await this.generateFromScenario(args.workflowName, args.scenario, flags.input, flags.name);
+        await this.generateFromScenario(args.workflowName, args.scenario, flags.input, flags.name, flags.catalog);
     }
-    async generateFromScenario(workflowName, scenario, inputFlag, nameOverride) {
-        const resolvedInput = await this.resolveScenarioInput(workflowName, scenario, inputFlag);
+    async generateFromScenario(workflowName, scenario, inputFlag, nameOverride, catalog) {
+        const resolvedInput = await this.resolveScenarioInput(workflowName, scenario, inputFlag, catalog);
         const datasetName = nameOverride ?? scenario ?? 'dataset';
         this.log(`Running workflow "${workflowName}"...`);
         const response = await postWorkflowRun({
             workflowName,
-            input: resolvedInput
+            input: resolvedInput,
+            catalog
         }, {
             config: { timeout: 600000 }
         });
@@ -116,7 +125,7 @@ export default class DatasetGenerate extends Command {
         }
         this.log(`\nGenerated ${traces.length} dataset(s)`);
     }
-    async resolveScenarioInput(workflowName, scenario, inputFlag) {
+    async resolveScenarioInput(workflowName, scenario, inputFlag, catalog) {
         if (inputFlag && scenario) {
             return ux.error('Cannot use both scenario argument and --input flag. Choose one.', { exit: 1 });
         }
@@ -124,7 +133,7 @@ export default class DatasetGenerate extends Command {
             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/commands/workflow/dataset/generate.spec.d.ts

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

package/dist/commands/workflow/dataset/generate.spec.js

@@ -0,0 +1,69 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('#api/generated/api.js', () => ({
+    postWorkflowRun: vi.fn()
+}));
+vi.mock('#utils/scenario_resolver.js', () => ({
+    resolveScenarioPath: vi.fn(),
+    getScenarioNotFoundMessage: vi.fn().mockReturnValue('not found')
+}));
+vi.mock('#utils/input_parser.js', () => ({
+    parseInputFlag: vi.fn()
+}));
+vi.mock('#services/datasets.js', () => ({
+    writeDataset: vi.fn(),
+    resolveDefaultDatasetsDir: vi.fn().mockResolvedValue('/datasets'),
+    buildDataset: vi.fn().mockReturnValue({ name: 'basic' }),
+    getExecutionTime: vi.fn().mockResolvedValue(100),
+    extractDatasetName: vi.fn()
+}));
+describe('workflow dataset generate command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        delete process.env.OUTPUT_CATALOG_ID;
+    });
+    describe('command definition', () => {
+        it('binds the catalog flag to OUTPUT_CATALOG_ID', async () => {
+            const DatasetGenerate = (await import('./generate.js')).default;
+            expect(DatasetGenerate.flags).toHaveProperty('catalog');
+            expect(DatasetGenerate.flags.catalog.env).toBe('OUTPUT_CATALOG_ID');
+            expect(DatasetGenerate.flags.catalog.char).toBe('c');
+        });
+    });
+    describe('run()', () => {
+        const createCommand = async (flagOverrides = {}) => {
+            const DatasetGenerate = (await import('./generate.js')).default;
+            const { postWorkflowRun } = await import('#api/generated/api.js');
+            const { resolveScenarioPath } = await import('#utils/scenario_resolver.js');
+            const { parseInputFlag } = await import('#utils/input_parser.js');
+            const cmd = new DatasetGenerate(['my_workflow'], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn(() => {
+                throw new Error('error called');
+            });
+            cmd.parse = vi.fn().mockResolvedValue({
+                args: { workflowName: 'my_workflow', scenario: 'basic' },
+                flags: { catalog: undefined, trace: undefined, name: undefined, download: false, limit: 5, input: undefined, ...flagOverrides }
+            });
+            return {
+                cmd,
+                postWorkflowRun: vi.mocked(postWorkflowRun),
+                resolveScenarioPath: vi.mocked(resolveScenarioPath),
+                parseInputFlag: vi.mocked(parseInputFlag)
+            };
+        };
+        it('resolves the scenario and runs the workflow against the resolved catalog', async () => {
+            const { cmd, postWorkflowRun, resolveScenarioPath, parseInputFlag } = await createCommand({ catalog: 'my-catalog' });
+            resolveScenarioPath.mockResolvedValue({ found: true, path: '/scenarios/basic.json', searchedPaths: [] });
+            parseInputFlag.mockResolvedValue({ foo: 'bar' });
+            postWorkflowRun.mockResolvedValue({
+                data: { workflowId: 'wf-1', output: { ok: true } },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(resolveScenarioPath).toHaveBeenCalledWith('my_workflow', 'basic', undefined, undefined, 'my-catalog');
+            expect(postWorkflowRun).toHaveBeenCalledWith(expect.objectContaining({ workflowName: 'my_workflow', catalog: 'my-catalog' }), expect.anything());
+        });
+    });
+});

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

@@ -4,8 +4,8 @@ import Generate from './generate.js';
 import { generateWorkflow } from '#services/workflow_generator.js';
 import { parseWorkflowDir } from '#utils/workflow_dir_parser.js';
 import { InvalidNameError, WorkflowExistsError } from '#types/errors.js';
-vi.mock('../../services/workflow_generator.js');
-vi.mock('../../utils/workflow_dir_parser.js');
+vi.mock('#services/workflow_generator.js');
+vi.mock('#utils/workflow_dir_parser.js');
 describe('Generate Command', () => {
     let mockGenerateWorkflow;
     let mockParseWorkflowDir;

package/dist/commands/workflow/run.js

@@ -63,7 +63,7 @@ export default class WorkflowRun extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(WorkflowRun);
-        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'run');
+        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'run', flags.catalog);
         this.log(`Executing workflow: ${args.workflowName}...`);
         const response = await executeWorkflow({
             body: {

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

@@ -64,11 +64,28 @@ describe('workflow run command', () => {
                 headers: new Headers()
             });
             await cmd.run();
+            expect(resolveInput).toHaveBeenCalledWith('my_workflow', undefined, undefined, 'run', undefined);
             expect(postWorkflowRun).toHaveBeenCalledTimes(1);
             expect(postWorkflowRun).toHaveBeenCalledWith({ workflowName: 'my_workflow', input: { key: 'value' }, catalog: undefined }, expect.objectContaining({ config: { timeout: 600000 } }));
             expect(cmd.log).toHaveBeenCalledWith('Executing workflow: my_workflow...');
             expect(cmd.log).toHaveBeenCalledWith(expect.stringMatching(/\n/));
         });
+        it('threads the resolved catalog to resolveInput and postWorkflowRun', async () => {
+            const { cmd, postWorkflowRun, resolveInput } = await createCommand();
+            cmd.parse = vi.fn().mockResolvedValue({
+                args: { workflowName: 'my_workflow', scenario: 'basic' },
+                flags: { input: undefined, catalog: 'my-catalog', format: 'text' }
+            });
+            resolveInput.mockResolvedValue({ key: 'value' });
+            postWorkflowRun.mockResolvedValue({
+                data: { status: 'completed', result: {} },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(resolveInput).toHaveBeenCalledWith('my_workflow', 'basic', undefined, 'run', 'my-catalog');
+            expect(postWorkflowRun).toHaveBeenCalledWith(expect.objectContaining({ catalog: 'my-catalog' }), expect.anything());
+        });
         it('retries when response has Retry-After and succeeds on second attempt', async () => {
             const { cmd, postWorkflowRun, resolveInput } = await createCommand();
             resolveInput.mockResolvedValue({});

package/dist/commands/workflow/start.js

@@ -37,7 +37,7 @@ export default class WorkflowStart extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(WorkflowStart);
-        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'start');
+        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'start', flags.catalog);
         this.log(`Starting workflow: ${args.workflowName}...`);
         const response = await postWorkflowStart({
             workflowName: args.workflowName,

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

@@ -1,11 +1,17 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../../api/generated/api.js', () => ({
+vi.mock('#api/generated/api.js', () => ({
     postWorkflowStart: vi.fn()
 }));
+vi.mock('#utils/resolve_input.js', () => ({
+    resolveInput: vi.fn()
+}));
 describe('workflow start command', () => {
-    beforeEach(() => {
+    beforeEach(async () => {
         vi.clearAllMocks();
         delete process.env.OUTPUT_CATALOG_ID;
+        const { resolveInput } = await import('#utils/resolve_input.js');
+        vi.mocked(resolveInput).mockResolvedValue({});
     });
     describe('command definition', () => {
         it('should export a valid OCLIF command', async () => {
@@ -25,5 +31,50 @@ describe('workflow start command', () => {
             expect(WorkflowStart.args).toHaveProperty('scenario');
             expect(WorkflowStart.args.scenario.required).toBe(false);
         });
+        it('binds the catalog flag to OUTPUT_CATALOG_ID', async () => {
+            const WorkflowStart = (await import('./start.js')).default;
+            expect(WorkflowStart.flags.catalog.env).toBe('OUTPUT_CATALOG_ID');
+            expect(WorkflowStart.flags.catalog.char).toBe('c');
+        });
+    });
+    describe('run()', () => {
+        const createCommand = async (flagOverrides = {}) => {
+            const WorkflowStart = (await import('./start.js')).default;
+            const { postWorkflowStart } = await import('#api/generated/api.js');
+            const { resolveInput } = await import('#utils/resolve_input.js');
+            const cmd = new WorkflowStart(['my_workflow'], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn(() => {
+                throw new Error('error called');
+            });
+            cmd.parse = vi.fn().mockResolvedValue({
+                args: { workflowName: 'my_workflow', scenario: undefined },
+                flags: { input: undefined, catalog: undefined, ...flagOverrides }
+            });
+            return { cmd, postWorkflowStart: vi.mocked(postWorkflowStart), resolveInput: vi.mocked(resolveInput) };
+        };
+        it('threads the resolved catalog to resolveInput and postWorkflowStart', async () => {
+            const { cmd, postWorkflowStart, resolveInput } = await createCommand({ catalog: 'my-catalog' });
+            resolveInput.mockResolvedValue({ key: 'value' });
+            postWorkflowStart.mockResolvedValue({
+                data: { workflowId: 'wf-123' },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(resolveInput).toHaveBeenCalledWith('my_workflow', undefined, undefined, 'start', 'my-catalog');
+            expect(postWorkflowStart).toHaveBeenCalledWith(expect.objectContaining({ workflowName: 'my_workflow', catalog: 'my-catalog' }));
+        });
+        it('passes undefined catalog through when none is set', async () => {
+            const { cmd, postWorkflowStart, resolveInput } = await createCommand();
+            resolveInput.mockResolvedValue({});
+            postWorkflowStart.mockResolvedValue({
+                data: { workflowId: 'wf-123' },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(resolveInput).toHaveBeenCalledWith('my_workflow', undefined, undefined, 'start', undefined);
+        });
     });
 });

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

@@ -9,6 +9,7 @@ export default class WorkflowTest extends Command {
         workflowName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
+        catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         cached: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         save: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         dataset: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/workflow/test_eval.js

@@ -24,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,
@@ -43,7 +51,7 @@ export default class WorkflowTest extends Command {
         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` +
@@ -51,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 }
         });
@@ -73,9 +82,9 @@ export default class WorkflowTest extends Command {
         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 });
         }
     }
@@ -88,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) {
@@ -96,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.js

@@ -4,10 +4,16 @@ 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 }
@@ -23,10 +29,16 @@ describe('workflow test command', () => {
         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;
@@ -36,6 +48,12 @@ describe('workflow test command', () => {
             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) => {
@@ -80,5 +98,24 @@ describe('workflow test command', () => {
             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.42a0ddf.0"
+    "framework": "0.8.2-next.7929835.0"
 }

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/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/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/oclif.manifest.json

@@ -1164,6 +1164,22 @@
           "allowNo": false,
           "type": "boolean"
         },
+        "catalog": {
+          "aliases": [
+            "task-queue"
+          ],
+          "char": "c",
+          "charAliases": [
+            "q"
+          ],
+          "deprecateAliases": true,
+          "description": "Catalog name for workflow execution (defaults to OUTPUT_CATALOG_ID)",
+          "env": "OUTPUT_CATALOG_ID",
+          "name": "catalog",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "cached": {
           "description": "Use cached output from dataset files (skip workflow execution)",
           "exclusive": [
@@ -1228,6 +1244,22 @@
         "<%= config.bin %> <%= command.id %> simple --download --limit 5"
       ],
       "flags": {
+        "catalog": {
+          "aliases": [
+            "task-queue"
+          ],
+          "char": "c",
+          "charAliases": [
+            "q"
+          ],
+          "deprecateAliases": true,
+          "description": "Catalog name for workflow execution (defaults to OUTPUT_CATALOG_ID)",
+          "env": "OUTPUT_CATALOG_ID",
+          "name": "catalog",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "trace": {
           "char": "t",
           "description": "Path to a local trace file to extract dataset from",
@@ -1422,5 +1454,5 @@
       ]
     }
   },
-  "version": "0.8.2-next.42a0ddf.0"
+  "version": "0.8.2-next.7929835.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.8.2-next.42a0ddf.0",
+  "version": "0.8.2-next.7929835.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -34,11 +34,11 @@
     "ky": "1.14.3",
     "react": "19.2.5",
     "semver": "7.7.4",
-    "undici": "8.1.0",
+    "undici": "8.5.0",
     "yaml": "^2.8.3",
-    "@outputai/credentials": "0.8.2-next.42a0ddf.0",
-    "@outputai/evals": "0.8.2-next.42a0ddf.0",
-    "@outputai/llm": "0.8.2-next.42a0ddf.0"
+    "@outputai/evals": "0.8.2-next.7929835.0",
+    "@outputai/llm": "0.8.2-next.7929835.0",
+    "@outputai/credentials": "0.8.2-next.7929835.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",