@outputai/cli 0.1.13-next.c93cdb4.0 → 0.1.13-next.d19646c.0

package/dist/api/generated/api.js

@@ -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.c93cdb4.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.1.13-next.d19646c.0}
     init: true
     networks:
       - main

package/dist/commands/workflow/generate.js

@@ -4,6 +4,7 @@ import { buildWorkflow, buildWorkflowInteractiveLoop } from '#services/workflow_
 import { ensureOutputAISystem } from '#services/coding_agents.js';
 import { getWorkflowGenerateSuccessMessage } from '#services/messages.js';
 import { DEFAULT_OUTPUT_DIRS } from '#utils/paths.js';
+import { parseWorkflowDir } from '#utils/workflow_dir_parser.js';
 import path from 'node:path';
 import * as fsSync from 'node:fs';
 import { getErrorMessage } from '#utils/error_utils.js';
@@ -83,7 +84,8 @@ export default class Generate extends Command {
         this.displaySuccess(result);
     }
     displaySuccess(result) {
-        const message = getWorkflowGenerateSuccessMessage(result.workflowName, result.targetDir, result.filesCreated);
+        const dirInfo = parseWorkflowDir(result.targetDir);
+        const message = getWorkflowGenerateSuccessMessage(result.workflowName, dirInfo.workflowId ?? result.workflowName, dirInfo.scenarioNames[0], result.targetDir, result.filesCreated);
         this.log(message);
     }
 }

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

@@ -2,10 +2,13 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 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');
 describe('Generate Command', () => {
     let mockGenerateWorkflow;
+    let mockParseWorkflowDir;
     let logSpy;
     const createCommand = () => {
         const cmd = new Generate([], {});
@@ -20,6 +23,7 @@ describe('Generate Command', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         mockGenerateWorkflow = vi.mocked(generateWorkflow);
+        mockParseWorkflowDir = vi.mocked(parseWorkflowDir);
     });
     describe('successful workflow generation', () => {
         it('should generate workflow with skeleton flag', async () => {
@@ -38,6 +42,10 @@ describe('Generate Command', () => {
                 targetDir: '/tmp/test-workflow',
                 filesCreated: ['index.ts', 'steps.ts', 'types.ts']
             });
+            mockParseWorkflowDir.mockReturnValue({
+                workflowId: 'testWorkflow',
+                scenarioNames: ['test_input']
+            });
             await cmd.run();
             expect(mockGenerateWorkflow).toHaveBeenCalledWith({
                 name: 'test-workflow',
@@ -105,6 +113,10 @@ describe('Generate Command', () => {
                 targetDir: '/custom/path/my-workflow',
                 filesCreated: ['index.ts', 'steps.ts', 'types.ts']
             });
+            mockParseWorkflowDir.mockReturnValue({
+                workflowId: 'myWorkflow',
+                scenarioNames: ['test_input']
+            });
             await cmd.run();
             expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('SUCCESS!'));
             expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('my-workflow'));

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/components/command_footer.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface CommandHint {
+    key: string;
+    label: string;
+}
+export declare const CommandFooter: React.FC<{
+    hints: CommandHint[];
+}>;

package/dist/components/command_footer.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+export const CommandFooter = ({ hints }) => (_jsx(Box, { marginTop: 1, children: hints.map((hint, i) => (_jsxs(React.Fragment, { children: [i > 0 && _jsx(Text, { dimColor: true, children: ' | ' }), _jsx(Text, { dimColor: true, children: '(' }), _jsx(Text, { dimColor: true, bold: true, children: hint.key }), _jsx(Text, { dimColor: true, children: ')' }), _jsx(Text, { dimColor: true, children: ` ${hint.label}` })] }, hint.key))) }));

package/dist/components/status_icon.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface StatusDisplay {
+    icon: string;
+    color: string;
+}
+export declare const resolveStatus: (status: string) => StatusDisplay;
+export declare const statusColor: (status: string) => string;
+export declare const StatusIcon: React.FC<{
+    status: string;
+}>;
+export {};

package/dist/components/status_icon.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from 'ink';
+const STATUS_MAP = {
+    // Docker service health
+    healthy: { icon: '●', color: 'green' },
+    unhealthy: { icon: '○', color: 'red' },
+    starting: { icon: '◐', color: 'yellow' },
+    none: { icon: '●', color: 'blue' },
+    exited: { icon: '✗', color: 'red' },
+    // Workflow run status
+    running: { icon: '●', color: 'blue' },
+    completed: { icon: '●', color: 'green' },
+    failed: { icon: '✗', color: 'red' },
+    canceled: { icon: '○', color: 'gray' },
+    terminated: { icon: '✗', color: 'red' },
+    timed_out: { icon: '✗', color: 'red' },
+    continued: { icon: '↻', color: 'blue' }
+};
+const DEFAULT_DISPLAY = { icon: '?', color: 'white' };
+export const resolveStatus = (status) => STATUS_MAP[status] ?? DEFAULT_DISPLAY;
+export const statusColor = (status) => resolveStatus(status).color;
+export const StatusIcon = ({ status }) => {
+    const { icon, color } = resolveStatus(status);
+    return _jsx(Text, { color: color, children: icon });
+};

package/dist/components/workflow_summary.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface WorkflowSummary {
+    running: number;
+    completed: number;
+    failed: number;
+    total: number;
+}
+export declare const WorkflowSummarySection: React.FC<{
+    summary: WorkflowSummary;
+}>;

package/dist/components/workflow_summary.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { statusColor } from '#components/status_icon.js';
+export const WorkflowSummarySection = ({ summary }) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "\uD83D\uDCCB Workflows" }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: statusColor('running'), children: [summary.running, " running"] }), _jsx(Text, { children: ", " }), _jsxs(Text, { color: statusColor('failed'), children: [summary.failed, " failed"] }), _jsx(Text, { children: ", " }), _jsxs(Text, { color: statusColor('completed'), children: [summary.completed, " complete"] })] })] }));

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.1.13-next.c93cdb4.0"
+    "framework": "0.1.13-next.d19646c.0"
 }

package/dist/services/claude_client.js

@@ -105,7 +105,10 @@ function getTodoWriteMessage(message) {
     if (message.type !== 'assistant') {
         return null;
     }
-    const todoWriteMessage = message.message.content.find((c) => c?.type === 'tool_use' && c.name === 'TodoWrite');
+    const todoWriteMessage = message.message.content.find((c) => {
+        const block = c;
+        return block.type === 'tool_use' && block.name === 'TodoWrite';
+    });
     return todoWriteMessage ?? null;
 }
 function applyInstructions(message, instructions) {

package/dist/services/docker.d.ts

@@ -21,8 +21,6 @@ export declare class DockerComposeConfigNotFoundError extends Error {
     constructor(dockerComposePath: string);
 }
 declare const isDockerInstalled: () => boolean;
-declare const isDockerComposeAvailable: () => boolean;
-declare const isDockerDaemonRunning: () => boolean;
 export declare function validateDockerEnvironment(): void;
 export declare function getDefaultDockerComposePath(): string;
 export declare function parseServiceStatus(jsonOutput: string): ServiceStatus[];
@@ -37,4 +35,4 @@ export type PullPolicy = 'always' | 'missing' | 'never';
 export declare function startDockerCompose(dockerComposePath: string, pullPolicy?: PullPolicy): Promise<DockerComposeProcess>;
 export declare function startDockerComposeDetached(dockerComposePath: string, pullPolicy?: PullPolicy): void;
 export declare function stopDockerCompose(dockerComposePath: string): Promise<void>;
-export { isDockerInstalled, isDockerComposeAvailable, isDockerDaemonRunning, DockerValidationError };
+export { isDockerInstalled, DockerValidationError };

package/dist/services/docker.js

@@ -2,6 +2,7 @@ import { execFileSync, execSync, spawn } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ux } from '@oclif/core';
+import semver from 'semver';
 const DEFAULT_COMPOSE_PATH = '../assets/docker/docker-compose-dev.yml';
 export const SERVICE_HEALTH = {
     HEALTHY: 'healthy',
@@ -30,27 +31,51 @@ const checkDockerCommand = (command) => {
         return false;
     }
 };
+const getCommandVersion = (command, pattern = /(\d+\.\d+\.\d+)/) => {
+    try {
+        const output = execSync(command, { stdio: 'pipe', encoding: 'utf-8' }).trim();
+        const match = output.match(pattern);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+};
 const isDockerInstalled = () => checkDockerCommand('docker --version');
-const isDockerComposeAvailable = () => checkDockerCommand('docker compose version');
-const isDockerDaemonRunning = () => checkDockerCommand('docker ps');
-const DOCKER_VALIDATIONS = [
+const PREREQUISITES = [
     {
-        check: isDockerInstalled,
-        error: 'Docker is not installed. Please install Docker to use the dev command.\nVisit: https://docs.docker.com/get-docker/'
+        name: 'Docker',
+        semverRange: '>=20.0.0',
+        getVersion: () => getCommandVersion('docker --version'),
+        errorMessage: (current, required) => current === null ?
+            'Docker is not installed. Please install Docker to use the dev command.\nVisit: https://docs.docker.com/get-docker/' :
+            `Docker version ${required} is required (found v${current}).\nVisit: https://docs.docker.com/get-docker/`
     },
     {
-        check: isDockerComposeAvailable,
-        error: 'Docker Compose is not installed. Please install Docker Compose to use the dev command.\nVisit: https://docs.docker.com/compose/install/'
+        name: 'Docker Compose',
+        semverRange: '>=2.24.0',
+        getVersion: () => getCommandVersion('docker compose version --short'),
+        errorMessage: (current, required) => current === null ?
+            'Docker Compose is not installed. Please install Docker Compose to use the dev command.\nVisit: https://docs.docker.com/compose/install/' :
+            `Docker Compose ${required} is required (found v${current}).\nPlease update Docker Compose: https://docs.docker.com/compose/install/`
     },
     {
-        check: isDockerDaemonRunning,
-        error: 'Docker daemon is not running. Please start Docker and try again.'
+        name: 'Docker Daemon',
+        semverRange: '*',
+        getVersion: () => checkDockerCommand('docker ps') ? '0.0.0' : null,
+        errorMessage: () => 'Docker daemon is not running. Please start Docker and try again.'
     }
 ];
 export function validateDockerEnvironment() {
-    const failedValidation = DOCKER_VALIDATIONS.find(v => !v.check());
-    if (failedValidation) {
-        throw new DockerValidationError(failedValidation.error);
+    for (const prereq of PREREQUISITES) {
+        const raw = prereq.getVersion();
+        const version = raw ? semver.valid(semver.coerce(raw)) : null;
+        if (!version) {
+            throw new DockerValidationError(prereq.errorMessage(null, prereq.semverRange));
+        }
+        if (!semver.satisfies(version, prereq.semverRange)) {
+            throw new DockerValidationError(prereq.errorMessage(version, prereq.semverRange));
+        }
     }
 }
 export function getDefaultDockerComposePath() {
@@ -129,4 +154,4 @@ export async function stopDockerCompose(dockerComposePath) {
     ux.stdout('⏹️  Stopping services...\n');
     execFileSync('docker', ['compose', '-f', dockerComposePath, 'down'], { stdio: 'inherit', cwd: process.cwd() });
 }
-export { isDockerInstalled, isDockerComposeAvailable, isDockerDaemonRunning, DockerValidationError };
+export { isDockerInstalled, DockerValidationError };

package/dist/services/messages.d.ts

@@ -3,4 +3,4 @@
  */
 export declare const getEjectSuccessMessage: (destPath: string, outputFile: string, binName: string) => string;
 export declare const getProjectSuccessMessage: (folderName: string, installSuccess: boolean, credentialsConfigured?: boolean) => string;
-export declare const getWorkflowGenerateSuccessMessage: (workflowName: string, targetDir: string, filesCreated: string[]) => string;
+export declare const getWorkflowGenerateSuccessMessage: (workflowName: string, workflowId: string, scenarioName: string | undefined, targetDir: string, filesCreated: string[]) => string;

package/dist/services/messages.js

@@ -234,7 +234,7 @@ ${ux.colorize('dim', '         to manage your project secrets.')}
 ${ux.colorize('green', ux.colorize('bold', 'Happy building with Output! 🚀'))}
 `;
 };
-export const getWorkflowGenerateSuccessMessage = (workflowName, targetDir, filesCreated) => {
+export const getWorkflowGenerateSuccessMessage = (workflowName, workflowId, scenarioName, targetDir, filesCreated) => {
     const divider = ux.colorize('dim', '─'.repeat(80));
     const bulletPoint = ux.colorize('green', '▸');
     const formattedFiles = filesCreated.map(file => {
@@ -256,7 +256,7 @@ export const getWorkflowGenerateSuccessMessage = (workflowName, targetDir, files
         },
         {
             step: 'Test your workflow',
-            command: `npx output workflow run ${workflowName} test_input`,
+            command: `npx output workflow run ${workflowId}${scenarioName ? ` ${scenarioName}` : ''}`,
             note: 'Run after starting services with "npx output dev"'
         }
     ];

package/dist/templates/agent_instructions/CLAUDE.md.template

@@ -4,16 +4,50 @@ This is an **Output.ai** project - a framework for building reliable, production
 
 ## Getting Started
 
-For full framework documentation, commands, and AI-assisted workflow development, install our Claude Code plugins:
+Install Claude Code plugins for full framework documentation and AI-assisted development:
 
 ```bash
 claude plugin marketplace add growthxai/output
 claude plugin install outputai@outputai --scope project
 ```
 
+## Commands
+
+```bash
+npm run output:dev           # Start dev environment (worker + Temporal)
+npm run output:worker:build  # Build TypeScript to dist/
+npm run output:worker:watch  # Build + restart on file changes
+npm run output:worker        # Install, build, and start worker
+```
+
+## Project Structure
+
+```
+src/
+  workflows/         # Each subfolder is one workflow
+    <name>/
+      workflow.ts    # Workflow orchestration (must be deterministic - no I/O)
+      steps.ts       # Step functions (all I/O: HTTP, LLM, DB)
+      evaluators.ts  # Evaluator functions (LLM-based quality assessment)
+      types.ts       # Zod schemas and TypeScript types
+      prompts/       # .prompt files (Liquid.js templates with YAML frontmatter)
+      scenarios/     # Test scenario JSON files
+  clients/           # Shared HTTP clients (use @outputai/http, not fetch/axios)
+  shared/            # Shared utilities across workflows
+config/
+  costs.yml              # Token/API pricing overrides
+  credentials.yml.enc    # Encrypted secrets (edit via: output credentials edit)
+  credentials.yml.template  # Credential structure reference
+```
+
+## Key Conventions
+
+- **Workflows are deterministic**: No I/O, no `Date.now()`, no `Math.random()` in `workflow.ts`. All side effects go in steps or evaluators.
+- **HTTP clients**: Always use `httpClient` from `@outputai/http` -- never raw `fetch` or `axios`. This enables automatic tracing and cost tracking.
+- **LLM calls**: Use `generateText` from `@outputai/llm` with `.prompt` files. Never call LLM APIs directly.
+
 ---
 
 ## Project-Specific Instructions
 
 <!-- Add your project-specific instructions below -->
-

package/dist/templates/agent_instructions/dotclaude/settings.json.template

@@ -4,8 +4,8 @@
       "WebFetch",
       "Bash(npx output:*)",
       "Bash(npm run output:*)",
-      "Skills(output*)",
-      "Skills(flow*)"
+      "Skill(output*)",
+      "Skill(outputai:*)"
     ]
   },
   "enabledPlugins": {

package/dist/utils/date_formatter.d.ts

@@ -14,7 +14,17 @@ export declare function formatDuration(ms: number): string;
  */
 export declare function formatDate(isoString: string | null | undefined): string;
 /**
- * Format a duration between two ISO timestamps
+ * Calculate elapsed milliseconds between two ISO timestamps.
+ * If completedAt is null/undefined, uses current time (for in-progress durations).
+ */
+export declare function elapsedMs(startedAt: string, completedAt?: string | null): number;
+/**
+ * Format a duration in milliseconds to a compact string that fits in narrow columns.
+ * Always returns a short single-token string (e.g., "150ms", "7.56s", "24.2m", "1.3h").
+ */
+export declare function formatDurationCompact(ms: number): string;
+/**
+ * Format a duration between two ISO timestamps.
  *
  * @param startedAt - ISO 8601 start timestamp
  * @param completedAt - ISO 8601 end timestamp (or null if still running)

package/dist/utils/date_formatter.js

@@ -33,7 +33,32 @@ export function formatDate(isoString) {
     return format(parseISO(isoString), 'MMM d, yyyy h:mm a');
 }
 /**
- * Format a duration between two ISO timestamps
+ * Calculate elapsed milliseconds between two ISO timestamps.
+ * If completedAt is null/undefined, uses current time (for in-progress durations).
+ */
+export function elapsedMs(startedAt, completedAt) {
+    const start = parseISO(startedAt).getTime();
+    const end = completedAt ? parseISO(completedAt).getTime() : Date.now();
+    return end - start;
+}
+/**
+ * Format a duration in milliseconds to a compact string that fits in narrow columns.
+ * Always returns a short single-token string (e.g., "150ms", "7.56s", "24.2m", "1.3h").
+ */
+export function formatDurationCompact(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    if (ms < 60_000) {
+        return `${(ms / 1000).toFixed(2)}s`;
+    }
+    if (ms < 3_600_000) {
+        return `${(ms / 60_000).toFixed(1)}m`;
+    }
+    return `${(ms / 3_600_000).toFixed(1)}h`;
+}
+/**
+ * Format a duration between two ISO timestamps.
  *
  * @param startedAt - ISO 8601 start timestamp
  * @param completedAt - ISO 8601 end timestamp (or null if still running)

package/dist/utils/format_workflow_result.d.ts

@@ -1,5 +1,5 @@
-import type { GetWorkflowIdResult200, GetWorkflowIdResult200Status } from '../api/generated/api.js';
-type WorkflowResult = Pick<GetWorkflowIdResult200, 'workflowId' | 'output' | 'status' | 'error'>;
-export declare const ERROR_STATUSES: ReadonlySet<GetWorkflowIdResult200Status | undefined>;
+import type { WorkflowResultResponse, WorkflowResultResponseStatus } from '../api/generated/api.js';
+type WorkflowResult = Pick<WorkflowResultResponse, 'workflowId' | 'output' | 'status' | 'error'>;
+export declare const ERROR_STATUSES: ReadonlySet<WorkflowResultResponseStatus | undefined>;
 export declare function formatWorkflowResult(result: WorkflowResult): string;
 export {};

package/dist/utils/open_url.d.ts

@@ -0,0 +1 @@
+export declare const openUrl: (url: string) => void;