@outputai/cli 0.10.1-next.be4ec7f.0 → 0.10.1-next.bf95a6f.0

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

@@ -66,22 +66,29 @@ export interface Workflow {
     /** Alternative names that resolve to this workflow */
     aliases?: string[];
 }
+/**
+ * Legacy trace information containing nested destinations
+ * @nullable
+ */
+export type TraceInfoV1 = {
+    /** Available destinations for trace data */
+    destinations?: {
+        /** Absolute path to local trace file, omitted if not saved locally */
+        local?: string;
+        /** Remote trace location (e.g., S3 URI), omitted if not saved remotely */
+        remote?: string;
+    };
+} | null;
 /**
  * Available destinations for trace data
+ * @nullable
  */
-export type TraceInfoDestinations = {
+export type TraceInfoV2 = {
     /** Absolute path to local trace file, omitted if not saved locally */
     local?: string;
     /** Remote trace location (e.g., S3 URI), omitted if not saved remotely */
     remote?: string;
-};
-/**
- * An object with information about the trace generated by the execution
- */
-export interface TraceInfo {
-    /** Available destinations for trace data */
-    destinations?: TraceInfoDestinations;
-}
+} | null;
 /**
  * The workflow input
  */
@@ -148,7 +155,7 @@ export declare const WorkflowRunInfoStatus: {
     readonly running: "running";
     readonly completed: "completed";
     readonly failed: "failed";
-    readonly canceled: "canceled";
+    readonly cancelled: "cancelled";
     readonly terminated: "terminated";
     readonly timed_out: "timed_out";
     readonly continued_as_new: "continued_as_new";
@@ -180,7 +187,7 @@ export interface WorkflowRunsResponse {
  */
 export type WorkflowStatusResponseStatus = typeof WorkflowStatusResponseStatus[keyof typeof WorkflowStatusResponseStatus];
 export declare const WorkflowStatusResponseStatus: {
-    readonly canceled: "canceled";
+    readonly cancelled: "cancelled";
     readonly completed: "completed";
     readonly continued_as_new: "continued_as_new";
     readonly failed: "failed";
@@ -204,20 +211,33 @@ export interface WorkflowStatusResponse {
 /**
  * The workflow execution status
  */
-export type WorkflowResultResponseStatus = typeof WorkflowResultResponseStatus[keyof typeof WorkflowResultResponseStatus];
-export declare const WorkflowResultResponseStatus: {
+export type WorkflowResultStatus = typeof WorkflowResultStatus[keyof typeof WorkflowResultStatus];
+export declare const WorkflowResultStatus: {
     readonly completed: "completed";
     readonly failed: "failed";
-    readonly canceled: "canceled";
+    readonly cancelled: "cancelled";
     readonly terminated: "terminated";
     readonly timed_out: "timed_out";
     readonly continued_as_new: "continued_as_new";
 };
+/**
+ * Structured error details captured from the workflow or activity failure
+ * @nullable
+ */
+export type SerializedWorkflowError = {
+    /** Failing activity type, omitted when the failure did not originate in an activity */
+    activityType?: string;
+    /** Original error class name */
+    name?: string;
+    /** Original error message */
+    message?: string;
+    [key: string]: unknown;
+} | null;
 /**
  * Structured failure details if the workflow failed, null otherwise
  * @nullable
  */
-export type WorkflowResultResponseErrorDetails = {
+export type WorkflowResultV1ResponseErrorDetails = {
     /**
        * Friendly failure message (from the underlying application error)
        * @nullable
@@ -246,29 +266,64 @@ export type WorkflowResultResponseErrorDetails = {
         [key: string]: unknown;
     } | null;
 } | null | null;
-export interface WorkflowResultResponse {
+/**
+ * Legacy wrapped workflow result
+ * @deprecated
+ */
+export interface WorkflowResultV1Response {
     /** The workflow execution id */
-    workflowId?: string;
-    /** The specific run id for this execution */
-    runId?: string;
+    workflowId: string;
+    /**
+       * The specific run id for this execution
+       * @nullable
+       */
+    runId: string | null;
+    status: WorkflowResultStatus;
     /** The original input passed to the workflow, null if unavailable */
-    input?: unknown;
+    input: unknown | null;
     /** The result of workflow, null if workflow failed */
-    output?: unknown;
-    trace?: TraceInfo;
-    /** The workflow execution status */
-    status?: WorkflowResultResponseStatus;
+    output: unknown | null;
+    trace: TraceInfoV1 | null;
     /**
        * Error message if workflow failed, null otherwise
        * @nullable
        */
-    error?: string | null;
+    error: string | null;
     /**
        * Structured failure details if the workflow failed, null otherwise
        * @nullable
        */
-    errorDetails?: WorkflowResultResponseErrorDetails;
+    errorDetails: WorkflowResultV1ResponseErrorDetails;
+}
+/**
+ * Workflow result response version
+ */
+export type WorkflowResultV2ResponseV = typeof WorkflowResultV2ResponseV[keyof typeof WorkflowResultV2ResponseV];
+export declare const WorkflowResultV2ResponseV: {
+    readonly NUMBER_2: "2";
+};
+/**
+ * Current workflow result with direct output and memo-based trace information
+ */
+export interface WorkflowResultV2Response {
+    /** Workflow result response version */
+    v: WorkflowResultV2ResponseV;
+    /** The workflow execution id */
+    workflowId: string;
+    /**
+       * The specific run id for this execution
+       * @nullable
+       */
+    runId: string | null;
+    status: WorkflowResultStatus;
+    /** The original input passed to the workflow, null if unavailable */
+    input: unknown | null;
+    /** Direct workflow output, null if no output is available */
+    output: unknown | null;
+    trace: TraceInfoV2 | null;
+    error: (SerializedWorkflowError | null) | null;
 }
+export type WorkflowResultResponse = WorkflowResultV2Response | WorkflowResultV1Response;
 export interface WorkflowInputResponse {
     /** The workflow execution id */
     workflowId: string;

package/dist/api/generated/api.js

@@ -19,13 +19,13 @@ export const WorkflowRunInfoStatus = {
     running: 'running',
     completed: 'completed',
     failed: 'failed',
-    canceled: 'canceled',
+    cancelled: 'cancelled',
     terminated: 'terminated',
     timed_out: 'timed_out',
     continued_as_new: 'continued_as_new',
 };
 export const WorkflowStatusResponseStatus = {
-    canceled: 'canceled',
+    cancelled: 'cancelled',
     completed: 'completed',
     continued_as_new: 'continued_as_new',
     failed: 'failed',
@@ -34,14 +34,17 @@ export const WorkflowStatusResponseStatus = {
     timed_out: 'timed_out',
     unspecified: 'unspecified',
 };
-export const WorkflowResultResponseStatus = {
+export const WorkflowResultStatus = {
     completed: 'completed',
     failed: 'failed',
-    canceled: 'canceled',
+    cancelled: 'cancelled',
     terminated: 'terminated',
     timed_out: 'timed_out',
     continued_as_new: 'continued_as_new',
 };
+export const WorkflowResultV2ResponseV = {
+    NUMBER_2: '2',
+};
 ;
 export const getGetHealthUrl = () => {
     return `/health`;

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.10.1-next.be4ec7f.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.10.1-next.bf95a6f.0}
     init: true
     networks:
       - main
@@ -118,7 +118,7 @@ services:
       - OUTPUT_CATALOG_ID=${OUTPUT_CATALOG_ID:-main}
       - OUTPUT_REDIS_URL=redis://redis:6379
       - OUTPUT_TRACE_LOCAL_ON=${OUTPUT_TRACE_LOCAL_ON:-true}
-      - OUTPUT_TRACE_HOST_PATH=${PWD}/logs
+      - OUTPUT_TRACE_HOST_PATH=${OUTPUT_TRACE_HOST_PATH:-${PWD}/logs}
       - OUTPUT_TRACE_HTTP_VERBOSE=${OUTPUT_TRACE_HTTP_VERBOSE:-true}
       - OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION=${OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION:-false}
       - TEMPORAL_ADDRESS=temporal:7233

package/dist/commands/workflow/result.js

@@ -1,6 +1,6 @@
 import { Args, Command } from '@oclif/core';
 import { getWorkflowIdResult } from '#api/generated/api.js';
-import { formatWorkflowResult, ERROR_STATUSES } from '#utils/format_workflow_result.js';
+import { formatWorkflowResult, isErrorWorkflowStatus } from '#utils/format_workflow_result.js';
 import { handleApiError } from '#utils/error_handler.js';
 export default class WorkflowResult extends Command {
     static description = 'Get workflow execution result';
@@ -24,7 +24,7 @@ export default class WorkflowResult extends Command {
         }
         const data = response.data;
         this.log(`\n${formatWorkflowResult(data)}`);
-        if (ERROR_STATUSES.has(data.status)) {
+        if (isErrorWorkflowStatus(data.status)) {
             process.exitCode = 1;
         }
         return data;

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

@@ -1,10 +1,12 @@
+/* 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', () => ({
     getWorkflowIdResult: vi.fn()
 }));
 describe('workflow result command', () => {
     beforeEach(() => {
         vi.clearAllMocks();
+        process.exitCode = undefined;
     });
     describe('command definition', () => {
         it('should export a valid OCLIF command', async () => {
@@ -18,4 +20,66 @@ describe('workflow result command', () => {
             expect(WorkflowResult.enableJsonFlag).toBe(true);
         });
     });
+    describe('run()', () => {
+        const runCommand = async (data) => {
+            const WorkflowResult = (await import('./result.js')).default;
+            const { getWorkflowIdResult } = await import('#api/generated/api.js');
+            const cmd = new WorkflowResult(['wf-1'], {});
+            cmd.log = vi.fn();
+            cmd.parse = vi.fn().mockResolvedValue({ args: { workflowId: 'wf-1' } });
+            vi.mocked(getWorkflowIdResult).mockResolvedValue({
+                data,
+                status: 200,
+                headers: new Headers()
+            });
+            const result = await cmd.run();
+            return { cmd, result, getWorkflowIdResult };
+        };
+        it('returns and formats a legacy result', async () => {
+            const data = {
+                workflowId: 'wf-1',
+                runId: 'run-1',
+                status: 'failed',
+                input: {},
+                output: null,
+                trace: null,
+                error: 'Legacy failure',
+                errorDetails: null
+            };
+            const { cmd, result, getWorkflowIdResult } = await runCommand(data);
+            expect(getWorkflowIdResult).toHaveBeenCalledWith('wf-1');
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('Error: Legacy failure'));
+            expect(result).toEqual(data);
+            expect(process.exitCode).toBe(1);
+        });
+        it('returns and formats a current result', async () => {
+            const data = {
+                v: '2',
+                workflowId: 'wf-1',
+                runId: 'run-1',
+                status: 'failed',
+                input: {},
+                output: null,
+                trace: null,
+                error: { name: 'ValidationError', message: 'Invalid input' }
+            };
+            const { result } = await runCommand(data);
+            expect(result).toEqual(data);
+            expect(process.exitCode).toBe(1);
+        });
+        it('sets a failure exit code for the previous canceled spelling', async () => {
+            const data = {
+                workflowId: 'wf-1',
+                runId: 'run-1',
+                status: 'canceled',
+                input: {},
+                output: null,
+                trace: null,
+                error: 'Workflow was canceled',
+                errorDetails: null
+            };
+            await runCommand(data);
+            expect(process.exitCode).toBe(1);
+        });
+    });
 });

package/dist/commands/workflow/run.js

@@ -1,6 +1,6 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { postWorkflowRun } from '#api/generated/api.js';
-import { formatWorkflowResult, ERROR_STATUSES } from '#utils/format_workflow_result.js';
+import { formatWorkflowResult, isErrorWorkflowStatus } from '#utils/format_workflow_result.js';
 import { handleApiError } from '#utils/error_handler.js';
 import { resolveInput } from '#utils/resolve_input.js';
 import { getRetryDelayFromResponse } from '#utils/header_utils.js';
@@ -63,7 +63,14 @@ 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', flags.catalog);
+        const input = await resolveInput({
+            workflowName: args.workflowName,
+            scenario: args.scenario,
+            inputFlag: flags.input,
+            commandName: 'run',
+            catalog: flags.catalog,
+            json: this.jsonEnabled()
+        });
         this.log(`Executing workflow: ${args.workflowName}...`);
         const response = await executeWorkflow({
             body: {
@@ -79,7 +86,7 @@ export default class WorkflowRun extends Command {
         }
         const data = response.data;
         this.log(`\n${formatWorkflowResult(data)}`);
-        if (ERROR_STATUSES.has(data.status)) {
+        if (isErrorWorkflowStatus(data.status)) {
             process.exitCode = 1;
         }
         return data;

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

@@ -59,12 +59,26 @@ describe('workflow run command', () => {
             const { cmd, postWorkflowRun, resolveInput } = await createCommand();
             resolveInput.mockResolvedValue({ key: 'value' });
             postWorkflowRun.mockResolvedValue({
-                data: { status: 'completed', result: { output: 'ok' } },
+                data: {
+                    v: '2',
+                    workflowId: 'wf-1',
+                    runId: 'run-1',
+                    status: 'completed',
+                    input: { key: 'value' },
+                    output: 'ok',
+                    trace: null,
+                    error: null
+                },
                 status: 200,
                 headers: new Headers()
             });
             await cmd.run();
-            expect(resolveInput).toHaveBeenCalledWith('my_workflow', undefined, undefined, 'run', undefined);
+            expect(resolveInput).toHaveBeenCalledWith(expect.objectContaining({
+                workflowName: 'my_workflow',
+                commandName: 'run',
+                catalog: undefined,
+                json: false
+            }));
             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...');
@@ -78,12 +92,26 @@ describe('workflow run command', () => {
             });
             resolveInput.mockResolvedValue({ key: 'value' });
             postWorkflowRun.mockResolvedValue({
-                data: { status: 'completed', result: {} },
+                data: {
+                    v: '2',
+                    workflowId: 'wf-1',
+                    runId: 'run-1',
+                    status: 'completed',
+                    input: { key: 'value' },
+                    output: {},
+                    trace: null,
+                    error: null
+                },
                 status: 200,
                 headers: new Headers()
             });
             await cmd.run();
-            expect(resolveInput).toHaveBeenCalledWith('my_workflow', 'basic', undefined, 'run', 'my-catalog');
+            expect(resolveInput).toHaveBeenCalledWith(expect.objectContaining({
+                workflowName: 'my_workflow',
+                scenario: 'basic',
+                commandName: 'run',
+                catalog: '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 () => {
@@ -93,7 +121,16 @@ describe('workflow run command', () => {
             postWorkflowRun
                 .mockRejectedValueOnce(new HttpError('Unavailable', { status: 503, headers }))
                 .mockResolvedValueOnce({
-                data: { status: 'completed', result: {} },
+                data: {
+                    v: '2',
+                    workflowId: 'wf-1',
+                    runId: 'run-1',
+                    status: 'completed',
+                    input: {},
+                    output: {},
+                    trace: null,
+                    error: null
+                },
                 status: 200,
                 headers: new Headers()
             });

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

@@ -1,6 +1,8 @@
 import { Command } from '@oclif/core';
+import { type PostWorkflowStart200 } from '#api/generated/api.js';
 export default class WorkflowStart extends Command {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static args: {
         workflowName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
@@ -10,6 +12,6 @@ export default class WorkflowStart extends Command {
         input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    run(): Promise<void>;
+    run(): Promise<PostWorkflowStart200>;
     catch(error: Error): Promise<void>;
 }

package/dist/commands/workflow/start.js

@@ -4,11 +4,13 @@ import { handleApiError } from '#utils/error_handler.js';
 import { resolveInput } from '#utils/resolve_input.js';
 export default class WorkflowStart extends Command {
     static description = 'Start a workflow asynchronously without waiting for completion';
+    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> simple basic_input',
         '<%= config.bin %> <%= command.id %> simple --input \'{"values":[1,2,3]}\'',
         '<%= config.bin %> <%= command.id %> simple --input input.json',
-        '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --catalog my-catalog'
+        '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --catalog my-catalog',
+        '<%= config.bin %> <%= command.id %> simple --json'
     ];
     static args = {
         workflowName: Args.string({
@@ -37,7 +39,14 @@ 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', flags.catalog);
+        const input = await resolveInput({
+            workflowName: args.workflowName,
+            scenario: args.scenario,
+            inputFlag: flags.input,
+            commandName: 'start',
+            catalog: flags.catalog,
+            json: this.jsonEnabled()
+        });
         this.log(`Starting workflow: ${args.workflowName}...`);
         const response = await postWorkflowStart({
             workflowName: args.workflowName,
@@ -57,6 +66,7 @@ export default class WorkflowStart extends Command {
             `Use "workflow result ${result.workflowId || '<workflow-id>'}" to get the workflow result when complete`
         ].join('\n');
         this.log(`\n${output}`);
+        return result;
     }
     async catch(error) {
         return handleApiError(error, (...args) => this.error(...args), {

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

@@ -36,13 +36,17 @@ describe('workflow start command', () => {
             expect(WorkflowStart.flags.catalog.env).toBe('OUTPUT_CATALOG_ID');
             expect(WorkflowStart.flags.catalog.char).toBe('c');
         });
+        it('enables the built-in --json flag', async () => {
+            const WorkflowStart = (await import('./start.js')).default;
+            expect(WorkflowStart.enableJsonFlag).toBe(true);
+        });
     });
     describe('run()', () => {
-        const createCommand = async (flagOverrides = {}) => {
+        const createCommand = async (flagOverrides = {}, argv = ['my_workflow']) => {
             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'], {});
+            const cmd = new WorkflowStart(argv, {});
             cmd.log = vi.fn();
             cmd.error = vi.fn(() => {
                 throw new Error('error called');
@@ -61,9 +65,15 @@ describe('workflow start command', () => {
                 status: 200,
                 headers: new Headers()
             });
-            await cmd.run();
-            expect(resolveInput).toHaveBeenCalledWith('my_workflow', undefined, undefined, 'start', 'my-catalog');
+            const result = await cmd.run();
+            expect(resolveInput).toHaveBeenCalledWith(expect.objectContaining({
+                workflowName: 'my_workflow',
+                commandName: 'start',
+                catalog: 'my-catalog',
+                json: false
+            }));
             expect(postWorkflowStart).toHaveBeenCalledWith(expect.objectContaining({ workflowName: 'my_workflow', catalog: 'my-catalog' }));
+            expect(result).toEqual({ workflowId: 'wf-123' });
         });
         it('passes undefined catalog through when none is set', async () => {
             const { cmd, postWorkflowStart, resolveInput } = await createCommand();
@@ -74,7 +84,22 @@ describe('workflow start command', () => {
                 headers: new Headers()
             });
             await cmd.run();
-            expect(resolveInput).toHaveBeenCalledWith('my_workflow', undefined, undefined, 'start', undefined);
+            expect(resolveInput).toHaveBeenCalledWith(expect.objectContaining({
+                workflowName: 'my_workflow',
+                commandName: 'start',
+                catalog: undefined
+            }));
+        });
+        it('tells resolveInput to stay quiet when --json is set', async () => {
+            const { cmd, postWorkflowStart, resolveInput } = await createCommand({}, ['my_workflow', 'basic', '--json']);
+            resolveInput.mockResolvedValue({});
+            postWorkflowStart.mockResolvedValue({
+                data: { workflowId: 'wf-123' },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(resolveInput).toHaveBeenCalledWith(expect.objectContaining({ json: true }));
         });
     });
 });

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

@@ -2,7 +2,7 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 vi.mock('../../api/generated/api.js', () => ({
     getWorkflowIdStatus: vi.fn(),
     GetWorkflowIdStatus200Status: {
-        canceled: 'canceled',
+        cancelled: 'cancelled',
         completed: 'completed',
         continued_as_new: 'continued_as_new',
         failed: 'failed',

package/dist/commands/workflow/{test_eval.d.ts → test.d.ts}

@@ -1,7 +1,6 @@
 import { Command } from '@oclif/core';
 import type { EvalOutput } from '@outputai/evals';
 export default class WorkflowTest extends Command {
-    static aliases: string[];
     static description: string;
     static enableJsonFlag: boolean;
     static examples: string[];

package/dist/commands/workflow/{test_eval.js → test.js}

@@ -7,7 +7,6 @@ import { diagnoseMissingEvalWorkflow } from '#utils/eval_diagnostics.js';
 import { handleApiError } from '#utils/error_handler.js';
 import { getEvalWorkflowName, renderEvalOutput, computeExitCode, EvalOutputSchema } from '@outputai/evals';
 export default class WorkflowTest extends Command {
-    static aliases = ['workflow:test'];
     static description = 'Run evaluations against a workflow using its datasets';
     static enableJsonFlag = true;
     static examples = [

package/dist/commands/workflow/{test_eval.spec.js → test.spec.js}

@@ -45,11 +45,11 @@ describe('workflow test command', () => {
     });
     describe('command definition', () => {
         it('enables the built-in --json flag', async () => {
-            const WorkflowTest = (await import('./test_eval.js')).default;
+            const WorkflowTest = (await import('./test.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;
+            const WorkflowTest = (await import('./test.js')).default;
             expect(WorkflowTest.flags).toHaveProperty('catalog');
             expect(WorkflowTest.flags.catalog.env).toBe('OUTPUT_CATALOG_ID');
             expect(WorkflowTest.flags.catalog.char).toBe('c');
@@ -57,7 +57,7 @@ describe('workflow test command', () => {
     });
     describe('run()', () => {
         const createCommand = async (jsonEnabled) => {
-            const WorkflowTest = (await import('./test_eval.js')).default;
+            const WorkflowTest = (await import('./test.js')).default;
             const { postWorkflowRun } = await import('#api/generated/api.js');
             const cmd = new WorkflowTest(['simple'], {});
             cmd.log = vi.fn();
@@ -99,7 +99,7 @@ describe('workflow test command', () => {
             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 WorkflowTest = (await import('./test.js')).default;
             const { postWorkflowRun } = await import('#api/generated/api.js');
             const { fetchWorkflowCatalog } = await import('#api/workflow_catalog.js');
             const cmd = new WorkflowTest(['my_workflow'], {});

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.10.1-next.be4ec7f.0"
+    "framework": "0.10.1-next.bf95a6f.0"
 }

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

@@ -17,10 +17,12 @@ claude plugin install outputai@outputai --scope project
 npm run output:dev           # Start dev environment (worker + Temporal)
 npm run output:worker:build  # Build TypeScript to dist/
 npm run output:worker:check  # Optional: bundle-check workflows for bad imports (node: built-ins)
-npm run output:worker:watch  # Build + restart on file changes
-npm run output:worker        # Install, build, and start worker
+npm run output:worker:watch  # Build + restart on src/ file changes
+npm run output:worker        # Build and start worker
 ```
 
+Hot-reload watches `src/` only. After changing dependencies (`package.json` / lockfile), run `npm install`, then `npx output dev down` and `npm run output:dev` again so the worker container reinstalls. A hot-reload alone is not enough; if the stack is still running, `npx output dev down` is required.
+
 ## Project Structure
 
 ```

package/dist/templates/project/README.md.template

@@ -79,7 +79,9 @@ This starts:
 - Temporal server and UI (http://localhost:8080)
 - PostgreSQL and Redis databases
 - Output.ai API server (http://localhost:3001)
-- Worker process for executing workflows
+- Worker process for executing workflows (auto-reloads on `src/` changes)
+
+Dependency changes (`package.json` / lockfile) are not picked up by hot-reload. Run `npm install`, then `npx output dev down` and `npm run output:dev` again so the worker container reinstalls. A hot-reload alone is not enough; if the stack is still running, `npx output dev down` is required.
 
 ### 4. Run a workflow
 

package/dist/templates/project/package.json.template

@@ -9,8 +9,8 @@
     "output:worker:build": "rm -rf dist/* && tsc -p ./ && output-copy-assets",
     "output:worker:start": "output-worker",
     "output:worker:check": "output-worker --check",
-    "output:worker": "npm run output:worker:install && npm run output:worker:build && npm run output:worker:start",
-    "output:worker:watch": "npx nodemon --watch src --watch package.json --ext ts,js,json,prompt,md --ignore 'dist/**' --ignore '**/*.spec.*' --ignore '**/*.test.*' --exec 'npm run output:worker'",
+    "output:worker": "npm run output:worker:build && npm run output:worker:start",
+    "output:worker:watch": "npx nodemon --watch src --ext ts,js,json,prompt,md --ignore 'dist/**' --ignore '**/*.spec.*' --ignore '**/*.test.*' --exec 'npm run output:worker'",
     "output:dev": "output dev"
   },
   "dependencies": {

package/dist/utils/env_loader.js

@@ -5,7 +5,6 @@
  */
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
-import * as dotenv from 'dotenv';
 import debugFactory from 'debug';
 const debug = debugFactory('output-cli:env-loader');
 export function loadEnvironment() {
@@ -17,5 +16,10 @@ export function loadEnvironment() {
         return;
     }
     debug(`Loading env from: ${envPath}`);
-    dotenv.config({ path: envPath, quiet: true });
+    try {
+        process.loadEnvFile(envPath);
+    }
+    catch (err) {
+        debug(`Warning: Failed to load env file ${envPath}: ${err}`);
+    }
 }

package/dist/utils/env_loader.spec.js

@@ -1,43 +1,72 @@
-/**
- * Tests for the env loader utility
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-import * as dotenv from 'dotenv';
-vi.mock('node:fs');
-vi.mock('dotenv');
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { loadEnvironment } from './env_loader.js';
 describe('loadEnvironment', () => {
-    const originalEnv = { ...process.env };
-    const mockCwd = '/mock/project';
+    const mockCwd = mkdtempSync(join(tmpdir(), 'output-env-loader-'));
     beforeEach(() => {
-        vi.resetModules();
-        vi.clearAllMocks();
+        for (const name of readdirSync(mockCwd)) {
+            rmSync(join(mockCwd, name), { recursive: true, force: true });
+        }
         vi.spyOn(process, 'cwd').mockReturnValue(mockCwd);
-        vi.spyOn(console, 'log').mockImplementation(() => { });
-        vi.spyOn(console, 'warn').mockImplementation(() => { });
+        vi.stubEnv('OUTPUT_CLI_ENV', undefined);
+        vi.stubEnv('OUTPUT_API_URL', undefined);
+        vi.stubEnv('OUTPUT_API_TOKEN', undefined);
     });
     afterEach(() => {
-        process.env = { ...originalEnv };
         vi.restoreAllMocks();
+        vi.unstubAllEnvs();
     });
-    it('should load from OUTPUT_CLI_ENV when set and file exists', async () => {
-        process.env.OUTPUT_CLI_ENV = '.env.prod';
-        const expectedPath = resolve(mockCwd, '.env.prod');
-        vi.mocked(existsSync).mockReturnValue(true);
-        vi.mocked(dotenv.config).mockReturnValue({ parsed: { OUTPUT_API_URL: 'https://prod.api.com' } });
-        const { loadEnvironment } = await import('./env_loader.js');
+    afterAll(() => {
+        rmSync(mockCwd, { recursive: true, force: true });
+    });
+    it('loads variables from OUTPUT_CLI_ENV', () => {
+        writeFileSync(join(mockCwd, '.env'), [
+            'OUTPUT_API_URL=https://default.api.com',
+            'OUTPUT_API_TOKEN=default-token'
+        ].join('\n'));
+        writeFileSync(join(mockCwd, '.env.mock'), [
+            'OUTPUT_API_URL=https://mock.api.com',
+            'OUTPUT_API_TOKEN=mock-token'
+        ].join('\n'));
+        process.env.OUTPUT_CLI_ENV = '.env.mock';
+        loadEnvironment();
+        expect(process.env.OUTPUT_API_URL).toBe('https://mock.api.com');
+        expect(process.env.OUTPUT_API_TOKEN).toBe('mock-token');
+    });
+    it('loads variables from .env by default', () => {
+        writeFileSync(join(mockCwd, '.env'), [
+            'OUTPUT_API_URL=https://default.api.com',
+            'OUTPUT_API_TOKEN=default-token'
+        ].join('\n'));
+        writeFileSync(join(mockCwd, '.env.mock'), [
+            'OUTPUT_API_URL=https://mock.api.com',
+            'OUTPUT_API_TOKEN=mock-token'
+        ].join('\n'));
         loadEnvironment();
-        expect(dotenv.config).toHaveBeenCalledWith({ path: expectedPath, quiet: true });
-    });
-    it('should load .env by default and log', async () => {
-        delete process.env.OUTPUT_CLI_ENV;
-        const envPath = resolve(mockCwd, '.env');
-        vi.mocked(existsSync).mockImplementation(p => p === envPath);
-        vi.mocked(dotenv.config).mockReturnValue({ parsed: {} });
-        const { loadEnvironment } = await import('./env_loader.js');
+        expect(process.env.OUTPUT_API_URL).toBe('https://default.api.com');
+        expect(process.env.OUTPUT_API_TOKEN).toBe('default-token');
+    });
+    it('does nothing when the env file is missing', () => {
+        expect(() => loadEnvironment()).not.toThrow();
+        expect(process.env.OUTPUT_API_URL).toBeUndefined();
+        expect(process.env.OUTPUT_API_TOKEN).toBeUndefined();
+    });
+    it('does not throw when the env path is not a readable file', () => {
+        mkdirSync(join(mockCwd, 'not-a-file.env'));
+        process.env.OUTPUT_CLI_ENV = 'not-a-file.env';
+        expect(() => loadEnvironment()).not.toThrow();
+        expect(process.env.OUTPUT_API_URL).toBeUndefined();
+    });
+    it('does not overwrite already-set process.env values', () => {
+        vi.stubEnv('OUTPUT_API_URL', 'https://ambient.api.com');
+        writeFileSync(join(mockCwd, '.env'), [
+            'OUTPUT_API_URL=https://file.api.com',
+            'OUTPUT_API_TOKEN=file-token'
+        ].join('\n'));
         loadEnvironment();
-        expect(dotenv.config).toHaveBeenCalledTimes(1);
-        expect(dotenv.config).toHaveBeenCalledWith({ path: envPath, quiet: true });
+        expect(process.env.OUTPUT_API_URL).toBe('https://ambient.api.com');
+        expect(process.env.OUTPUT_API_TOKEN).toBe('file-token');
     });
 });

package/dist/utils/format_workflow_result.d.ts

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

package/dist/utils/format_workflow_result.js

@@ -1,5 +1,6 @@
 import { normalizeWorkflowStatus } from './normalize_workflow_status.js';
-export const ERROR_STATUSES = new Set(['failed', 'canceled', 'terminated', 'timed_out']);
+export const ERROR_STATUSES = new Set(['failed', 'cancelled', 'terminated', 'timed_out']);
+export const isErrorWorkflowStatus = (status) => ERROR_STATUSES.has(normalizeWorkflowStatus(status));
 // Every error status plus the one success status — derived so the two sets can't
 // silently drift apart as error statuses evolve. Shared by `workflow monitor` and
 // the dev TUI's `useRunDetail`/`useStepGraph` so both agree on what "done" means.
@@ -17,7 +18,10 @@ export function formatWorkflowResult(result) {
     else {
         lines.push(`Status: ${status || 'unknown'}`);
         if (result.error) {
-            lines.push(`Error: ${result.error}`);
+            const error = typeof result.error === 'string' ?
+                result.error :
+                result.error.message ?? JSON.stringify(result.error, null, 2);
+            lines.push(`Error: ${error}`);
         }
     }
     return lines.join('\n');

package/dist/utils/format_workflow_result.spec.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { formatWorkflowResult } from './format_workflow_result.js';
+import { formatWorkflowResult, isErrorWorkflowStatus } from './format_workflow_result.js';
 describe('formatWorkflowResult', () => {
     it('should display output for completed workflows', () => {
         const result = formatWorkflowResult({
@@ -13,7 +13,7 @@ describe('formatWorkflowResult', () => {
         expect(result).toContain('"values"');
         expect(result).not.toContain('Status:');
     });
-    it('should display error details for failed workflows', () => {
+    it('should display legacy string errors for failed workflows', () => {
         const result = formatWorkflowResult({
             workflowId: 'wf-456',
             status: 'failed',
@@ -25,6 +25,29 @@ describe('formatWorkflowResult', () => {
         expect(result).toContain('Error: Activity task failed');
         expect(result).not.toContain('Output:');
     });
+    it('should display the message from structured errors', () => {
+        const result = formatWorkflowResult({
+            workflowId: 'wf-v2',
+            status: 'failed',
+            output: null,
+            error: {
+                name: 'ValidationError',
+                message: 'Input is invalid',
+                code: 'INVALID_INPUT'
+            }
+        });
+        expect(result).toContain('Error: Input is invalid');
+        expect(result).not.toContain('[object Object]');
+    });
+    it('should serialize structured errors without a message', () => {
+        const result = formatWorkflowResult({
+            workflowId: 'wf-v2',
+            status: 'failed',
+            output: null,
+            error: { code: 'UNKNOWN' }
+        });
+        expect(result).toContain('"code": "UNKNOWN"');
+    });
     it('should display status for terminated workflows', () => {
         const result = formatWorkflowResult({
             workflowId: 'wf-term',
@@ -35,15 +58,25 @@ describe('formatWorkflowResult', () => {
         expect(result).toContain('Status: terminated');
         expect(result).toContain('Error: Workflow terminated by user');
     });
-    it('should display status for canceled workflows', () => {
+    it('should display status for cancelled workflows', () => {
         const result = formatWorkflowResult({
+            workflowId: 'wf-cancel',
+            status: 'cancelled',
+            output: null,
+            error: 'Workflow was cancelled'
+        });
+        expect(result).toContain('Status: cancelled');
+        expect(result).toContain('Error: Workflow was cancelled');
+    });
+    it('normalizes canceled responses without changing the current status type', () => {
+        const legacyResult = {
             workflowId: 'wf-cancel',
             status: 'canceled',
             output: null,
             error: 'Workflow was canceled'
-        });
-        expect(result).toContain('Status: canceled');
-        expect(result).toContain('Error: Workflow was canceled');
+        };
+        expect(formatWorkflowResult(legacyResult)).toContain('Status: cancelled');
+        expect(isErrorWorkflowStatus('canceled')).toBe(true);
     });
     it('should display status without error line for continued_as_new workflows', () => {
         const result = formatWorkflowResult({

package/dist/utils/normalize_workflow_status.d.ts

@@ -1,8 +1,9 @@
 /**
- * Temporary compatibility for API responses produced before CONTINUED_AS_NEW
- * was exposed as `continued_as_new`.
+ * Normalizes statuses from earlier API contracts.
+ *
+ * This can be removed after Aug, 2026
  *
  * @param status - Workflow status from the API
  * @returns Normalized workflow status
  */
-export declare const normalizeWorkflowStatus: <T extends string | null | undefined>(status: T) => T | "continued_as_new";
+export declare const normalizeWorkflowStatus: <T extends string | null | undefined>(status: T) => T | "continued_as_new" | "cancelled";

package/dist/utils/normalize_workflow_status.js

@@ -1,8 +1,17 @@
 /**
- * Temporary compatibility for API responses produced before CONTINUED_AS_NEW
- * was exposed as `continued_as_new`.
+ * Normalizes statuses from earlier API contracts.
+ *
+ * This can be removed after Aug, 2026
  *
  * @param status - Workflow status from the API
  * @returns Normalized workflow status
  */
-export const normalizeWorkflowStatus = (status) => status === 'continued' ? 'continued_as_new' : status;
+export const normalizeWorkflowStatus = (status) => {
+    if (status === 'continued') {
+        return 'continued_as_new';
+    }
+    if (status === 'canceled') {
+        return 'cancelled';
+    }
+    return status;
+};

package/dist/utils/normalize_workflow_status.spec.js

@@ -4,6 +4,9 @@ describe('normalizeWorkflowStatus', () => {
     it('temporarily maps continued to continued_as_new', () => {
         expect(normalizeWorkflowStatus('continued')).toBe('continued_as_new');
     });
+    it('maps the previous canceled spelling to cancelled', () => {
+        expect(normalizeWorkflowStatus('canceled')).toBe('cancelled');
+    });
     it('leaves other statuses and nullish values unchanged', () => {
         expect(normalizeWorkflowStatus('completed')).toBe('completed');
         expect(normalizeWorkflowStatus('continued_as_new')).toBe('continued_as_new');

package/dist/utils/resolve_input.d.ts

@@ -1 +1,9 @@
-export declare function resolveInput(workflowName: string, scenario: string | undefined, inputFlag: string | undefined, commandName: string, catalog?: string): Promise<unknown>;
+export type ResolveInputOptions = {
+    workflowName: string;
+    scenario?: string;
+    inputFlag?: string;
+    commandName: string;
+    catalog?: string;
+    json?: boolean;
+};
+export declare function resolveInput(options: ResolveInputOptions): Promise<unknown>;

package/dist/utils/resolve_input.js

@@ -1,7 +1,8 @@
 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, catalog) {
+export async function resolveInput(options) {
+    const { workflowName, scenario, inputFlag, commandName, catalog, json } = options;
     if (inputFlag && scenario) {
         return ux.error('Cannot use both scenario argument and --input flag. Choose one.', { exit: 1 });
     }
@@ -13,7 +14,12 @@ export async function resolveInput(workflowName, scenario, inputFlag, commandNam
         if (!resolution.found) {
             return ux.error(getScenarioNotFoundMessage(workflowName, scenario, resolution.searchedPaths), { exit: 1 });
         }
-        ux.stdout(`Using scenario: ${resolution.path}\n`);
+        // Advisory notice goes to stderr so stdout stays clean for piping, and is
+        // skipped entirely under --json where even stderr is noise to a script
+        // consuming the structured output (same rule as the init hook's banner).
+        if (!json) {
+            ux.stderr(`Using scenario: ${resolution.path}`);
+        }
         return parseInputFlag(resolution.path);
     }
     return ux.error('Input required. Provide either:\n' +

package/dist/utils/resolve_input.spec.d.ts

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

package/dist/utils/resolve_input.spec.js

@@ -0,0 +1,75 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('@oclif/core', () => ({
+    ux: {
+        stdout: vi.fn(),
+        stderr: vi.fn(),
+        error: vi.fn(() => {
+            throw new Error('ux.error called');
+        })
+    }
+}));
+vi.mock('#utils/input_parser.js', () => ({
+    parseInputFlag: vi.fn()
+}));
+vi.mock('#utils/scenario_resolver.js', () => ({
+    resolveScenarioPath: vi.fn(),
+    getScenarioNotFoundMessage: vi.fn()
+}));
+describe('resolveInput', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('emits the scenario notice on stderr so --json stdout stays clean', async () => {
+        const { ux } = await import('@oclif/core');
+        const { parseInputFlag } = await import('#utils/input_parser.js');
+        const { resolveScenarioPath } = await import('#utils/scenario_resolver.js');
+        const { resolveInput } = await import('./resolve_input.js');
+        vi.mocked(resolveScenarioPath).mockResolvedValue({
+            found: true,
+            path: '/scenarios/happy_path.json'
+        });
+        vi.mocked(parseInputFlag).mockReturnValue({ key: 'value' });
+        const result = await resolveInput({
+            workflowName: 'web_search',
+            scenario: 'happy_path',
+            commandName: 'start'
+        });
+        expect(result).toEqual({ key: 'value' });
+        expect(ux.stderr).toHaveBeenCalledWith('Using scenario: /scenarios/happy_path.json');
+        expect(ux.stdout).not.toHaveBeenCalled();
+    });
+    it('suppresses the scenario notice entirely under --json', async () => {
+        const { ux } = await import('@oclif/core');
+        const { parseInputFlag } = await import('#utils/input_parser.js');
+        const { resolveScenarioPath } = await import('#utils/scenario_resolver.js');
+        const { resolveInput } = await import('./resolve_input.js');
+        vi.mocked(resolveScenarioPath).mockResolvedValue({
+            found: true,
+            path: '/scenarios/happy_path.json'
+        });
+        vi.mocked(parseInputFlag).mockReturnValue({ key: 'value' });
+        const result = await resolveInput({
+            workflowName: 'web_search',
+            scenario: 'happy_path',
+            commandName: 'start',
+            json: true
+        });
+        expect(result).toEqual({ key: 'value' });
+        expect(ux.stderr).not.toHaveBeenCalled();
+        expect(ux.stdout).not.toHaveBeenCalled();
+    });
+    it('does not emit the scenario notice when input comes from --input', async () => {
+        const { ux } = await import('@oclif/core');
+        const { parseInputFlag } = await import('#utils/input_parser.js');
+        const { resolveInput } = await import('./resolve_input.js');
+        vi.mocked(parseInputFlag).mockReturnValue({ key: 'value' });
+        await resolveInput({
+            workflowName: 'web_search',
+            inputFlag: '{"key":"value"}',
+            commandName: 'start'
+        });
+        expect(ux.stderr).not.toHaveBeenCalled();
+        expect(ux.stdout).not.toHaveBeenCalled();
+    });
+});

package/dist/views/dev/components/workflow_status.js

@@ -4,7 +4,7 @@ const WORKFLOW_STATUS_MAP = {
     running: { icon: '●', color: 'yellow' },
     completed: { icon: '●', color: 'green' },
     failed: { icon: '✗', color: 'red' },
-    canceled: { icon: '○', color: 'gray' },
+    cancelled: { icon: '○', color: 'gray' },
     terminated: { icon: '✗', color: 'gray' },
     timed_out: { icon: '✗', color: 'red' },
     continued_as_new: { icon: '↻', color: 'blue' }

package/dist/views/dev/hooks/use_run_detail.js

@@ -73,7 +73,7 @@ const readTraceLog = async (source) => {
     return JSON.parse(content);
 };
 // Run detail and trace fetches are best-effort. Many statuses (in-progress,
-// failed, canceled) don't have a fully-formed result or trace available at
+// failed, cancelled) don't have a fully-formed result or trace available at
 // any given moment, and that's expected — the caller falls back to
 // EMPTY_DETAIL and the UI renders whatever's there. Swallow everything.
 const fetchTrace = async (workflowId, runId) => {

package/dist/views/dev/hooks/use_run_detail.spec.js

@@ -4,7 +4,7 @@ describe('isTerminalRunStatus', () => {
     it('returns true for completed states', () => {
         expect(isTerminalRunStatus('completed')).toBe(true);
         expect(isTerminalRunStatus('failed')).toBe(true);
-        expect(isTerminalRunStatus('canceled')).toBe(true);
+        expect(isTerminalRunStatus('cancelled')).toBe(true);
         expect(isTerminalRunStatus('terminated')).toBe(true);
         expect(isTerminalRunStatus('timed_out')).toBe(true);
     });

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

@@ -21,7 +21,7 @@ const STATUS_ORDER = {
     failed: 1,
     timed_out: 2,
     terminated: 3,
-    canceled: 4,
+    cancelled: 4,
     continued_as_new: 5,
     completed: 6
 };
@@ -110,7 +110,7 @@ const DetailPane = ({ run, pane, rows }) => {
             }
             return _jsx(Text, { dimColor: true, children: "\u2014" });
         }
-        if (activePane === 'output' && hasJsonValue(pane.error)) {
+        if (activePane === 'output' && typeof pane.error === 'string') {
             const lines = String(pane.error).split('\n').slice(0, tabContentRows);
             return (_jsx(Box, { flexDirection: "column", children: lines.map((line, i) => (_jsx(Text, { color: "red", wrap: "truncate-end", children: line }, i))) }));
         }

package/oclif.manifest.json

@@ -1236,9 +1236,17 @@
         "<%= config.bin %> <%= command.id %> simple basic_input",
         "<%= config.bin %> <%= command.id %> simple --input '{\"values\":[1,2,3]}'",
         "<%= config.bin %> <%= command.id %> simple --input input.json",
-        "<%= config.bin %> <%= command.id %> simple --input '{\"key\":\"value\"}' --catalog my-catalog"
+        "<%= config.bin %> <%= command.id %> simple --input '{\"key\":\"value\"}' --catalog my-catalog",
+        "<%= config.bin %> <%= command.id %> simple --json"
       ],
       "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "input": {
           "char": "i",
           "description": "Workflow input as JSON string or file path (overrides scenario)",
@@ -1272,7 +1280,7 @@
       "pluginName": "@outputai/cli",
       "pluginType": "core",
       "strict": true,
-      "enableJsonFlag": false,
+      "enableJsonFlag": true,
       "isESM": true,
       "relativePath": [
         "dist",
@@ -1390,10 +1398,8 @@
         "terminate.js"
       ]
     },
-    "workflow:test_eval": {
-      "aliases": [
-        "workflow:test"
-      ],
+    "workflow:test": {
+      "aliases": [],
       "args": {
         "workflowName": {
           "description": "Name of the workflow to test",
@@ -1462,7 +1468,7 @@
       },
       "hasDynamicHelp": false,
       "hiddenAliases": [],
-      "id": "workflow:test_eval",
+      "id": "workflow:test",
       "pluginAlias": "@outputai/cli",
       "pluginName": "@outputai/cli",
       "pluginType": "core",
@@ -1473,7 +1479,7 @@
         "dist",
         "commands",
         "workflow",
-        "test_eval.js"
+        "test.js"
       ]
     },
     "workflow:dataset:generate": {
@@ -1707,5 +1713,5 @@
       ]
     }
   },
-  "version": "0.10.1-next.be4ec7f.0"
+  "version": "0.10.1-next.bf95a6f.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.10.1-next.be4ec7f.0",
+  "version": "0.10.1-next.bf95a6f.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -27,20 +27,18 @@
     "cli-table3": "0.6.5",
     "date-fns": "4.1.0",
     "debug": "4.4.3",
-    "dotenv": "17.4.2",
     "handlebars": "4.7.9",
     "ink": "7.0.1",
     "ink-spinner": "5.0.0",
-    "js-yaml": "4.1.1",
+    "js-yaml": "4.3.1",
     "json-schema-library": "11.4.0",
     "ky": "2.0.2",
     "react": "19.2.5",
     "semver": "7.7.4",
-    "undici": "8.5.0",
-    "yaml": "^2.8.3",
-    "@outputai/credentials": "0.10.1-next.be4ec7f.0",
-    "@outputai/evals": "0.10.1-next.be4ec7f.0",
-    "@outputai/llm": "0.10.1-next.be4ec7f.0"
+    "undici": "8.9.0",
+    "@outputai/evals": "0.10.1-next.bf95a6f.0",
+    "@outputai/credentials": "0.10.1-next.bf95a6f.0",
+    "@outputai/llm": "0.10.1-next.bf95a6f.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",