@outputai/cli 0.1.13-next.91c5d78.0 → 0.1.13-next.934347c.0

package/dist/api/generated/api.js

@@ -1,5 +1,5 @@
 /**
- * Generated by orval v8.6.2 🍺
+ * Generated by orval v8.8.0 🍺
  * Do not edit manually.
  * Output.ai API
  * API for managing and executing Output.ai workflows
@@ -24,11 +24,7 @@ export const WorkflowRunInfoStatus = {
     timed_out: 'timed_out',
     continued: 'continued',
 };
-export const PostWorkflowRun200Status = {
-    completed: 'completed',
-    failed: 'failed',
-};
-export const GetWorkflowIdStatus200Status = {
+export const WorkflowStatusResponseStatus = {
     canceled: 'canceled',
     completed: 'completed',
     continued_as_new: 'continued_as_new',
@@ -38,7 +34,7 @@ export const GetWorkflowIdStatus200Status = {
     timed_out: 'timed_out',
     unspecified: 'unspecified',
 };
-export const GetWorkflowIdResult200Status = {
+export const WorkflowResultResponseStatus = {
     completed: 'completed',
     failed: 'failed',
     canceled: 'canceled',
@@ -46,6 +42,10 @@ export const GetWorkflowIdResult200Status = {
     timed_out: 'timed_out',
     continued: 'continued',
 };
+export const PostWorkflowRun200Status = {
+    completed: 'completed',
+    failed: 'failed',
+};
 ;
 export const getGetHealthUrl = () => {
     return `/health`;
@@ -87,6 +87,24 @@ export const getWorkflowIdStatus = async (id, options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowIdRunsRidStatusUrl = (id, rid) => {
+    return `/workflow/${id}/runs/${rid}/status`;
+};
+export const getWorkflowIdRunsRidStatus = async (id, rid, options) => {
+    return customFetchInstance(getGetWorkflowIdRunsRidStatusUrl(id, rid), {
+        ...options,
+        method: 'GET'
+    });
+};
+export const getPatchWorkflowIdRunsRidStopUrl = (id, rid) => {
+    return `/workflow/${id}/runs/${rid}/stop`;
+};
+export const patchWorkflowIdRunsRidStop = async (id, rid, options) => {
+    return customFetchInstance(getPatchWorkflowIdRunsRidStopUrl(id, rid), {
+        ...options,
+        method: 'PATCH'
+    });
+};
 export const getPatchWorkflowIdStopUrl = (id) => {
     return `/workflow/${id}/stop`;
 };
@@ -96,6 +114,17 @@ export const patchWorkflowIdStop = async (id, options) => {
         method: 'PATCH'
     });
 };
+export const getPostWorkflowIdRunsRidTerminateUrl = (id, rid) => {
+    return `/workflow/${id}/runs/${rid}/terminate`;
+};
+export const postWorkflowIdRunsRidTerminate = async (id, rid, postWorkflowIdRunsRidTerminateBody, options) => {
+    return customFetchInstance(getPostWorkflowIdRunsRidTerminateUrl(id, rid), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(postWorkflowIdRunsRidTerminateBody)
+    });
+};
 export const getPostWorkflowIdTerminateUrl = (id) => {
     return `/workflow/${id}/terminate`;
 };
@@ -107,15 +136,26 @@ export const postWorkflowIdTerminate = async (id, postWorkflowIdTerminateBody, o
         body: JSON.stringify(postWorkflowIdTerminateBody)
     });
 };
+export const getPostWorkflowIdRunsRidResetUrl = (id, rid) => {
+    return `/workflow/${id}/runs/${rid}/reset`;
+};
+export const postWorkflowIdRunsRidReset = async (id, rid, resetWorkflowRequest, options) => {
+    return customFetchInstance(getPostWorkflowIdRunsRidResetUrl(id, rid), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(resetWorkflowRequest)
+    });
+};
 export const getPostWorkflowIdResetUrl = (id) => {
     return `/workflow/${id}/reset`;
 };
-export const postWorkflowIdReset = async (id, postWorkflowIdResetBody, options) => {
+export const postWorkflowIdReset = async (id, resetWorkflowRequest, options) => {
     return customFetchInstance(getPostWorkflowIdResetUrl(id), {
         ...options,
         method: 'POST',
         headers: { 'Content-Type': 'application/json', ...options?.headers },
-        body: JSON.stringify(postWorkflowIdResetBody)
+        body: JSON.stringify(resetWorkflowRequest)
     });
 };
 export const getGetWorkflowIdResultUrl = (id) => {
@@ -127,6 +167,15 @@ export const getWorkflowIdResult = async (id, options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowIdRunsRidResultUrl = (id, rid) => {
+    return `/workflow/${id}/runs/${rid}/result`;
+};
+export const getWorkflowIdRunsRidResult = async (id, rid, options) => {
+    return customFetchInstance(getGetWorkflowIdRunsRidResultUrl(id, rid), {
+        ...options,
+        method: 'GET'
+    });
+};
 export const getGetWorkflowIdTraceLogUrl = (id) => {
     return `/workflow/${id}/trace-log`;
 };
@@ -136,6 +185,15 @@ export const getWorkflowIdTraceLog = async (id, options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowIdRunsRidTraceLogUrl = (id, rid) => {
+    return `/workflow/${id}/runs/${rid}/trace-log`;
+};
+export const getWorkflowIdRunsRidTraceLog = async (id, rid, options) => {
+    return customFetchInstance(getGetWorkflowIdRunsRidTraceLogUrl(id, rid), {
+        ...options,
+        method: 'GET'
+    });
+};
 export const getGetWorkflowCatalogIdUrl = (id) => {
     return `/workflow/catalog/${id}`;
 };

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

@@ -81,7 +81,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.1.13-next.91c5d78.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.1.13-next.934347c.0}
     init: true
     networks:
       - main
@@ -103,7 +103,7 @@ services:
     depends_on:
       temporal:
         condition: service_healthy
-    image: node:24.13.0-slim
+    image: node:24.15.0-slim
     healthcheck:
       test: [ 'CMD-SHELL', 'npx output-healthcheck' ]
       interval: 3s

package/dist/commands/credentials/set.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class CredentialsSet extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        environment: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        workflow: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    private confirmOverwrite;
+    run(): Promise<void>;
+}

package/dist/commands/credentials/set.js

@@ -0,0 +1,125 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { confirm } from '@inquirer/prompts';
+import { load as parseYaml, dump as stringifyYaml } from 'js-yaml';
+import { getErrorMessage } from '#utils/error_utils.js';
+import { decryptCredentials, credentialsExist, writeEncrypted, resolveCredentialsPath } from '#services/credentials_service.js';
+const isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const detectPathConflict = (obj, dotPath) => {
+    const parts = dotPath.split('.');
+    const intermediateKeys = parts.slice(0, -1);
+    const leafKey = parts[parts.length - 1];
+    const walked = intermediateKeys.reduce((state, key, i) => {
+        if (state.done) {
+            return state;
+        }
+        const next = state.cursor[key];
+        if (next === undefined) {
+            return { done: true, conflict: null };
+        }
+        if (!isPlainObject(next)) {
+            return {
+                done: true,
+                conflict: {
+                    kind: 'primitive_to_object',
+                    atPath: parts.slice(0, i + 1).join('.'),
+                    existingValue: next
+                }
+            };
+        }
+        return { done: false, cursor: next };
+    }, { done: false, cursor: obj });
+    if (walked.done) {
+        return walked.conflict;
+    }
+    const leaf = walked.cursor[leafKey];
+    if (leaf !== undefined && (isPlainObject(leaf) || Array.isArray(leaf))) {
+        return { kind: 'object_to_primitive', atPath: dotPath, existingValue: leaf };
+    }
+    return null;
+};
+const setNestedValue = (obj, dotPath, value) => {
+    const parts = dotPath.split('.');
+    const parent = parts.slice(0, -1).reduce((current, key) => {
+        if (!isPlainObject(current[key])) {
+            current[key] = {};
+        }
+        return current[key];
+    }, obj);
+    parent[parts[parts.length - 1]] = value;
+};
+export default class CredentialsSet extends Command {
+    static description = 'Set a credential value by dot-notation path';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> anthropic.api_key sk-ant-...',
+        '<%= config.bin %> <%= command.id %> openai.api_key sk-... --environment production',
+        '<%= config.bin %> <%= command.id %> stripe.key sk_live_... --workflow my_workflow'
+    ];
+    static args = {
+        path: Args.string({
+            description: 'Dot-notation path to the credential (e.g. anthropic.api_key)',
+            required: true
+        }),
+        value: Args.string({
+            description: 'Value to set',
+            required: true
+        })
+    };
+    static flags = {
+        environment: Flags.string({
+            char: 'e',
+            description: 'Target environment (e.g. production, development)'
+        }),
+        workflow: Flags.string({
+            char: 'w',
+            description: 'Target a specific workflow directory'
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip confirmation prompts when overwriting a value of a different shape',
+            default: false
+        })
+    };
+    async confirmOverwrite(conflict, newPath) {
+        if (conflict.kind === 'primitive_to_object') {
+            this.warn(`Writing to "${newPath}" will convert "${conflict.atPath}" from a value into an object, ` +
+                `discarding its current value (${JSON.stringify(conflict.existingValue)}).`);
+        }
+        else {
+            this.warn(`Writing to "${newPath}" will replace the existing object at that path ` +
+                `(${JSON.stringify(conflict.existingValue)}) with a string value.`);
+        }
+        return confirm({ message: 'Continue?', default: false });
+    }
+    async run() {
+        const { args, flags } = await this.parse(CredentialsSet);
+        const environment = flags.environment;
+        const workflow = flags.workflow;
+        if (environment && workflow) {
+            this.error('Cannot specify both --environment and --workflow.');
+        }
+        if (!credentialsExist(environment, workflow)) {
+            this.error(`No credentials file found at ${resolveCredentialsPath(environment, workflow)}. Run "output credentials init" first.`);
+        }
+        try {
+            const plaintext = decryptCredentials(environment, workflow);
+            const data = (parseYaml(plaintext) || {});
+            const conflict = detectPathConflict(data, args.path);
+            if (conflict && !flags.yes) {
+                const shouldContinue = await this.confirmOverwrite(conflict, args.path);
+                if (!shouldContinue) {
+                    this.log('Aborted.');
+                    return;
+                }
+            }
+            setNestedValue(data, args.path, args.value);
+            writeEncrypted(environment, stringifyYaml(data), workflow);
+        }
+        catch (error) {
+            if (error instanceof Error && error.constructor.name === 'ExitPromptError') {
+                return;
+            }
+            this.error(`Failed to update credentials: ${getErrorMessage(error)}`);
+        }
+        this.log(`Set ${args.path}`);
+    }
+}

package/dist/commands/credentials/set.spec.d.ts

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

package/dist/commands/credentials/set.spec.js

@@ -0,0 +1,160 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { confirm } from '@inquirer/prompts';
+import * as credentialsService from '#services/credentials_service.js';
+import CredentialsSet from './set.js';
+vi.mock('#services/credentials_service.js');
+vi.mock('@inquirer/prompts', () => ({
+    confirm: vi.fn()
+}));
+vi.mock('js-yaml', () => ({
+    load: vi.fn((yaml) => {
+        if (yaml.includes('__PRIMITIVE_AT_X_Y__')) {
+            return { x: { y: 'FOO' } };
+        }
+        if (yaml.includes('__OBJECT_AT_X_Y__')) {
+            return { x: { y: { z: 'FOO' } } };
+        }
+        if (yaml.includes('sk-existing')) {
+            return { anthropic: { api_key: 'sk-existing' } };
+        }
+        return {};
+    }),
+    dump: vi.fn((obj) => JSON.stringify(obj))
+}));
+describe('credentials set command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(credentialsService.credentialsExist).mockReturnValue(true);
+        vi.mocked(credentialsService.decryptCredentials).mockReturnValue('anthropic:\n  api_key: sk-existing\n');
+        vi.mocked(credentialsService.writeEncrypted).mockImplementation(() => { });
+        vi.mocked(confirm).mockResolvedValue(true);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    const createTestCommand = (parsedArgs = {}, flags = {}) => {
+        const cmd = new CredentialsSet([], {});
+        cmd.log = vi.fn();
+        cmd.warn = vi.fn();
+        cmd.error = vi.fn((msg) => {
+            throw new Error(msg);
+        });
+        Object.defineProperty(cmd, 'parse', {
+            value: vi.fn().mockResolvedValue({
+                args: { path: 'anthropic.api_key', value: 'sk-new-key', ...parsedArgs },
+                flags: { environment: undefined, workflow: undefined, yes: false, ...flags }
+            }),
+            configurable: true
+        });
+        return cmd;
+    };
+    describe('command structure', () => {
+        it('should have correct description', () => {
+            expect(CredentialsSet.description).toContain('credential value');
+        });
+        it('should have required path and value arguments', () => {
+            expect(CredentialsSet.args.path).toBeDefined();
+            expect(CredentialsSet.args.path.required).toBe(true);
+            expect(CredentialsSet.args.value).toBeDefined();
+            expect(CredentialsSet.args.value.required).toBe(true);
+        });
+        it('should have environment, workflow, and yes flags', () => {
+            expect(CredentialsSet.flags.environment).toBeDefined();
+            expect(CredentialsSet.flags.workflow).toBeDefined();
+            expect(CredentialsSet.flags.yes).toBeDefined();
+        });
+    });
+    describe('command execution', () => {
+        it('should decrypt, update, and re-encrypt credentials', async () => {
+            const cmd = createTestCommand();
+            await cmd.run();
+            expect(credentialsService.decryptCredentials).toHaveBeenCalledWith(undefined, undefined);
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledWith(undefined, expect.any(String), undefined);
+            expect(confirm).not.toHaveBeenCalled();
+            expect(cmd.log).toHaveBeenCalledWith('Set anthropic.api_key');
+        });
+        it('should create nested keys that do not exist', async () => {
+            vi.mocked(credentialsService.decryptCredentials).mockReturnValue('');
+            const cmd = createTestCommand({ path: 'new.nested.key', value: 'my-value' });
+            await cmd.run();
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledTimes(1);
+            expect(confirm).not.toHaveBeenCalled();
+            expect(cmd.log).toHaveBeenCalledWith('Set new.nested.key');
+        });
+        it('should pass environment flag to service functions', async () => {
+            const cmd = createTestCommand({}, { environment: 'production' });
+            await cmd.run();
+            expect(credentialsService.credentialsExist).toHaveBeenCalledWith('production', undefined);
+            expect(credentialsService.decryptCredentials).toHaveBeenCalledWith('production', undefined);
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledWith('production', expect.any(String), undefined);
+        });
+        it('should pass workflow flag to service functions', async () => {
+            const cmd = createTestCommand({}, { workflow: 'my_workflow' });
+            await cmd.run();
+            expect(credentialsService.credentialsExist).toHaveBeenCalledWith(undefined, 'my_workflow');
+            expect(credentialsService.decryptCredentials).toHaveBeenCalledWith(undefined, 'my_workflow');
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledWith(undefined, expect.any(String), 'my_workflow');
+        });
+        it('should error when both environment and workflow are specified', async () => {
+            const cmd = createTestCommand({}, { environment: 'production', workflow: 'my_workflow' });
+            await expect(cmd.run()).rejects.toThrow('Cannot specify both');
+        });
+        it('should error when credentials file does not exist', async () => {
+            vi.mocked(credentialsService.credentialsExist).mockReturnValue(false);
+            vi.mocked(credentialsService.resolveCredentialsPath).mockReturnValue('/project/config/credentials.yml.enc');
+            const cmd = createTestCommand();
+            await expect(cmd.run()).rejects.toThrow('No credentials file found');
+        });
+        it('should surface a friendly error when decryption fails', async () => {
+            vi.mocked(credentialsService.decryptCredentials).mockImplementation(() => {
+                throw new Error('Invalid key');
+            });
+            const cmd = createTestCommand();
+            await expect(cmd.run()).rejects.toThrow('Failed to update credentials: Invalid key');
+        });
+        it('should surface a friendly error when encryption fails', async () => {
+            vi.mocked(credentialsService.writeEncrypted).mockImplementation(() => {
+                throw new Error('Permission denied');
+            });
+            const cmd = createTestCommand();
+            await expect(cmd.run()).rejects.toThrow('Failed to update credentials: Permission denied');
+        });
+    });
+    describe('shape-change confirmation', () => {
+        it('should prompt before converting a primitive value into an object', async () => {
+            vi.mocked(credentialsService.decryptCredentials).mockReturnValue('__PRIMITIVE_AT_X_Y__');
+            const cmd = createTestCommand({ path: 'x.y.z', value: 'BAR' });
+            await cmd.run();
+            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('convert "x.y" from a value into an object'));
+            expect(confirm).toHaveBeenCalledTimes(1);
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledTimes(1);
+            expect(cmd.log).toHaveBeenCalledWith('Set x.y.z');
+        });
+        it('should prompt before replacing an object with a primitive value', async () => {
+            vi.mocked(credentialsService.decryptCredentials).mockReturnValue('__OBJECT_AT_X_Y__');
+            const cmd = createTestCommand({ path: 'x.y', value: 'BAR' });
+            await cmd.run();
+            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('replace the existing object'));
+            expect(confirm).toHaveBeenCalledTimes(1);
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledTimes(1);
+        });
+        it('should abort without writing when the user declines the prompt', async () => {
+            vi.mocked(credentialsService.decryptCredentials).mockReturnValue('__PRIMITIVE_AT_X_Y__');
+            vi.mocked(confirm).mockResolvedValue(false);
+            const cmd = createTestCommand({ path: 'x.y.z', value: 'BAR' });
+            await cmd.run();
+            expect(credentialsService.writeEncrypted).not.toHaveBeenCalled();
+            expect(cmd.log).toHaveBeenCalledWith('Aborted.');
+            expect(cmd.log).not.toHaveBeenCalledWith('Set x.y.z');
+        });
+        it('should skip the prompt when --yes is passed', async () => {
+            vi.mocked(credentialsService.decryptCredentials).mockReturnValue('__PRIMITIVE_AT_X_Y__');
+            const cmd = createTestCommand({ path: 'x.y.z', value: 'BAR' }, { yes: true });
+            await cmd.run();
+            expect(confirm).not.toHaveBeenCalled();
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledTimes(1);
+            expect(cmd.log).toHaveBeenCalledWith('Set x.y.z');
+        });
+    });
+});

package/dist/commands/migrate.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class Migrate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        from: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        to: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        notes: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/migrate.js

@@ -0,0 +1,40 @@
+import { Command, Flags } from '@oclif/core';
+import { ensureOutputAISystem } from '#services/coding_agents.js';
+import { invokeMigrate } from '#services/claude_client.js';
+export default class Migrate extends Command {
+    static description = 'Upgrade a project between versions of the Output framework. ' +
+        'Fetches the matching migration guide from docs.output.ai and applies it.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --to 0.2.0',
+        '<%= config.bin %> <%= command.id %> --from 0.1.12 --to 0.2.0',
+        '<%= config.bin %> <%= command.id %> --to 0.2.0 --notes "skip the http changes, we don\'t use that package"'
+    ];
+    static flags = {
+        from: Flags.string({
+            description: 'Version to migrate from. Defaults to the framework version in your package.json.',
+            required: false
+        }),
+        to: Flags.string({
+            description: 'Version to migrate to. Defaults to the latest published version.',
+            required: false
+        }),
+        notes: Flags.string({
+            char: 'n',
+            description: 'Extra guidance passed through to the migration agent.',
+            required: false
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(Migrate);
+        const projectRoot = process.cwd();
+        this.log('Checking .outputai directory structure...');
+        await ensureOutputAISystem(projectRoot);
+        this.log('\nInvoking the /output-migrate skill...');
+        this.log('This may take a moment...\n');
+        const summary = await invokeMigrate(flags.from ?? '', flags.to ?? '', flags.notes);
+        this.log('\n=========');
+        this.log(summary);
+        this.log('=========\n');
+    }
+}

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

@@ -6,6 +6,7 @@ interface WorkflowDisplay {
     inputs: string;
     outputs: string;
     scenarios: string;
+    aliases: string;
 }
 export declare function parseWorkflowForDisplay(workflow: Workflow): WorkflowDisplay;
 export default class WorkflowList extends Command {

package/dist/commands/workflow/list.js

@@ -17,7 +17,8 @@ export function parseWorkflowForDisplay(workflow) {
         description: parsed.description || 'No description',
         inputs: formatParameters(parsed.inputs),
         outputs: formatParameters(parsed.outputs),
-        scenarios: scenarioNames.length > 0 ? scenarioNames.join(', ') : 'none'
+        scenarios: scenarioNames.length > 0 ? scenarioNames.join(', ') : 'none',
+        aliases: workflow.aliases?.length ? workflow.aliases.join(', ') : 'none'
     };
 }
 function caseInsensitiveIncludes(str, filter) {
@@ -26,7 +27,10 @@ function caseInsensitiveIncludes(str, filter) {
 function matchName(filterString) {
     return workflow => {
         const name = workflow.name || '';
-        return caseInsensitiveIncludes(name, filterString);
+        if (caseInsensitiveIncludes(name, filterString)) {
+            return true;
+        }
+        return (workflow.aliases ?? []).some(alias => caseInsensitiveIncludes(alias, filterString));
     };
 }
 function sortWorkflowsByName(workflows) {
@@ -38,8 +42,8 @@ function sortWorkflowsByName(workflows) {
 }
 function createWorkflowTable(workflows, detailed) {
     const table = new Table({
-        head: ['Name', 'Description', 'Inputs', 'Outputs', 'Scenarios'],
-        colWidths: detailed ? [30, 42, 42, 42, 60] : [24, 30, 24, 24, 48],
+        head: ['Name', 'Description', 'Aliases', 'Inputs', 'Outputs', 'Scenarios'],
+        colWidths: detailed ? [28, 36, 36, 36, 36, 48] : [22, 26, 26, 22, 22, 36],
         wordWrap: true,
         style: {
             head: ['cyan']
@@ -49,13 +53,14 @@ function createWorkflowTable(workflows, detailed) {
     sortedWorkflows.forEach(workflow => {
         const display = parseWorkflowForDisplay(workflow);
         if (detailed) {
+            const aliases = workflow.aliases?.length ? workflow.aliases.join('\n') : 'none';
             const inputs = display.inputs.split(', ').join('\n');
             const outputs = display.outputs.split(', ').join('\n');
             const scenarios = display.scenarios.split(', ').join('\n');
-            table.push([display.name, display.description, inputs, outputs, scenarios]);
+            table.push([display.name, display.description, aliases, inputs, outputs, scenarios]);
         }
         else {
-            table.push([display.name, display.description, display.inputs, display.outputs, display.scenarios]);
+            table.push([display.name, display.description, display.aliases, display.inputs, display.outputs, display.scenarios]);
         }
     });
     return table.toString();
@@ -72,6 +77,7 @@ function formatWorkflowsAsJson(workflows) {
             return {
                 name: display.name,
                 description: display.description,
+                aliases: w.aliases ?? [],
                 inputs: display.inputs.split(', '),
                 outputs: display.outputs.split(', '),
                 scenarios: display.scenarios === 'none' ? [] : display.scenarios.split(', '),

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

@@ -64,6 +64,27 @@ describe('workflow list parsing', () => {
         expect(parsed.inputs).toBe('none');
         expect(parsed.outputs).toBe('none');
         expect(parsed.scenarios).toBe('none');
+        expect(parsed.aliases).toBe('none');
+    });
+    it('should include aliases when present', async () => {
+        const { parseWorkflowForDisplay } = await import('./list.js');
+        const mockWorkflow = {
+            name: 'aliased-workflow',
+            description: 'Has aliases',
+            aliases: ['old_name', 'legacy_name']
+        };
+        const parsed = parseWorkflowForDisplay(mockWorkflow);
+        expect(parsed.aliases).toBe('old_name, legacy_name');
+    });
+    it('should show none when aliases array is empty', async () => {
+        const { parseWorkflowForDisplay } = await import('./list.js');
+        const mockWorkflow = {
+            name: 'no-aliases',
+            description: 'Empty aliases',
+            aliases: []
+        };
+        const parsed = parseWorkflowForDisplay(mockWorkflow);
+        expect(parsed.aliases).toBe('none');
     });
     it('should include scenario names when scenarios exist', async () => {
         mockListScenarios.mockReturnValueOnce(['basic', 'advanced', 'stress_test']);

package/dist/commands/workflow/plan.js

@@ -56,7 +56,7 @@ export default class WorkflowPlan extends Command {
         return this.planModificationLoop(modifiedPlanContent);
     }
     async planGenerationLoop(promptDescription, planName, projectRoot) {
-        this.log('\nInvoking the /outputai:plan_workflow command...');
+        this.log('\nInvoking the /output-plan-workflow command...');
         this.log('This may take a moment...\n');
         const planContent = await invokePlanWorkflow(promptDescription);
         const modifiedPlanContent = await this.planModificationLoop(planContent);

package/dist/commands/workflow/run.js

@@ -55,7 +55,8 @@ export default class WorkflowRun extends Command {
         }),
         'task-queue': Flags.string({
             char: 'q',
-            description: 'Task queue name for workflow execution'
+            description: 'Task queue name for workflow execution (defaults to OUTPUT_CATALOG_ID)',
+            env: 'OUTPUT_CATALOG_ID'
         }),
         format: Flags.string({
             char: 'f',

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

@@ -13,6 +13,7 @@ vi.mock('#utils/sleep.js', () => ({
 describe('workflow run command', () => {
     beforeEach(async () => {
         vi.clearAllMocks();
+        delete process.env.OUTPUT_CATALOG_ID;
         const { resolveInput } = await import('#utils/resolve_input.js');
         const { sleep } = await import('#utils/sleep.js');
         vi.mocked(resolveInput).mockResolvedValue({});

package/dist/commands/workflow/start.js

@@ -28,7 +28,8 @@ export default class WorkflowStart extends Command {
         }),
         'task-queue': Flags.string({
             char: 'q',
-            description: 'Task queue name for workflow execution'
+            description: 'Task queue name for workflow execution (defaults to OUTPUT_CATALOG_ID)',
+            env: 'OUTPUT_CATALOG_ID'
         })
     };
     async run() {

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

@@ -5,6 +5,7 @@ vi.mock('../../api/generated/api.js', () => ({
 describe('workflow start command', () => {
     beforeEach(() => {
         vi.clearAllMocks();
+        delete process.env.OUTPUT_CATALOG_ID;
     });
     describe('command definition', () => {
         it('should export a valid OCLIF command', async () => {