@outputai/cli 0.10.1-next.c717e35.0 → 0.10.1-next.ca7de69.0

package/dist/utils/error_handler.js

@@ -1,3 +1,4 @@
+import { CLIError } from '@oclif/core/errors';
 import { config } from '#config.js';
 function getDefaultMessages() {
     return {
@@ -79,3 +80,16 @@ export function handleApiError(error, errorFn, overrides = {}) {
     const detailedMessage = getDetailedErrorMessage(error);
     errorFn(detailedMessage, { exit: 1 });
 }
+/**
+ * `catch()` handling for a command that raises oclif errors of its own. Flag
+ * relationship failures and every `this.error( ..., { exit } )` already carry an
+ * exit code and formatted output, and `handleApiError` would flatten all of it
+ * to a bare exit 1 — so pass those straight through and only map what actually
+ * came back from the API.
+ */
+export function handleCommandError(error, errorFn, overrides = {}) {
+    if (error instanceof CLIError) {
+        throw error;
+    }
+    return handleApiError(error, errorFn, overrides);
+}

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

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

package/dist/utils/error_handler.spec.js

@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi } from 'vitest';
+import { CLIError } from '@oclif/core/errors';
+import { handleApiError, handleCommandError } from './error_handler.js';
+const errorFn = () => vi.fn((message) => {
+    throw new Error(message);
+});
+const apiError = (status, data) => Object.assign(new Error('request failed'), { response: { status, data } });
+describe('handleApiError()', () => {
+    it('prefers a caller override over the server body for the same status', () => {
+        const fn = errorFn();
+        expect(() => handleApiError(apiError(404, { error: 'WorkflowNotFoundError', message: 'Workflow "wf-1" not found' }), fn, { 404: 'Workflow not found. Check the workflow ID.' })).toThrow('Workflow not found. Check the workflow ID.');
+    });
+    it('surfaces the server body when no override covers the status', () => {
+        const fn = errorFn();
+        // What `start --monitor` relies on now that it passes no 404 override: the
+        // API's own words, rather than advice about an id the user never typed.
+        expect(() => handleApiError(apiError(404, { error: 'WorkflowNotFoundError', message: 'Workflow "wf-1" not found' }), fn)).toThrow('WorkflowNotFoundError: Workflow "wf-1" not found.');
+    });
+    it('appends a root cause to the server message when the API reports one', () => {
+        const fn = errorFn();
+        expect(() => handleApiError(apiError(500, { error: 'StepFailure', message: 'Step failed', rootCause: { error: 'TypeError', message: 'x is not a function' } }), fn)).toThrow(/TypeError: x is not a function/);
+    });
+    it('falls back to the status default when the body carries no detail', () => {
+        const fn = errorFn();
+        expect(() => handleApiError(apiError(401), fn)).toThrow(/OUTPUT_API_AUTH_TOKEN/);
+    });
+    it.each([
+        ['a top-level code', Object.assign(new Error('connect'), { code: 'ECONNREFUSED' })],
+        ['a nested cause', Object.assign(new Error('fetch failed'), { cause: { code: 'ECONNREFUSED' } })]
+    ])('reports a refused connection from %s before looking at any status', (_label, error) => {
+        const fn = errorFn();
+        expect(() => handleApiError(error, fn)).toThrow(/Is the API server running\?/);
+    });
+    it('assembles a detailed message when there is no response at all', () => {
+        const fn = errorFn();
+        const error = Object.assign(new Error('fetch failed'), {
+            cause: Object.assign(new Error('getaddrinfo EAI_AGAIN api'), { code: 'EAI_AGAIN', hostname: 'api', port: 3001 })
+        });
+        expect(() => handleApiError(error, fn)).toThrow(/fetch failed \| Cause: getaddrinfo EAI_AGAIN api \| Code: EAI_AGAIN \| Host: api:3001/);
+    });
+    it('always exits 1, leaving a command\'s own exit codes to the command', () => {
+        const fn = errorFn();
+        expect(() => handleApiError(apiError(500), fn)).toThrow();
+        expect(fn).toHaveBeenCalledWith(expect.any(String), { exit: 1 });
+    });
+});
+describe('handleCommandError()', () => {
+    it('rethrows an oclif error untouched so its exit code and formatting survive', () => {
+        const fn = errorFn();
+        // `workflow start --monitor` raises exit 2 (bad flag combination) and exit 3
+        // (started but unmonitorable); flattening those to exit 1 would let a CI job
+        // retrying on a failed workflow re-submit one that is already running.
+        const cliError = new CLIError('Cannot combine --monitor with --json', { exit: 2 });
+        expect(() => handleCommandError(cliError, fn)).toThrow(cliError);
+        expect(fn).not.toHaveBeenCalled();
+    });
+    it('maps anything that came back from the API the same way handleApiError does', () => {
+        const fn = errorFn();
+        expect(() => handleCommandError(apiError(404), fn, { 404: 'Workflow not found. Check the workflow name.' })).toThrow('Workflow not found. Check the workflow name.');
+    });
+});

package/dist/utils/format_workflow_result.d.ts

@@ -1,6 +1,18 @@
-import type { WorkflowResultResponse, WorkflowResultResponseStatus } from '../api/generated/api.js';
+import type { WorkflowResultResponse } from '../api/generated/api.js';
 type WorkflowResult = Pick<WorkflowResultResponse, 'workflowId' | 'output' | 'status' | 'error'>;
-export declare const ERROR_STATUSES: ReadonlySet<WorkflowResultResponseStatus | undefined>;
-export declare const TERMINAL_STATUSES: ReadonlySet<string>;
+declare const ERROR_STATUS_VALUES: readonly ["failed", "cancelled", "terminated", "timed_out"];
+export type ErrorStatus = typeof ERROR_STATUS_VALUES[number];
+export type TerminalStatus = 'completed' | ErrorStatus;
+/**
+ * Maps a raw status to a canonical error status, or `undefined` if it is not one.
+ * Legacy spellings (`canceled`) are normalized so callers only ever see the
+ * current API vocabulary — until `normalizeWorkflowStatus` is removed.
+ */
+export declare function isErrorStatus(status: string | null | undefined): ErrorStatus | undefined;
+/**
+ * Maps a raw status to a canonical terminal status, or `undefined` if it is not
+ * one. Same normalization contract as `isErrorStatus`.
+ */
+export declare function isTerminalStatus(status: string | null | undefined): TerminalStatus | undefined;
 export declare function formatWorkflowResult(result: WorkflowResult): string;
 export {};

package/dist/utils/format_workflow_result.js

@@ -1,9 +1,39 @@
 import { normalizeWorkflowStatus } from './normalize_workflow_status.js';
-export const ERROR_STATUSES = new Set(['failed', 'canceled', 'terminated', 'timed_out']);
-// 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.
-export const TERMINAL_STATUSES = new Set(['completed', ...ERROR_STATUSES]);
+// `satisfies` rather than a plain annotation: it pins these to the generated API
+// union without widening them, so regenerating the API with a renamed status
+// breaks the build instead of silently making that status non-terminal.
+const ERROR_STATUS_VALUES = [
+    'failed', 'cancelled', 'terminated', 'timed_out'
+];
+const ERROR_STATUSES = new Set(ERROR_STATUS_VALUES);
+const TERMINAL_STATUSES = new Set(['completed', ...ERROR_STATUS_VALUES]);
+/**
+ * Maps a raw status to a canonical error status, or `undefined` if it is not one.
+ * Legacy spellings (`canceled`) are normalized so callers only ever see the
+ * current API vocabulary — until `normalizeWorkflowStatus` is removed.
+ */
+/* eslint-disable consistent-return -- returns ErrorStatus | undefined via early exit */
+export function isErrorStatus(status) {
+    if (typeof status !== 'string') {
+        return undefined;
+    }
+    const normalized = normalizeWorkflowStatus(status);
+    return ERROR_STATUSES.has(normalized) ? normalized : undefined;
+}
+/* eslint-enable consistent-return */
+/**
+ * Maps a raw status to a canonical terminal status, or `undefined` if it is not
+ * one. Same normalization contract as `isErrorStatus`.
+ */
+/* eslint-disable consistent-return -- returns TerminalStatus | undefined via early exit */
+export function isTerminalStatus(status) {
+    if (typeof status !== 'string') {
+        return undefined;
+    }
+    const normalized = normalizeWorkflowStatus(status);
+    return TERMINAL_STATUSES.has(normalized) ? normalized : undefined;
+}
+/* eslint-enable consistent-return */
 export function formatWorkflowResult(result) {
     const status = normalizeWorkflowStatus(result.status);
     const lines = [
@@ -17,7 +47,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, isErrorStatus } 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(isErrorStatus('canceled')).toBe('cancelled');
     });
     it('should display status without error line for continued_as_new workflows', () => {
         const result = formatWorkflowResult({

package/dist/utils/monitor_flags.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The stream's defaults when the tuning flags are not given. Caller-side, not a
+ * property of the loop: `streamWorkflowUpdates` takes all three as required
+ * options and never falls back. Single-sourced because only `workflow monitor`
+ * can hand them to oclif — `workflow start --monitor` has to apply them itself
+ * (see `gatedMonitorStreamFlags`), and a literal repeated on that side would
+ * drift the moment one of these changes.
+ */
+export declare const MONITOR_DEFAULTS: {
+    readonly interval: 2500;
+    readonly color: true;
+    readonly includePayloads: false;
+};
+/** For a command that always monitors, where oclif can apply the defaults itself. */
+export declare function monitorStreamFlags(): {
+    'include-payloads': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    interval: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    color: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+};
+/**
+ * For a command where monitoring is opt-in (`workflow start --monitor`).
+ *
+ * These carry no oclif `default` on purpose: a defaulted flag counts as present
+ * (`validateFlags` runs a relationship check whenever the parsed value is not
+ * `undefined`, and `validateDependsOn` has no `setFromDefault` exemption the way
+ * `validateExclusive` does), which triggers its own `dependsOn` check and fails
+ * every invocation that omits `--monitor` — including a plain `workflow start`.
+ * The caller applies the defaults in `run()`, so the interval's default is
+ * spelled out in the help text rather than rendered by oclif.
+ */
+export declare function gatedMonitorStreamFlags(gatedBy: string): {
+    'include-payloads': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    interval: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    color: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+};

package/dist/utils/monitor_flags.js

@@ -0,0 +1,76 @@
+import { Flags } from '@oclif/core';
+/**
+ * The stream's defaults when the tuning flags are not given. Caller-side, not a
+ * property of the loop: `streamWorkflowUpdates` takes all three as required
+ * options and never falls back. Single-sourced because only `workflow monitor`
+ * can hand them to oclif — `workflow start --monitor` has to apply them itself
+ * (see `gatedMonitorStreamFlags`), and a literal repeated on that side would
+ * drift the moment one of these changes.
+ */
+export const MONITOR_DEFAULTS = {
+    interval: 2500,
+    color: true,
+    includePayloads: false
+};
+/**
+ * Descriptions and constraints for the three flags that tune
+ * `streamWorkflowUpdates`, single-sourced so `workflow monitor` and
+ * `workflow start --monitor` can't drift apart on help text — the interval
+ * caveat in particular is easy to lose in a copy-paste.
+ */
+const PAYLOADS_DESCRIPTION = 'Include decoded step input/output payloads';
+const COLOR_DESCRIPTION = 'Colorize status output (use --no-color to disable)';
+const INTERVAL_DESCRIPTION = 'Poll interval in milliseconds. Once a resumed poll is long-polling ' +
+    'server-side for new events, this also bounds how long that block may last (capped at the ' +
+    'server\'s configured max), so an idle workflow\'s update cadence is roughly twice this value ' +
+    '(the long-poll bound, then this sleep) rather than a much longer, separate server default.';
+/** For a command that always monitors, where oclif can apply the defaults itself. */
+export function monitorStreamFlags() {
+    return {
+        'include-payloads': Flags.boolean({
+            description: PAYLOADS_DESCRIPTION,
+            default: MONITOR_DEFAULTS.includePayloads
+        }),
+        interval: Flags.integer({
+            description: INTERVAL_DESCRIPTION,
+            default: MONITOR_DEFAULTS.interval,
+            min: 1
+        }),
+        color: Flags.boolean({
+            description: COLOR_DESCRIPTION,
+            default: MONITOR_DEFAULTS.color,
+            allowNo: true
+        })
+    };
+}
+/**
+ * For a command where monitoring is opt-in (`workflow start --monitor`).
+ *
+ * These carry no oclif `default` on purpose: a defaulted flag counts as present
+ * (`validateFlags` runs a relationship check whenever the parsed value is not
+ * `undefined`, and `validateDependsOn` has no `setFromDefault` exemption the way
+ * `validateExclusive` does), which triggers its own `dependsOn` check and fails
+ * every invocation that omits `--monitor` — including a plain `workflow start`.
+ * The caller applies the defaults in `run()`, so the interval's default is
+ * spelled out in the help text rather than rendered by oclif.
+ */
+export function gatedMonitorStreamFlags(gatedBy) {
+    const gate = { dependsOn: [gatedBy], helpGroup: 'MONITOR' };
+    const requires = ` (requires --${gatedBy})`;
+    return {
+        'include-payloads': Flags.boolean({
+            description: `${PAYLOADS_DESCRIPTION}${requires}`,
+            ...gate
+        }),
+        interval: Flags.integer({
+            description: `${INTERVAL_DESCRIPTION}${requires} [default: ${MONITOR_DEFAULTS.interval}]`,
+            min: 1,
+            ...gate
+        }),
+        color: Flags.boolean({
+            description: `${COLOR_DESCRIPTION}${requires}`,
+            allowNo: true,
+            ...gate
+        })
+    };
+}

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/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

@@ -2,7 +2,7 @@ import { useEffect, useRef, useState } from 'react';
 import { readFile } from 'node:fs/promises';
 import { getWorkflowIdResult, getWorkflowIdRunsRidResult, getWorkflowIdTraceLog, getWorkflowIdRunsRidTraceLog } from '#api/generated/api.js';
 import { normalizeWorkflowStatus } from '#utils/normalize_workflow_status.js';
-import { TERMINAL_STATUSES } from '#utils/format_workflow_result.js';
+import { isTerminalStatus } from '#utils/format_workflow_result.js';
 import { createBoundedCache } from '#views/dev/utils/bounded_cache.js';
 const EMPTY_DETAIL = {
     result: null,
@@ -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) => {
@@ -104,8 +104,8 @@ const fetchResult = async (workflowId, runId) => {
 };
 // The cache is intentionally only populated for terminal statuses — partial results
 // from a still-running workflow would otherwise stick and stall the UI when the run
-// eventually finishes. `TERMINAL_STATUSES` is shared with `workflow monitor`.
-export const isTerminalRunStatus = (status) => Boolean(status && TERMINAL_STATUSES.has(status));
+// eventually finishes. `isTerminalStatus` is shared with `workflow monitor`.
+export const isTerminalRunStatus = (status) => isTerminalStatus(status) !== undefined;
 export const useRunDetail = (workflowId, runId, status) => {
     const [detail, setDetail] = useState(EMPTY_DETAIL);
     const fetchIdRef = useRef(0);

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,6 +1236,7 @@
         "<%= 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 input.json --monitor",
         "<%= config.bin %> <%= command.id %> simple --input '{\"key\":\"value\"}' --catalog my-catalog",
         "<%= config.bin %> <%= command.id %> simple --json"
       ],
@@ -1271,6 +1272,44 @@
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
+        },
+        "monitor": {
+          "char": "m",
+          "description": "After starting, attach and stream status updates until the workflow ends (Ctrl+C detaches; the workflow keeps running). Cannot be combined with --json",
+          "name": "monitor",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "include-payloads": {
+          "dependsOn": [
+            "monitor"
+          ],
+          "description": "Include decoded step input/output payloads (requires --monitor)",
+          "helpGroup": "MONITOR",
+          "name": "include-payloads",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "interval": {
+          "dependsOn": [
+            "monitor"
+          ],
+          "description": "Poll interval in milliseconds. Once a resumed poll is long-polling server-side for new events, this also bounds how long that block may last (capped at the server's configured max), so an idle workflow's update cadence is roughly twice this value (the long-poll bound, then this sleep) rather than a much longer, separate server default. (requires --monitor) [default: 2500]",
+          "helpGroup": "MONITOR",
+          "name": "interval",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "color": {
+          "dependsOn": [
+            "monitor"
+          ],
+          "description": "Colorize status output (use --no-color to disable) (requires --monitor)",
+          "helpGroup": "MONITOR",
+          "name": "color",
+          "allowNo": true,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -1713,5 +1752,5 @@
       ]
     }
   },
-  "version": "0.10.1-next.c717e35.0"
+  "version": "0.10.1-next.ca7de69.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.10.1-next.c717e35.0",
+  "version": "0.10.1-next.ca7de69.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -30,15 +30,15 @@
     "handlebars": "4.7.9",
     "ink": "7.0.1",
     "ink-spinner": "5.0.0",
-    "js-yaml": "4.3.0",
+    "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.9.0",
-    "@outputai/credentials": "0.10.1-next.c717e35.0",
-    "@outputai/llm": "0.10.1-next.c717e35.0",
-    "@outputai/evals": "0.10.1-next.c717e35.0"
+    "@outputai/evals": "0.10.1-next.ca7de69.0",
+    "@outputai/credentials": "0.10.1-next.ca7de69.0",
+    "@outputai/llm": "0.10.1-next.ca7de69.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",