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

package/dist/api/generated/api.d.ts

@@ -452,6 +452,26 @@ export type GetWorkflowIdRunsRidHistory200 = {
     /** @nullable */
     nextPageToken?: string | null;
 };
+export type GetWorkflowIdHistoryStreamParams = {
+    /**
+     * Include decoded input/output payloads in events
+     */
+    includePayloads?: boolean;
+    /**
+     * Resume from this event ID (alternative to Last-Event-ID header)
+     */
+    lastEventId?: number;
+};
+export type GetWorkflowIdRunsRidHistoryStreamParams = {
+    /**
+     * Include decoded input/output payloads in events
+     */
+    includePayloads?: boolean;
+    /**
+     * Resume from this event ID (alternative to Last-Event-ID header)
+     */
+    lastEventId?: number;
+};
 export type GetWorkflowCatalogId200 = {
     /** Each workflow available in this catalog */
     workflows?: Workflow[];
@@ -1043,6 +1063,65 @@ export type getWorkflowIdRunsRidHistoryResponseError = (getWorkflowIdRunsRidHist
 export type getWorkflowIdRunsRidHistoryResponse = (getWorkflowIdRunsRidHistoryResponseSuccess | getWorkflowIdRunsRidHistoryResponseError);
 export declare const getGetWorkflowIdRunsRidHistoryUrl: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryParams) => string;
 export declare const getWorkflowIdRunsRidHistory: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryParams, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidHistoryResponse>;
+/**
+ * Opens a persistent SSE connection that delivers Temporal workflow history events in real time. Emits named events: `workflow` (metadata, once), `history` (event batches), `done` (terminal state), `server_error` (post-flush errors). The `done` event carries `{ reason, newRunId? }` where `reason` is the terminal Temporal event type (`WORKFLOW_EXECUTION_COMPLETED`, `WORKFLOW_EXECUTION_FAILED`, `WORKFLOW_EXECUTION_TIMED_OUT`, `WORKFLOW_EXECUTION_CANCELED`, `WORKFLOW_EXECUTION_TERMINATED`, `WORKFLOW_EXECUTION_CONTINUED_AS_NEW`) and `newRunId` is present only when the terminal event chains a follow-on run. `server_error` carries `{ error, message, workflowId, runId }`. Errors before the stream opens are returned as JSON HTTP responses (400/404); once open, failures arrive as a `server_error` event. Supports reconnect via `Last-Event-ID` header or `lastEventId` query param.
+
+ * @summary Stream workflow history events via Server-Sent Events
+ */
+export type getWorkflowIdHistoryStreamResponse200 = {
+    data: string;
+    status: 200;
+};
+export type getWorkflowIdHistoryStreamResponse400 = {
+    data: BadRequestResponse;
+    status: 400;
+};
+export type getWorkflowIdHistoryStreamResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdHistoryStreamResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdHistoryStreamResponseSuccess = (getWorkflowIdHistoryStreamResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdHistoryStreamResponseError = (getWorkflowIdHistoryStreamResponse400 | getWorkflowIdHistoryStreamResponse404 | getWorkflowIdHistoryStreamResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdHistoryStreamResponse = (getWorkflowIdHistoryStreamResponseSuccess | getWorkflowIdHistoryStreamResponseError);
+export declare const getGetWorkflowIdHistoryStreamUrl: (id: string, params?: GetWorkflowIdHistoryStreamParams) => string;
+export declare const getWorkflowIdHistoryStream: (id: string, params?: GetWorkflowIdHistoryStreamParams, options?: ApiRequestOptions) => Promise<getWorkflowIdHistoryStreamResponse>;
+/**
+ * Same as /workflow/{id}/history/stream but targets a specific run ID.
+ * @summary Stream pinned-run workflow history events via Server-Sent Events
+ */
+export type getWorkflowIdRunsRidHistoryStreamResponse200 = {
+    data: string;
+    status: 200;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse400 = {
+    data: BadRequestResponse;
+    status: 400;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponseSuccess = (getWorkflowIdRunsRidHistoryStreamResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponseError = (getWorkflowIdRunsRidHistoryStreamResponse400 | getWorkflowIdRunsRidHistoryStreamResponse404 | getWorkflowIdRunsRidHistoryStreamResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse = (getWorkflowIdRunsRidHistoryStreamResponseSuccess | getWorkflowIdRunsRidHistoryStreamResponseError);
+export declare const getGetWorkflowIdRunsRidHistoryStreamUrl: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryStreamParams) => string;
+export declare const getWorkflowIdRunsRidHistoryStream: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryStreamParams, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidHistoryStreamResponse>;
 /**
  * @summary Get a specific workflow catalog by ID
  */

package/dist/api/generated/api.js

@@ -231,6 +231,38 @@ export const getWorkflowIdRunsRidHistory = async (id, rid, params, options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowIdHistoryStreamUrl = (id, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/workflow/${id}/history/stream?${stringifiedParams}` : `/workflow/${id}/history/stream`;
+};
+export const getWorkflowIdHistoryStream = async (id, params, options) => {
+    return customFetchInstance(getGetWorkflowIdHistoryStreamUrl(id, params), {
+        ...options,
+        method: 'GET'
+    });
+};
+export const getGetWorkflowIdRunsRidHistoryStreamUrl = (id, rid, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/workflow/${id}/runs/${rid}/history/stream?${stringifiedParams}` : `/workflow/${id}/runs/${rid}/history/stream`;
+};
+export const getWorkflowIdRunsRidHistoryStream = async (id, rid, params, options) => {
+    return customFetchInstance(getGetWorkflowIdRunsRidHistoryStreamUrl(id, rid, params), {
+        ...options,
+        method: 'GET'
+    });
+};
 export const getGetWorkflowCatalogIdUrl = (id) => {
     return `/workflow/catalog/${id}`;
 };

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.c12766f.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.8.2-next.e658cc2.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.c12766f.0"
+    "framework": "0.8.2-next.e658cc2.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/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 {};

package/dist/views/dev/modals/run_modal.js

@@ -9,26 +9,40 @@ import { startWorkflow } from '#views/dev/services/run_workflow.js';
 import { readScenario, writeScenario } from '#views/dev/services/scenario_io.js';
 import { JsonEditor } from '#views/dev/utils/json_editor.js';
 import { ModalFrame } from '#views/dev/modals/modal_frame.js';
-const CUSTOM_SEED = { '': '' };
 const SCENARIO_NAME_RE = /^[a-zA-Z0-9_-]+$/;
-const buildEntries = (scenarios) => {
+// Seed for a brand-new input — an empty "": "" pair reads friendlier than a bare {}.
+const CUSTOM_SEED = { '': '' };
+export const buildEntries = (scenarios) => {
     const list = scenarios.map(s => ({
         kind: 'scenario',
         label: s,
         scenarioName: s
     }));
-    list.push({ kind: 'custom', label: '[Create new scenario]' });
+    list.push({ kind: 'custom', label: '[Enter input]' });
     return list;
 };
+export const validateScenarioName = (raw, existing) => {
+    const name = raw.trim();
+    if (!name) {
+        return 'Scenario name cannot be empty.';
+    }
+    if (!SCENARIO_NAME_RE.test(name)) {
+        return 'Use letters, numbers, dashes, and underscores only.';
+    }
+    if (existing.includes(name)) {
+        return `A scenario named '${name}' already exists.`;
+    }
+    return null;
+};
 const SELECT_SHORTCUTS = [
     ['↑/↓', 'navigate'],
     ['enter', 'run'],
     ['d', 'duplicate'],
     ['esc', 'cancel']
 ];
-const NAME_SHORTCUTS = [
-    ['enter', 'next'],
-    ['esc', 'back']
+const SAVE_SHORTCUTS = [
+    ['enter', 'save & run'],
+    ['esc', 'back to editor']
 ];
 const ERROR_SHORTCUTS = [
     { key: 'enter', label: 'return' },
@@ -41,9 +55,11 @@ export const RunModal = ({ workflowName, workflowPath }) => {
     const entries = useMemo(() => buildEntries(scenarios), [scenarios]);
     const [mode, setMode] = useState('select');
     const [index, setIndex] = useState(0);
-    const [editName, setEditName] = useState('');
-    const [editSeed, setEditSeed] = useState(CUSTOM_SEED);
+    const [editSeed, setEditSeed] = useState({});
     const [editFrameTitle, setEditFrameTitle] = useState('');
+    const [defaultSaveName, setDefaultSaveName] = useState('');
+    const [editName, setEditName] = useState('');
+    const [pendingValue, setPendingValue] = useState(null);
     const [nameError, setNameError] = useState(null);
     const [errorMessage, setErrorMessage] = useState(null);
     const closeWith = (message, tone = 'info') => {
@@ -76,63 +92,55 @@ export const RunModal = ({ workflowName, workflowPath }) => {
             setMode('error');
         }
     };
+    // Custom + duplicate both open the editor first; saving a scenario is opt-in (ctrl+s).
+    const startCustom = () => {
+        setEditSeed(CUSTOM_SEED);
+        setDefaultSaveName('');
+        setEditFrameTitle('Enter input');
+        setMode('edit_content');
+    };
     const startDuplicate = async (scenarioName) => {
         try {
             const sourceContent = await readScenario(workflowName, scenarioName, workflowPath);
-            setEditName(`${scenarioName}_copy`);
             setEditSeed(sourceContent);
+            setDefaultSaveName(`${scenarioName}_copy`);
             setEditFrameTitle(`Duplicate '${scenarioName}'`);
-            setNameError(null);
-            setMode('edit_name');
+            setMode('edit_content');
         }
         catch (err) {
             setErrorMessage(err instanceof Error ? err.message : String(err));
             setMode('error');
         }
     };
-    const startCustom = () => {
-        setEditName('');
-        setEditSeed(CUSTOM_SEED);
-        setEditFrameTitle('New scenario');
-        setNameError(null);
-        setMode('edit_name');
+    // ctrl+r in the editor: run the payload as-is, nothing written to disk.
+    const runEphemeral = (value) => {
+        void submit(value, defaultSaveName || 'input');
     };
-    const validateName = (raw) => {
-        const name = raw.trim();
-        if (!name) {
-            return 'Scenario name cannot be empty.';
-        }
-        if (!SCENARIO_NAME_RE.test(name)) {
-            return 'Use letters, numbers, dashes, and underscores only.';
-        }
-        if (scenarios.includes(name)) {
-            return `A scenario named '${name}' already exists.`;
-        }
-        return null;
+    // ctrl+s in the editor: keep the payload and ask for a name before saving + running.
+    const beginSave = (value) => {
+        setPendingValue(value);
+        setEditSeed(value);
+        setEditName(defaultSaveName);
+        setNameError(null);
+        setMode('name_for_save');
     };
-    const handleEditorSubmit = async (value) => {
-        const name = editName.trim();
-        const writeError = validateName(editName);
-        if (writeError) {
-            setNameError(writeError);
-            setMode('edit_name');
+    const confirmSave = async () => {
+        const validationError = validateScenarioName(editName, scenarios);
+        if (validationError) {
+            setNameError(validationError);
             return;
         }
         setMode('submitting');
         try {
-            const writtenPath = await writeScenario(workflowName, name, value, workflowPath);
+            const writtenPath = await writeScenario(workflowName, editName.trim(), pendingValue, workflowPath);
             ui.pushToast(`Saved scenario at ${writtenPath}`, 'info');
-            await submit(value, name);
+            await submit(pendingValue, editName.trim());
         }
         catch (err) {
             setErrorMessage(err instanceof Error ? err.message : String(err));
             setMode('error');
         }
     };
-    const handleEditorCancel = () => {
-        // Bring the user back to the name step so they can adjust it or bail.
-        setMode('edit_name');
-    };
     useInput((input, key) => {
         if (mode === 'edit_content' || mode === 'submitting') {
             return;
@@ -168,19 +176,13 @@ export const RunModal = ({ workflowName, workflowPath }) => {
             }
             return;
         }
-        if (mode === 'edit_name') {
+        if (mode === 'name_for_save') {
             if (key.escape) {
-                setMode('select');
+                setMode('edit_content');
                 return;
             }
             if (key.return) {
-                const err = validateName(editName);
-                if (err) {
-                    setNameError(err);
-                    return;
-                }
-                setNameError(null);
-                setMode('edit_content');
+                void confirmSave();
                 return;
             }
             if (key.backspace || key.delete) {
@@ -206,12 +208,10 @@ export const RunModal = ({ workflowName, workflowPath }) => {
         }
     });
     if (mode === 'edit_content') {
-        return (_jsx(ModalFrame, { title: editFrameTitle, children: _jsx(JsonEditor, { seed: editSeed, title: `${editName}.json`, isActive: true, onSubmit: value => {
-                    void handleEditorSubmit(value);
-                }, onCancel: handleEditorCancel }) }));
+        return (_jsx(ModalFrame, { title: editFrameTitle, children: _jsx(JsonEditor, { seed: editSeed, title: defaultSaveName ? `${defaultSaveName}.json` : 'input', isActive: true, onSubmit: runEphemeral, onSave: beginSave, onCancel: () => setMode('select') }) }));
     }
-    if (mode === 'edit_name') {
-        return (_jsxs(ModalFrame, { title: editFrameTitle, shortcuts: NAME_SHORTCUTS, children: [_jsx(TextPrompt, { label: "Scenario name:", value: editName }), nameError ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "red", children: nameError }) })) : null] }));
+    if (mode === 'name_for_save') {
+        return (_jsxs(ModalFrame, { title: "Save & run", shortcuts: SAVE_SHORTCUTS, children: [_jsx(TextPrompt, { label: "Scenario name:", value: editName }), nameError ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "red", children: nameError }) })) : null] }));
     }
     if (mode === 'submitting') {
         return (_jsxs(ModalFrame, { title: `Run ${workflowName}`, children: [_jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: "\u00A0Starting workflow\u2026" })] }));
@@ -219,5 +219,5 @@ export const RunModal = ({ workflowName, workflowPath }) => {
     if (mode === 'error') {
         return (_jsx(ModalFrame, { title: `Run workflow "${workflowName}"`, shortcuts: ERROR_SHORTCUTS, children: _jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", errorMessage ?? 'Something went wrong.'] }) }));
     }
-    return (_jsx(ModalFrame, { title: `Run ${workflowName}`, shortcuts: SELECT_SHORTCUTS, children: _jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { dimColor: true, children: scenarios.length === 0 ? 'No scenarios found. Create a new one:' : 'Select scenarios:' }), _jsx(Box, { flexDirection: "column", children: entries.map((entry, i) => (_jsxs(Box, { children: [_jsx(SelectionIndicator, { selected: i === index }), _jsxs(Text, { bold: i === index, children: ["\u00A0", entry.label] })] }, `${entry.kind}-${entry.scenarioName ?? i}`))) })] }) }));
+    return (_jsx(ModalFrame, { title: `Run ${workflowName}`, shortcuts: SELECT_SHORTCUTS, children: _jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { dimColor: true, children: scenarios.length === 0 ? 'No saved scenarios. Enter input to run:' : 'Select a scenario:' }), _jsx(Box, { flexDirection: "column", children: entries.map((entry, i) => (_jsxs(Box, { children: [_jsx(SelectionIndicator, { selected: i === index }), _jsxs(Text, { bold: i === index, children: ["\u00A0", entry.label] })] }, `${entry.kind}-${entry.scenarioName ?? i}`))) })] }) }));
 };

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

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

package/dist/views/dev/modals/run_modal.spec.js

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { buildEntries, validateScenarioName } from './run_modal.js';
+describe('buildEntries', () => {
+    it('lists scenarios then the custom-JSON entry', () => {
+        const entries = buildEntries(['basic', 'edge']);
+        expect(entries.map(e => e.label)).toEqual(['basic', 'edge', '[Enter input]']);
+        expect(entries[0]).toMatchObject({ kind: 'scenario', scenarioName: 'basic' });
+        expect(entries.at(-1)).toMatchObject({ kind: 'custom' });
+    });
+    it('offers the custom entry even with no saved scenarios', () => {
+        const entries = buildEntries([]);
+        expect(entries).toHaveLength(1);
+        expect(entries[0].kind).toBe('custom');
+    });
+});
+describe('validateScenarioName', () => {
+    it('rejects empty or whitespace-only names', () => {
+        expect(validateScenarioName('', [])).toMatch(/cannot be empty/);
+        expect(validateScenarioName('   ', [])).toMatch(/cannot be empty/);
+    });
+    it('rejects names with unsupported characters', () => {
+        expect(validateScenarioName('has space', [])).toMatch(/letters, numbers/);
+        expect(validateScenarioName('bad/name', [])).toMatch(/letters, numbers/);
+    });
+    it('rejects names that already exist', () => {
+        expect(validateScenarioName('basic', ['basic'])).toMatch(/already exists/);
+    });
+    it('trims before checking for duplicates', () => {
+        expect(validateScenarioName('  basic  ', ['basic'])).toMatch(/already exists/);
+    });
+    it('accepts a unique name with allowed characters', () => {
+        expect(validateScenarioName('edge_case-1', ['basic'])).toBeNull();
+    });
+});

package/dist/views/dev/panels/help_panel.js

@@ -10,7 +10,7 @@ const DOCS_URL = 'https://docs.output.ai';
 export const Section = ({ children, title, direction = 'v' }) => (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { bold: true, children: title }), _jsx(Box, { flexDirection: direction === 'v' ? 'column' : 'row', gap: 1, flexWrap: 'wrap', children: children })] }));
 export const SubSection = ({ children, title }) => (_jsxs(Box, { flexDirection: "column", gap: 1, borderStyle: "single", borderColor: "blackBright", paddingLeft: 1, paddingRight: 1, children: [_jsx(Text, { italic: true, dimColor: true, children: title }), _jsx(Box, { flexDirection: "column", children: children })] }));
 const KV = ({ label, value }) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: 26, children: _jsx(Text, { children: label }) }), _jsx(Text, { bold: true, children: value })] }));
-const RunFromCli = () => (_jsxs(Section, { title: "Running a workflow", children: [_jsxs(SubSection, { title: "From the CLI", children: [_jsx(InlineSnippet, { content: "npx output workflow run blog_evaluator paulgraham_hwh" }), _jsx(InlineSnippet, { content: 'npx output workflow run simple --input {"values":[1,2,3]}' }), _jsx(InlineSnippet, { content: "npx output workflow run simple --input scenario.json" })] }), _jsxs(SubSection, { title: "From the TUI", children: [_jsxs(Text, { children: ["Open Workflows tab, hover a workflow, press ", _jsx(Text, { bold: true, children: "r" }), "."] }), _jsx(Text, { children: "Create a custom input from the TUI using the editor with live JSON validation or select an existing scenario." })] })] }));
+const RunFromCli = () => (_jsxs(Section, { title: "Running a workflow", children: [_jsxs(SubSection, { title: "From the CLI", children: [_jsx(InlineSnippet, { content: "npx output workflow run blog_evaluator paulgraham_hwh" }), _jsx(InlineSnippet, { content: 'npx output workflow run simple --input {"values":[1,2,3]}' }), _jsx(InlineSnippet, { content: "npx output workflow run simple --input scenario.json" })] }), _jsxs(SubSection, { title: "From the TUI", children: [_jsxs(Text, { children: ["Open Workflows tab, hover a workflow, press ", _jsx(Text, { bold: true, children: "r" }), "."] }), _jsx(Text, { children: "Pick a saved scenario, or edit JSON with live validation." }), _jsxs(Text, { children: ["Press ", _jsx(Text, { bold: true, children: "ctrl+r" }), " to run as-is, or ", _jsx(Text, { bold: true, children: "ctrl+s" }), " to save it as a scenario first."] })] })] }));
 const ServiceUrls = () => (_jsx(Section, { title: "Service URLs", children: _jsxs(SubSection, { title: "Where the services are available", children: [_jsx(KV, { label: "Temporal gRPC", value: "localhost:7233" }), _jsx(KV, { label: "Temporal UI", value: "http://localhost:8080" }), _jsx(KV, { label: "API server", value: "localhost:3001" }), _jsx(KV, { label: "Redis", value: "localhost:6379" })] }) }));
 const UpdatingMigrating = () => (_jsxs(Section, { title: "Updating / Migrating", children: [_jsxs(SubSection, { title: "Update", children: [_jsx(Text, { wrap: "wrap", children: "Update the CLI to the latest published version:" }), _jsx(InlineSnippet, { content: "output update" })] }), _jsxs(SubSection, { title: "Migrate", children: [_jsx(Text, { wrap: "wrap", children: "Migrate a workflow project to the SDK version this CLI ships with:" }), _jsx(InlineSnippet, { content: "output migrate" }), _jsx(Text, { wrap: "wrap", children: "The migration walks `package.json` and project files, updates `@outputai/*` deps, and applies any code-mod steps the SDK ships with the new version." })] })] }));
 const ClaudePlugins = () => (_jsx(Section, { title: "Claude Plugins", children: _jsxs(SubSection, { title: "Reinstall", children: [_jsx(Text, { wrap: "wrap", children: "Command `output init` already installs the Claude Code plugins (skills, commands, agents) into your project during scaffolding." }), _jsx(Text, { wrap: "wrap", children: "But if it is necessary to reinstall it, use the update command:" }), _jsx(InlineSnippet, { content: "output update --agents" }), _jsx(Text, { children: "This pulls the latest plugin bundle that ships with the installed CLI version." })] }) }));

package/dist/views/dev/utils/json_editor.d.ts

@@ -11,11 +11,13 @@ export declare const tryParseJson: (text: string) => {
     ok: false;
     error: string;
 };
+export declare const initialCursor: (buffer: string) => number;
 export declare const JsonEditor: React.FC<{
     seed: unknown;
     title: string;
     isActive?: boolean;
     onSubmit: (value: unknown) => void;
+    onSave?: (value: unknown) => void;
     onCancel: () => void;
 }>;
 export {};

package/dist/views/dev/utils/json_editor.js

@@ -25,11 +25,17 @@ export const tryParseJson = (text) => {
         return { ok: false, error: err instanceof Error ? err.message : String(err) };
     }
 };
+// Start the cursor inside the first empty "" pair (e.g. the key of a fresh `{ "": "" }`
+// seed) so the user can type immediately; otherwise sit at the end of the buffer.
+export const initialCursor = (buffer) => {
+    const emptyPair = buffer.indexOf('""');
+    return emptyPair === -1 ? buffer.length : emptyPair + 1;
+};
 const VISIBLE_BUFFER = 6;
-export const JsonEditor = ({ seed, title, isActive = true, onSubmit, onCancel }) => {
+export const JsonEditor = ({ seed, title, isActive = true, onSubmit, onSave, onCancel }) => {
     const initial = JSON.stringify(seed ?? {}, null, 2);
     const [buffer, setBuffer] = useState(initial);
-    const [cursor, setCursor] = useState(initial.length);
+    const [cursor, setCursor] = useState(() => initialCursor(initial));
     const [status, setStatus] = useState(() => tryParseJson(initial));
     const [submitMessage, setSubmitMessage] = useState(null);
     useEffect(() => {
@@ -46,23 +52,30 @@ export const JsonEditor = ({ seed, title, isActive = true, onSubmit, onCancel })
         setBuffer(b => b.slice(0, cursor - 1) + b.slice(cursor));
         setCursor(c => Math.max(0, c - 1));
     };
+    const commit = (handler) => {
+        const parsed = tryParseJson(buffer);
+        if (!parsed.ok) {
+            setSubmitMessage(`Invalid JSON — ${parsed.error}`);
+            return;
+        }
+        try {
+            handler(JSON.parse(buffer));
+        }
+        catch (err) {
+            setSubmitMessage(err instanceof Error ? err.message : String(err));
+        }
+    };
     useInput((input, key) => {
         if (key.escape) {
             onCancel();
             return;
         }
-        if (key.ctrl && input === 's') {
-            const parsed = tryParseJson(buffer);
-            if (!parsed.ok) {
-                setSubmitMessage(`Cannot submit — ${parsed.error}`);
-                return;
-            }
-            try {
-                onSubmit(JSON.parse(buffer));
-            }
-            catch (err) {
-                setSubmitMessage(err instanceof Error ? err.message : String(err));
-            }
+        if (key.ctrl && input === 'r') {
+            commit(onSubmit);
+            return;
+        }
+        if (key.ctrl && input === 's' && onSave) {
+            commit(onSave);
             return;
         }
         if (key.return) {
@@ -113,5 +126,5 @@ export const JsonEditor = ({ seed, title, isActive = true, onSubmit, onCancel })
                     const at = line[cursorPos.col] ?? ' ';
                     const after = line.slice(cursorPos.col + 1);
                     return (_jsxs(Text, { bold: true, children: [_jsx(Text, { children: before }), _jsx(Text, { inverse: true, children: at }), _jsx(Text, { children: after })] }, lineIdx));
-                }) }), !status.ok && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "red", wrap: "truncate-end", children: status.error }) })), submitMessage && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "yellow", children: submitMessage }) })), _jsxs(Box, { marginTop: 1, columnGap: 2, children: [_jsxs(Box, { columnGap: 1, children: [_jsx(Text, { bold: true, children: "ctrl+s" }), _jsx(Text, { dimColor: true, children: "submit" })] }), _jsxs(Box, { columnGap: 1, children: [_jsx(Text, { bold: true, children: "esc" }), _jsx(Text, { dimColor: true, children: "cancel" })] }), _jsxs(Box, { columnGap: 1, children: [_jsx(Text, { bold: true, children: "\u2191\u2193\u2190\u2192" }), _jsx(Text, { dimColor: true, children: "move" })] }), _jsxs(Box, { columnGap: 1, children: [_jsx(Text, { bold: true, children: "tab" }), _jsx(Text, { dimColor: true, children: "indent" })] })] })] }));
+                }) }), !status.ok && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "red", wrap: "truncate-end", children: status.error }) })), submitMessage && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "yellow", children: submitMessage }) })), _jsxs(Box, { marginTop: 1, columnGap: 2, children: [_jsxs(Box, { columnGap: 1, children: [_jsx(Text, { bold: true, children: "ctrl+r" }), _jsx(Text, { dimColor: true, children: "run" })] }), onSave ? (_jsxs(Box, { columnGap: 1, children: [_jsx(Text, { bold: true, children: "ctrl+s" }), _jsx(Text, { dimColor: true, children: "save & run" })] })) : null, _jsxs(Box, { columnGap: 1, children: [_jsx(Text, { bold: true, children: "esc" }), _jsx(Text, { dimColor: true, children: "cancel" })] }), _jsxs(Box, { columnGap: 1, children: [_jsx(Text, { bold: true, children: "\u2191\u2193\u2190\u2192" }), _jsx(Text, { dimColor: true, children: "move" })] }), _jsxs(Box, { columnGap: 1, children: [_jsx(Text, { bold: true, children: "tab" }), _jsx(Text, { dimColor: true, children: "indent" })] })] })] }));
 };

package/dist/views/dev/utils/json_editor.spec.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { cursorToPosition, positionToCursor, tryParseJson } from './json_editor.js';
+import { cursorToPosition, initialCursor, positionToCursor, tryParseJson } from './json_editor.js';
 describe('cursorToPosition', () => {
     it('returns line 0 col 0 for an empty buffer', () => {
         expect(cursorToPosition('', 0)).toEqual({ line: 0, col: 0 });
@@ -55,3 +55,18 @@ describe('tryParseJson', () => {
         }
     });
 });
+describe('initialCursor', () => {
+    it('lands inside the first empty "" pair so typing starts there', () => {
+        const buffer = JSON.stringify({ '': '' }, null, 2); // {\n  "": ""\n}
+        const cursor = initialCursor(buffer);
+        expect(cursor).toBe(buffer.indexOf('""') + 1);
+        expect(buffer[cursor - 1]).toBe('"');
+    });
+    it('falls back to the end when there is no empty pair', () => {
+        const buffer = JSON.stringify({ values: [1, 2, 3] }, null, 2);
+        expect(initialCursor(buffer)).toBe(buffer.length);
+    });
+    it('returns 0 for an empty buffer', () => {
+        expect(initialCursor('')).toBe(0);
+    });
+});

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.c12766f.0"
+  "version": "0.8.2-next.e658cc2.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.8.2-next.c12766f.0",
+  "version": "0.8.2-next.e658cc2.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/llm": "0.8.2-next.c12766f.0",
-    "@outputai/evals": "0.8.2-next.c12766f.0",
-    "@outputai/credentials": "0.8.2-next.c12766f.0"
+    "@outputai/evals": "0.8.2-next.e658cc2.0",
+    "@outputai/llm": "0.8.2-next.e658cc2.0",
+    "@outputai/credentials": "0.8.2-next.e658cc2.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",