@outputai/cli 0.7.1-next.d67ad85.0 → 0.7.1-next.db8ddd7.0

package/dist/services/workflow_runs.js

@@ -2,6 +2,7 @@
  * Workflow runs service for fetching workflow run data from the API
  */
 import { getWorkflowRuns } from '#api/generated/api.js';
+import { normalizeWorkflowStatus } from '#utils/normalize_workflow_status.js';
 export async function fetchWorkflowRuns(options = {}) {
     const params = {};
     if (options.limit) {
@@ -21,8 +22,12 @@ export async function fetchWorkflowRuns(options = {}) {
         throw new Error('API returned invalid response (missing data)');
     }
     const data = response.data;
+    const runs = (data.runs || []).map(run => ({
+        ...run,
+        status: normalizeWorkflowStatus(run.status)
+    }));
     return {
-        runs: data.runs || [],
+        runs,
         count: data.count || 0
     };
 }

package/dist/types/cost.d.ts

@@ -2,6 +2,10 @@
  * Cost Calculator Types
  *
  * TypeScript interfaces for trace parsing, pricing configuration, and cost reports.
+ *
+ * Costs are sourced from the trace events themselves (the as-charged "original"
+ * cost), with `costs.yml` applied as an optional override layer (the "adjusted"
+ * cost). Both figures are surfaced per model and per host.
  */
 export interface TokenUsage {
     inputTokens?: number;
@@ -9,6 +13,25 @@ export interface TokenUsage {
     cachedInputTokens?: number;
     reasoningTokens?: number;
 }
+export type { LLMUsageEvent } from '@outputai/llm';
+import type { LLMUsageEvent } from '@outputai/llm';
+export type LLMUsageLine = LLMUsageEvent['usage'][number];
+export interface HTTPCostEvent {
+    type: 'http:request:cost';
+    url: string;
+    requestId: string;
+    total: number;
+}
+export interface HTTPCountEvent {
+    type: 'http:request:count';
+    url: string;
+    requestId: string;
+}
+export interface NodeAttributes {
+    'llm:usage'?: LLMUsageEvent;
+    'http:request:cost'?: HTTPCostEvent;
+    'http:request:count'?: HTTPCountEvent;
+}
 export interface TraceNode {
     id?: string;
     kind: string;
@@ -17,15 +40,16 @@ export interface TraceNode {
     endedAt?: number;
     children?: TraceNode[];
     input?: Record<string, unknown>;
-    output?: Record<string, unknown> & {
-        usage?: TokenUsage;
-    };
+    output?: Record<string, unknown>;
+    attributes?: NodeAttributes;
 }
 export interface LLMCall {
     stepName: string;
     llmName: string;
     model: string;
     usage: TokenUsage;
+    originalCost: number;
+    lines: LLMUsageLine[];
 }
 export interface HTTPCall {
     stepName: string;
@@ -34,6 +58,8 @@ export interface HTTPCall {
     input: Record<string, unknown>;
     output: Record<string, unknown>;
     status?: number;
+    host: string;
+    originalCost?: number;
 }
 export interface ModelPricing {
     provider: string;
@@ -80,47 +106,60 @@ export interface LLMCostResult {
     output: number;
     cached: number;
     reasoning: number;
-    cost: number;
-    warning?: string;
+    originalCost: number;
+    adjustedCost: number;
 }
 export interface ServiceCostResult {
     step: string;
     cost: number;
     usage: string;
+    kind: 'computed' | 'estimated' | 'failed';
     model?: string;
     endpoint?: string;
     warning?: string;
     details?: Record<string, unknown>;
 }
-export interface ServiceCostSummary {
-    serviceName: string;
-    calls: ServiceCostResult[];
-    totalCost: number;
+export interface HTTPCostResult {
+    step: string;
+    host: string;
+    usage: string;
+    originalCost: number;
+    adjustedCost: number;
+}
+export interface HostCostSummary {
+    host: string;
+    calls: HTTPCostResult[];
+    originalTotalCost: number;
+    adjustedTotalCost: number;
 }
 export interface CostReport {
     traceFile: string;
     workflowName: string;
     durationMs: number | null;
     llmCalls: LLMCostResult[];
-    llmTotalCost: number;
+    llmOriginalCost: number;
+    llmAdjustedCost: number;
     totalInputTokens: number;
     totalOutputTokens: number;
     totalCachedTokens: number;
     totalReasoningTokens: number;
-    unknownModels: string[];
-    services: ServiceCostSummary[];
-    serviceTotalCost: number;
+    httpCosts: HostCostSummary[];
+    httpOriginalCost: number;
+    httpAdjustedCost: number;
+    originalTotalCost: number;
     totalCost: number;
 }
 export interface LLMModelSummary {
     model: string;
     count: number;
-    cost: number;
+    originalCost: number;
+    adjustedCost: number;
 }
-export interface ServiceSummary {
-    serviceName: string;
+export interface HostSummary {
+    host: string;
     callCount: number;
-    cost: number;
+    originalCost: number;
+    adjustedCost: number;
 }
 export interface VerboseFlags {
     hasReasoning: boolean;
@@ -132,18 +171,20 @@ export interface ParsedCostData {
     duration: string;
     llmModels: LLMModelSummary[];
     llmTotalCalls: number;
-    llmTotalCost: number;
-    services: ServiceSummary[];
-    serviceTotalCalls: number;
-    serviceTotalCost: number;
+    llmOriginalCost: number;
+    llmAdjustedCost: number;
+    hosts: HostSummary[];
+    httpTotalCalls: number;
+    httpOriginalCost: number;
+    httpAdjustedCost: number;
     verbose: VerboseFlags;
     llmCalls: LLMCostResult[];
-    serviceDetails: ServiceCostSummary[];
+    httpDetails: HostCostSummary[];
     totalInputTokens: number;
     totalOutputTokens: number;
     totalCachedTokens: number;
     totalReasoningTokens: number;
+    originalTotalCost: number;
     totalCost: number;
-    unknownModels: string[];
     isEmpty: boolean;
 }

package/dist/types/cost.js

@@ -2,5 +2,9 @@
  * Cost Calculator Types
  *
  * TypeScript interfaces for trace parsing, pricing configuration, and cost reports.
+ *
+ * Costs are sourced from the trace events themselves (the as-charged "original"
+ * cost), with `costs.yml` applied as an optional override layer (the "adjusted"
+ * cost). Both figures are surfaced per model and per host.
  */
 export {};

package/dist/utils/cost_formatter.js

@@ -29,76 +29,96 @@ export function parseCostData(report) {
     const byModel = {};
     for (const r of report.llmCalls) {
         if (!byModel[r.model]) {
-            byModel[r.model] = { count: 0, cost: 0 };
+            byModel[r.model] = { count: 0, originalCost: 0, adjustedCost: 0 };
         }
         byModel[r.model].count++;
-        byModel[r.model].cost += r.cost;
+        byModel[r.model].originalCost += r.originalCost;
+        byModel[r.model].adjustedCost += r.adjustedCost;
     }
     const llmModels = Object.entries(byModel)
-        .sort((a, b) => b[1].cost - a[1].cost)
-        .map(([model, stats]) => ({ model, count: stats.count, cost: stats.cost }));
-    const services = [...report.services]
-        .sort((a, b) => b.totalCost - a.totalCost)
-        .map(s => ({ serviceName: s.serviceName, callCount: s.calls.length, cost: s.totalCost }));
-    const serviceTotalCalls = services.reduce((sum, s) => sum + s.callCount, 0);
+        .sort((a, b) => b[1].adjustedCost - a[1].adjustedCost)
+        .map(([model, s]) => ({ model, ...s }));
+    const hosts = [...report.httpCosts]
+        .sort((a, b) => b.adjustedTotalCost - a.adjustedTotalCost)
+        .map(h => ({
+        host: h.host,
+        callCount: h.calls.length,
+        originalCost: h.originalTotalCost,
+        adjustedCost: h.adjustedTotalCost
+    }));
+    const httpTotalCalls = hosts.reduce((sum, h) => sum + h.callCount, 0);
     return {
         traceFile: report.traceFile,
         workflowName: report.workflowName,
         duration: report.durationMs ? `${(report.durationMs / 1000).toFixed(1)}s` : 'N/A',
         llmModels,
         llmTotalCalls: report.llmCalls.length,
-        llmTotalCost: report.llmTotalCost,
-        services,
-        serviceTotalCalls,
-        serviceTotalCost: report.serviceTotalCost,
+        llmOriginalCost: report.llmOriginalCost,
+        llmAdjustedCost: report.llmAdjustedCost,
+        hosts,
+        httpTotalCalls,
+        httpOriginalCost: report.httpOriginalCost,
+        httpAdjustedCost: report.httpAdjustedCost,
         verbose: {
             hasReasoning: report.totalReasoningTokens > 0,
             hasCached: report.totalCachedTokens > 0
         },
         llmCalls: report.llmCalls,
-        serviceDetails: report.services,
+        httpDetails: report.httpCosts,
         totalInputTokens: report.totalInputTokens,
         totalOutputTokens: report.totalOutputTokens,
         totalCachedTokens: report.totalCachedTokens,
         totalReasoningTokens: report.totalReasoningTokens,
+        originalTotalCost: report.originalTotalCost,
         totalCost: report.totalCost,
-        unknownModels: report.unknownModels,
-        isEmpty: report.llmCalls.length === 0 && report.services.length === 0
+        isEmpty: report.llmCalls.length === 0 && report.httpCosts.length === 0
     };
 }
 function formatSummary(data) {
     const lines = [];
     if (data.llmModels.length > 0) {
         const table = new Table({
-            head: ['Model', 'Calls', 'Cost'],
+            head: ['Model', 'Calls', 'Original', 'Adjusted'],
             style: { head: ['cyan'] },
-            colAligns: ['left', 'right', 'right']
+            colAligns: ['left', 'right', 'right', 'right']
         });
         for (const m of data.llmModels) {
-            table.push([m.model, pluralize(m.count, 'call'), formatCurrency(m.cost)]);
+            table.push([
+                m.model,
+                pluralize(m.count, 'call'),
+                formatCurrency(m.originalCost),
+                formatCurrency(m.adjustedCost)
+            ]);
         }
         table.push([
             'Subtotal',
             pluralize(data.llmTotalCalls, 'call'),
-            formatCurrency(data.llmTotalCost)
+            formatCurrency(data.llmOriginalCost),
+            formatCurrency(data.llmAdjustedCost)
         ]);
         lines.push('LLM Costs:');
         lines.push(table.toString());
         lines.push('');
     }
-    if (data.services.length > 0) {
+    if (data.hosts.length > 0) {
         const table = new Table({
-            head: ['Service', 'Calls', 'Cost'],
+            head: ['Host', 'Calls', 'Original', 'Adjusted'],
             style: { head: ['cyan'] },
-            colAligns: ['left', 'right', 'right']
+            colAligns: ['left', 'right', 'right', 'right']
         });
-        for (const s of data.services) {
-            table.push([s.serviceName, pluralize(s.callCount, 'call'), formatCurrency(s.cost)]);
+        for (const h of data.hosts) {
+            table.push([
+                h.host,
+                pluralize(h.callCount, 'call'),
+                formatCurrency(h.originalCost),
+                formatCurrency(h.adjustedCost)
+            ]);
         }
         table.push([
             'Subtotal',
-            pluralize(data.serviceTotalCalls, 'call'),
-            formatCurrency(data.serviceTotalCost)
+            pluralize(data.httpTotalCalls, 'call'),
+            formatCurrency(data.httpOriginalCost),
+            formatCurrency(data.httpAdjustedCost)
         ]);
         lines.push('API Costs:');
         lines.push(table.toString());
@@ -119,8 +139,8 @@ function formatVerbose(data) {
             head.push('Reasoning');
             colAligns.push('right');
         }
-        head.push('Cost');
-        colAligns.push('right');
+        head.push('Original', 'Adjusted');
+        colAligns.push('right', 'right');
         const table = new Table({
             head,
             style: { head: ['cyan'] },
@@ -139,7 +159,7 @@ function formatVerbose(data) {
             if (data.verbose.hasReasoning) {
                 row.push(formatNumber(r.reasoning));
             }
-            row.push(formatCurrency(r.cost) + (r.warning ? ` (${r.warning})` : ''));
+            row.push(formatCurrency(r.originalCost), formatCurrency(r.adjustedCost));
             table.push(row);
         }
         const totalRow = [
@@ -154,29 +174,34 @@ function formatVerbose(data) {
         if (data.verbose.hasReasoning) {
             totalRow.push(formatNumber(data.totalReasoningTokens));
         }
-        totalRow.push(formatCurrency(data.llmTotalCost));
+        totalRow.push(formatCurrency(data.llmOriginalCost), formatCurrency(data.llmAdjustedCost));
         table.push(totalRow);
         lines.push('LLM Calls:');
         lines.push(table.toString());
         lines.push('');
     }
-    if (data.serviceDetails.length > 0) {
+    if (data.httpDetails.length > 0) {
         const table = new Table({
-            head: ['Service', 'Step', 'Usage', 'Cost'],
+            head: ['Host', 'Step', 'Usage', 'Original', 'Adjusted'],
             style: { head: ['cyan'] },
-            colAligns: ['left', 'left', 'right', 'right']
+            colAligns: ['left', 'left', 'right', 'right', 'right']
         });
-        for (const service of data.serviceDetails) {
-            for (const call of service.calls) {
+        for (const host of data.httpDetails) {
+            for (const call of host.calls) {
                 table.push([
-                    service.serviceName,
+                    host.host,
                     call.step,
                     call.usage,
-                    formatCurrency(call.cost)
+                    formatCurrency(call.originalCost),
+                    formatCurrency(call.adjustedCost)
                 ]);
             }
         }
-        table.push(['Subtotal', '', '', formatCurrency(data.serviceTotalCost)]);
+        table.push([
+            'Subtotal', '', '',
+            formatCurrency(data.httpOriginalCost),
+            formatCurrency(data.httpAdjustedCost)
+        ]);
         lines.push('API Calls:');
         lines.push(table.toString());
         lines.push('');
@@ -203,13 +228,10 @@ export function formatCostReport(report, options = {}) {
             colAligns: ['left', 'right'],
             colWidths: [36, 12]
         });
-        totalTable.push(['TOTAL ESTIMATED COST', formatCurrency(data.totalCost)]);
+        totalTable.push(['TOTAL ESTIMATED COST (adjusted)', formatCurrency(data.totalCost)]);
+        totalTable.push(['As-charged (from trace)', formatCurrency(data.originalTotalCost)]);
         lines.push(totalTable.toString());
     }
-    if (data.unknownModels.length > 0) {
-        lines.push('');
-        lines.push(`Warning: Unknown models (add to config/costs.yml): ${data.unknownModels.join(', ')}`);
-    }
     if (data.isEmpty) {
         lines.push('No billable calls found in trace.');
     }

package/dist/utils/format_workflow_result.js

@@ -1,15 +1,17 @@
+import { normalizeWorkflowStatus } from './normalize_workflow_status.js';
 export const ERROR_STATUSES = new Set(['failed', 'canceled', 'terminated', 'timed_out']);
 export function formatWorkflowResult(result) {
+    const status = normalizeWorkflowStatus(result.status);
     const lines = [
         `Workflow ID: ${result.workflowId || 'unknown'}`,
         ''
     ];
-    if (result.status === 'completed') {
+    if (status === 'completed') {
         lines.push('Output:');
         lines.push(JSON.stringify(result.output, null, 2));
     }
     else {
-        lines.push(`Status: ${result.status || 'unknown'}`);
+        lines.push(`Status: ${status || 'unknown'}`);
         if (result.error) {
             lines.push(`Error: ${result.error}`);
         }

package/dist/utils/format_workflow_result.spec.js

@@ -46,16 +46,26 @@ describe('formatWorkflowResult', () => {
         expect(result).toContain('Status: canceled');
         expect(result).toContain('Error: Workflow was canceled');
     });
-    it('should display status without error line for continued workflows', () => {
+    it('should display status without error line for continued_as_new workflows', () => {
         const result = formatWorkflowResult({
             workflowId: 'wf-cont',
-            status: 'continued',
+            status: 'continued_as_new',
             output: null,
             error: null
         });
-        expect(result).toContain('Status: continued');
+        expect(result).toContain('Status: continued_as_new');
         expect(result).not.toContain('Error:');
     });
+    it('temporarily normalizes legacy continued status to continued_as_new', () => {
+        const legacyResult = {
+            workflowId: 'wf-cont',
+            status: 'continued',
+            output: null,
+            error: null
+        };
+        const result = formatWorkflowResult(legacyResult);
+        expect(result).toContain('Status: continued_as_new');
+    });
     it('should omit error line when error is null on failed workflow', () => {
         const result = formatWorkflowResult({
             workflowId: 'wf-789',

package/dist/utils/normalize_workflow_status.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Temporary compatibility for API responses produced before CONTINUED_AS_NEW
+ * was exposed as `continued_as_new`.
+ *
+ * @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";

package/dist/utils/normalize_workflow_status.js

@@ -0,0 +1,8 @@
+/**
+ * Temporary compatibility for API responses produced before CONTINUED_AS_NEW
+ * was exposed as `continued_as_new`.
+ *
+ * @param status - Workflow status from the API
+ * @returns Normalized workflow status
+ */
+export const normalizeWorkflowStatus = (status) => status === 'continued' ? 'continued_as_new' : status;

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

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

package/dist/utils/normalize_workflow_status.spec.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeWorkflowStatus } from './normalize_workflow_status.js';
+describe('normalizeWorkflowStatus', () => {
+    it('temporarily maps continued to continued_as_new', () => {
+        expect(normalizeWorkflowStatus('continued')).toBe('continued_as_new');
+    });
+    it('leaves other statuses and nullish values unchanged', () => {
+        expect(normalizeWorkflowStatus('completed')).toBe('completed');
+        expect(normalizeWorkflowStatus('continued_as_new')).toBe('continued_as_new');
+        expect(normalizeWorkflowStatus(null)).toBeNull();
+        expect(normalizeWorkflowStatus(undefined)).toBeUndefined();
+    });
+});

package/dist/utils/scenario_resolver.js

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
-import { getWorkflowCatalog } from '#api/generated/api.js';
+import { fetchWorkflowCatalog } from '#api/workflow_catalog.js';
 import { getWorkflowsBasePath } from '#utils/paths.js';
 const SCENARIOS_DIR = 'scenarios';
 const WORKFLOWS_PATHS = ['src/workflows', 'workflows'];
@@ -30,17 +30,9 @@ export function findWorkflowDirectoryFromPath(workflowPath, basePath = getWorkfl
 }
 async function fetchWorkflowPath(workflowName) {
     try {
-        const response = await getWorkflowCatalog();
-        const data = response?.data;
-        const workflows = data?.workflows;
-        if (!workflows) {
-            return null;
-        }
+        const workflows = await fetchWorkflowCatalog();
         const workflow = workflows.find(w => w.name === workflowName);
-        if (!workflow) {
-            return null;
-        }
-        return workflow.path ?? null;
+        return workflow?.path ?? null;
     }
     catch {
         return null;

package/dist/utils/scenario_resolver.spec.js

@@ -1,23 +1,19 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
 import { resolveScenarioPath, getScenarioNotFoundMessage, extractWorkflowRelativePath, findWorkflowDirectoryFromPath, listScenariosForWorkflow } from './scenario_resolver.js';
 import * as fs from 'node:fs';
-import * as api from '#api/generated/api.js';
+import * as catalog from '#api/workflow_catalog.js';
 vi.mock('node:fs', () => ({
     existsSync: vi.fn(),
     readdirSync: vi.fn()
 }));
-vi.mock('#api/generated/api.js', () => ({
-    getWorkflowCatalog: vi.fn()
+vi.mock('#api/workflow_catalog.js', () => ({
+    fetchWorkflowCatalog: vi.fn()
 }));
 function mockCatalog(workflows) {
-    vi.mocked(api.getWorkflowCatalog).mockResolvedValue({
-        data: { workflows },
-        status: 200,
-        headers: new Headers()
-    });
+    vi.mocked(catalog.fetchWorkflowCatalog).mockResolvedValue(workflows);
 }
 function mockCatalogFailure() {
-    vi.mocked(api.getWorkflowCatalog).mockRejectedValue(new Error('API unavailable'));
+    vi.mocked(catalog.fetchWorkflowCatalog).mockRejectedValue(new Error('API unavailable'));
 }
 describe('extractWorkflowRelativePath', () => {
     it('should extract relative path from workflow.js path', () => {

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

@@ -7,7 +7,7 @@ const WORKFLOW_STATUS_MAP = {
     canceled: { icon: '○', color: 'gray' },
     terminated: { icon: '✗', color: 'gray' },
     timed_out: { icon: '✗', color: 'red' },
-    continued: { icon: '↻', color: 'blue' }
+    continued_as_new: { icon: '↻', color: 'blue' }
 };
 const DEFAULT_DISPLAY = { icon: '?', color: 'white' };
 export const resolveWorkflowStatus = (status) => WORKFLOW_STATUS_MAP[status] ?? DEFAULT_DISPLAY;

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

@@ -1,6 +1,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';
 const EMPTY_DETAIL = {
     result: null,
     trace: null,
@@ -88,7 +89,11 @@ const fetchResult = async (workflowId, runId) => {
         const response = runId ?
             await getWorkflowIdRunsRidResult(workflowId, runId) :
             await getWorkflowIdResult(workflowId);
-        return response.data;
+        const data = response.data;
+        return {
+            ...data,
+            status: normalizeWorkflowStatus(data.status)
+        };
     }
     catch {
         return null;

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

@@ -10,7 +10,7 @@ describe('isTerminalRunStatus', () => {
     });
     it('returns false for in-progress states', () => {
         expect(isTerminalRunStatus('running')).toBe(false);
-        expect(isTerminalRunStatus('continued')).toBe(false);
+        expect(isTerminalRunStatus('continued_as_new')).toBe(false);
     });
     it('returns false for nullish input', () => {
         expect(isTerminalRunStatus(null)).toBe(false);

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

@@ -1,16 +1,12 @@
 import { useState } from 'react';
-import { getWorkflowCatalog } from '#api/generated/api.js';
+import { fetchWorkflowCatalog } from '#api/workflow_catalog.js';
 import { usePoll } from '#views/dev/hooks/use_poll.js';
 const CATALOG_INTERVAL_MS = 10_000;
 export const useWorkflowCatalog = (enabled) => {
     const [workflows, setWorkflows] = useState([]);
     usePoll(enabled, CATALOG_INTERVAL_MS, async () => {
         try {
-            const response = await getWorkflowCatalog();
-            const data = response?.data;
-            if (data?.workflows) {
-                setWorkflows(data.workflows);
-            }
+            setWorkflows(await fetchWorkflowCatalog());
         }
         catch {
             // API may not be ready yet

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

@@ -22,7 +22,7 @@ const STATUS_ORDER = {
     timed_out: 2,
     terminated: 3,
     canceled: 4,
-    continued: 5,
+    continued_as_new: 5,
     completed: 6
 };
 const sortRuns = (runs) => [...runs].sort((a, b) => {

package/oclif.manifest.json

@@ -704,9 +704,26 @@
         "<%= config.bin %> <%= command.id %> --format table",
         "<%= config.bin %> <%= command.id %> --format json",
         "<%= config.bin %> <%= command.id %> --detailed",
-        "<%= config.bin %> <%= command.id %> --filter simple"
+        "<%= config.bin %> <%= command.id %> --filter simple",
+        "<%= config.bin %> <%= command.id %> --catalog my-catalog"
       ],
       "flags": {
+        "catalog": {
+          "aliases": [
+            "task-queue"
+          ],
+          "char": "c",
+          "charAliases": [
+            "q"
+          ],
+          "deprecateAliases": true,
+          "description": "Catalog to list workflows from (defaults to OUTPUT_CATALOG_ID)",
+          "env": "OUTPUT_CATALOG_ID",
+          "name": "catalog",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "format": {
           "char": "f",
           "description": "Output format",
@@ -1424,5 +1441,5 @@
       ]
     }
   },
-  "version": "0.7.1-next.d67ad85.0"
+  "version": "0.7.1-next.db8ddd7.0"
 }