@outputai/cli 0.8.0 → 0.8.1-dev.945f2f2.0

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.8.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.8.1-dev.945f2f2.0}
     init: true
     networks:
       - main

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

@@ -79,7 +79,7 @@ export default class DatasetGenerate extends Command {
         const { workflowId, output } = response.data;
         const executionTimeMs = await getExecutionTime(workflowId);
         const dataset = buildDataset(datasetName, resolvedInput, output, executionTimeMs);
-        const dir = resolveDefaultDatasetsDir(workflowName);
+        const dir = await resolveDefaultDatasetsDir(workflowName);
         const filePath = join(dir, `${datasetName}.yml`);
         await writeDataset(dataset, filePath);
         this.log(`Dataset saved: ${filePath}`);
@@ -91,7 +91,7 @@ export default class DatasetGenerate extends Command {
         const extracted = extractDatasetFromTrace(traceData);
         const datasetName = nameOverride ?? extractDatasetName(tracePath);
         const dataset = buildDataset(datasetName, extracted.input, extracted.output, extracted.executionTimeMs);
-        const dir = resolveDefaultDatasetsDir(workflowName);
+        const dir = await resolveDefaultDatasetsDir(workflowName);
         const filePath = join(dir, `${datasetName}.yml`);
         await writeDataset(dataset, filePath);
         this.log(`Dataset saved: ${filePath}`);
@@ -104,7 +104,7 @@ export default class DatasetGenerate extends Command {
             return;
         }
         this.log(`Found ${traces.length} trace(s). Downloading...`);
-        const dir = resolveDefaultDatasetsDir(workflowName);
+        const dir = await resolveDefaultDatasetsDir(workflowName);
         for (const trace of traces) {
             const traceData = await downloadRemoteTrace(trace.key);
             const extracted = extractDatasetFromTrace(traceData);

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

@@ -13,6 +13,7 @@ export default class WorkflowTest extends Command {
         format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
+    private ensureEvalWorkflowRegistered;
     private validateDatasets;
     private runWorkflowForDatasets;
     private saveEvalResults;

package/dist/commands/workflow/test_eval.js

@@ -2,6 +2,8 @@ import { join } from 'node:path';
 import { Args, Command, Flags } from '@oclif/core';
 import { postWorkflowRun } from '#api/generated/api.js';
 import { readAllDatasets, writeDataset } from '#services/datasets.js';
+import { fetchWorkflowCatalog } from '#api/workflow_catalog.js';
+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 {
@@ -45,6 +47,8 @@ export default class WorkflowTest extends Command {
     async run() {
         const { args, flags } = await this.parse(WorkflowTest);
         const filterNames = flags.dataset?.split(',').map(s => s.trim());
+        const evalName = getEvalWorkflowName(args.workflowName);
+        await this.ensureEvalWorkflowRegistered(args.workflowName, evalName);
         const { datasets, dir } = await readAllDatasets(args.workflowName, filterNames);
         if (datasets.length === 0) {
             this.error(`No datasets found for workflow "${args.workflowName}".\n` +
@@ -53,7 +57,6 @@ export default class WorkflowTest extends Command {
         const preparedDatasets = flags.cached ?
             this.validateDatasets(datasets) :
             await this.runWorkflowForDatasets(args.workflowName, datasets, flags.save, dir);
-        const evalName = getEvalWorkflowName(args.workflowName);
         this.log(`Running eval workflow "${evalName}"...\n`);
         const response = await postWorkflowRun({
             workflowName: evalName,
@@ -80,6 +83,12 @@ export default class WorkflowTest extends Command {
             this.exit(exitCode);
         }
     }
+    async ensureEvalWorkflowRegistered(workflowName, evalName) {
+        const catalog = await fetchWorkflowCatalog().catch(() => null);
+        if (catalog && !catalog.some(w => w.name === evalName)) {
+            this.error(await diagnoseMissingEvalWorkflow(workflowName), { exit: 1 });
+        }
+    }
     validateDatasets(datasets) {
         const missing = datasets.filter(d => d.last_output?.output === undefined);
         if (missing.length > 0) {

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.8.0"
+    "framework": "0.8.1-dev.945f2f2.0"
 }

package/dist/services/datasets.d.ts

@@ -6,8 +6,8 @@ export interface DatasetInfo {
     lastOutputDate?: string;
     lastEvalDate?: string;
 }
-export declare function resolveDatasetsDir(workflowName: string, basePath?: string): string | null;
-export declare function resolveDefaultDatasetsDir(workflowName: string, basePath?: string): string;
+export declare function resolveDatasetsDir(workflowName: string, basePath?: string, workflowPath?: string): Promise<string | null>;
+export declare function resolveDefaultDatasetsDir(workflowName: string, basePath?: string, workflowPath?: string): Promise<string>;
 export declare function readDatasetFile(filePath: string): Promise<Dataset[]>;
 export declare function readAllDatasets(workflowName: string, filterNames?: string[], basePath?: string): Promise<{
     datasets: Dataset[];

package/dist/services/datasets.js

@@ -5,24 +5,26 @@ import yaml from 'js-yaml';
 import { DatasetSchema } from '@outputai/evals';
 import { getTrace } from '#services/trace_reader.js';
 import { sanitizeSecrets } from '#utils/secret_sanitizer.js';
+import { resolveWorkflowDir, WORKFLOWS_PATHS } from '#utils/workflow_dir.js';
+import { getWorkflowsBasePath } from '#utils/paths.js';
 const DATASETS_DIR = 'tests/datasets';
-const WORKFLOWS_PATHS = ['src/workflows', 'workflows'];
-export function resolveDatasetsDir(workflowName, basePath = process.cwd()) {
-    for (const workflowsDir of WORKFLOWS_PATHS) {
-        const candidate = resolve(basePath, workflowsDir, workflowName, DATASETS_DIR);
-        if (existsSync(candidate)) {
-            return candidate;
-        }
+export async function resolveDatasetsDir(workflowName, basePath, workflowPath) {
+    const workflowDir = await resolveWorkflowDir(workflowName, basePath, workflowPath);
+    if (!workflowDir) {
+        return null;
     }
-    return null;
+    const datasetsDir = resolve(workflowDir, DATASETS_DIR);
+    return existsSync(datasetsDir) ? datasetsDir : null;
 }
-export function resolveDefaultDatasetsDir(workflowName, basePath = process.cwd()) {
-    const existing = resolveDatasetsDir(workflowName, basePath);
-    if (existing) {
-        return existing;
+export async function resolveDefaultDatasetsDir(workflowName, basePath, workflowPath) {
+    // Write into the resolved workflow's tests/datasets — even when it doesn't
+    // exist yet (first generation) — so nested workflows get the right location.
+    const workflowDir = await resolveWorkflowDir(workflowName, basePath, workflowPath);
+    if (workflowDir) {
+        return resolve(workflowDir, DATASETS_DIR);
     }
-    // Default to first workflows path
-    return resolve(basePath, WORKFLOWS_PATHS[0], workflowName, DATASETS_DIR);
+    // Workflow not found (unknown name / API unavailable): flat convention.
+    return resolve(basePath ?? getWorkflowsBasePath(), WORKFLOWS_PATHS[0], workflowName, DATASETS_DIR);
 }
 export async function readDatasetFile(filePath) {
     const raw = yaml.load(await readFile(filePath, 'utf-8'));
@@ -39,9 +41,9 @@ export async function readDatasetFile(filePath) {
     });
 }
 export async function readAllDatasets(workflowName, filterNames, basePath) {
-    const dir = resolveDatasetsDir(workflowName, basePath);
+    const dir = await resolveDatasetsDir(workflowName, basePath);
     if (!dir) {
-        return { datasets: [], dir: resolveDefaultDatasetsDir(workflowName, basePath) };
+        return { datasets: [], dir: await resolveDefaultDatasetsDir(workflowName, basePath) };
     }
     const files = await readdir(dir);
     const ymlFiles = files.filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
@@ -76,7 +78,7 @@ export async function writeDataset(dataset, filePath) {
     await writeFile(filePath, yaml.dump(fileObj, { lineWidth: 120, noRefs: true, sortKeys: false }), 'utf-8');
 }
 export async function listDatasets(workflowName, basePath) {
-    const dir = resolveDatasetsDir(workflowName, basePath);
+    const dir = await resolveDatasetsDir(workflowName, basePath);
     if (!dir) {
         return [];
     }

package/dist/services/datasets.test.js

@@ -1,12 +1,20 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { mkdtemp, rm, writeFile, readFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import yaml from 'js-yaml';
-import { readDatasetFile, readAllDatasets, writeDataset, listDatasets } from './datasets.js';
+import { readDatasetFile, readAllDatasets, writeDataset, listDatasets, resolveDefaultDatasetsDir } from './datasets.js';
+import * as catalog from '#api/workflow_catalog.js';
+vi.mock('#api/workflow_catalog.js', () => ({
+    fetchWorkflowCatalog: vi.fn()
+}));
 const ctx = { tmpDir: '' };
 beforeEach(async () => {
     ctx.tmpDir = await mkdtemp(join(tmpdir(), 'output-datasets-test-'));
+    // Default: no API. Flat-layout cases resolve offline before this is hit;
+    // nested cases override with a resolved catalog.
+    vi.mocked(catalog.fetchWorkflowCatalog).mockReset();
+    vi.mocked(catalog.fetchWorkflowCatalog).mockRejectedValue(new Error('API unavailable'));
 });
 afterEach(async () => {
     await rm(ctx.tmpDir, { recursive: true, force: true });
@@ -102,6 +110,17 @@ describe('readAllDatasets', () => {
         expect(datasets).toHaveLength(2);
         expect(datasets.map(d => d.name).sort()).toEqual(['case_2', 'case_3']);
     });
+    it('resolves a nested workflow folder via the catalog', async () => {
+        const datasetsDir = join(ctx.tmpDir, 'src', 'workflows', 'a', 'b', 'c', 'tests', 'datasets');
+        await mkdir(datasetsDir, { recursive: true });
+        await writeYaml(join(datasetsDir, 'cases.yml'), {
+            nested_case: { input: { x: 1 } }
+        });
+        vi.mocked(catalog.fetchWorkflowCatalog).mockResolvedValue([{ name: 'a_b_c', path: '/app/dist/workflows/a/b/c/workflow.js' }]);
+        const { datasets, dir } = await readAllDatasets('a_b_c', undefined, ctx.tmpDir);
+        expect(datasets.map(d => d.name)).toEqual(['nested_case']);
+        expect(dir).toBe(datasetsDir);
+    });
     it('returns empty datasets and a default dir when workflow has no datasets dir', async () => {
         const { datasets, dir } = await readAllDatasets('nonexistent_workflow', undefined, ctx.tmpDir);
         expect(datasets).toHaveLength(0);
@@ -200,3 +219,19 @@ describe('listDatasets', () => {
         expect(infos).toHaveLength(0);
     });
 });
+// ---------------------------------------------------------------------------
+// resolveDefaultDatasetsDir
+// ---------------------------------------------------------------------------
+describe('resolveDefaultDatasetsDir', () => {
+    it('returns the nested workflow tests/datasets for first-time generation via catalog', async () => {
+        // Workflow dir exists; its tests/datasets does not yet (first generation).
+        await mkdir(join(ctx.tmpDir, 'src', 'workflows', 'a', 'b', 'c'), { recursive: true });
+        vi.mocked(catalog.fetchWorkflowCatalog).mockResolvedValue([{ name: 'a_b_c', path: '/app/dist/workflows/a/b/c/workflow.js' }]);
+        const dir = await resolveDefaultDatasetsDir('a_b_c', ctx.tmpDir);
+        expect(dir).toBe(join(ctx.tmpDir, 'src', 'workflows', 'a', 'b', 'c', 'tests', 'datasets'));
+    });
+    it('falls back to the flat convention when the workflow cannot be resolved', async () => {
+        const dir = await resolveDefaultDatasetsDir('unknown_flow', ctx.tmpDir);
+        expect(dir).toBe(join(ctx.tmpDir, 'src', 'workflows', 'unknown_flow', 'tests', 'datasets'));
+    });
+});

package/dist/utils/eval_diagnostics.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Explain why a `<wf>_eval` workflow isn't registered. When the eval source
+ * exists on disk but isn't in the catalog, it almost always means tests/evals
+ * never compiled to dist (a tsconfig exclude dropped it) — so point at that
+ * instead of a bare WorkflowNotFoundError.
+ */
+export declare function diagnoseMissingEvalWorkflow(workflowName: string, basePath?: string): Promise<string>;

package/dist/utils/eval_diagnostics.js

@@ -0,0 +1,35 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { getEvalWorkflowName } from '@outputai/evals';
+import { resolveWorkflowDir } from '#utils/workflow_dir.js';
+const EVAL_WORKFLOW_FILES = ['tests/evals/workflow.ts', 'tests/evals/workflow.js'];
+/**
+ * Explain why a `<wf>_eval` workflow isn't registered. When the eval source
+ * exists on disk but isn't in the catalog, it almost always means tests/evals
+ * never compiled to dist (a tsconfig exclude dropped it) — so point at that
+ * instead of a bare WorkflowNotFoundError.
+ */
+export async function diagnoseMissingEvalWorkflow(workflowName, basePath) {
+    const evalName = getEvalWorkflowName(workflowName);
+    const workflowDir = await resolveWorkflowDir(workflowName, basePath);
+    const evalSource = workflowDir ?
+        EVAL_WORKFLOW_FILES.map(file => resolve(workflowDir, file)).find(existsSync) :
+        undefined;
+    if (evalSource) {
+        return [
+            `Eval workflow "${evalName}" is not registered, but its source exists at:`,
+            `  ${evalSource}`,
+            '',
+            'This usually means tests/evals did not compile to dist. Check your tsconfig:',
+            '  - Ensure tests/evals is not excluded (avoid excluding "src/**/tests").',
+            '  - Prefer excluding "**/*.spec.ts" and "**/*.test.ts" instead.',
+            '',
+            'Rebuild the worker so dist/.../tests/evals/workflow.js exists, then retry.'
+        ].join('\n');
+    }
+    return [
+        `No eval workflow defined for "${workflowName}".`,
+        '',
+        `Create an eval workflow at tests/evals/workflow.ts that registers "${evalName}".`
+    ].join('\n');
+}

package/dist/utils/scenario_resolver.d.ts

@@ -1,10 +1,9 @@
+export { extractWorkflowRelativePath, findWorkflowDirectoryFromPath } from '#utils/workflow_dir.js';
 export interface ScenarioResolutionResult {
     found: boolean;
     path?: string;
     searchedPaths: string[];
 }
-export declare function extractWorkflowRelativePath(path: string): string | null;
-export declare function findWorkflowDirectoryFromPath(workflowPath: string | undefined, basePath?: string): string | null;
 export declare function resolveScenarioPath(workflowName: string, scenarioName: string, basePath?: string, workflowPath?: string): Promise<ScenarioResolutionResult>;
 export declare function listScenariosForWorkflow(workflowName: string, workflowPath?: string, basePath?: string): string[];
 export declare function getScenarioNotFoundMessage(workflowName: string, scenarioName: string, searchedPaths: string[]): string;

package/dist/utils/scenario_resolver.js

@@ -1,43 +1,13 @@
 import { existsSync, readdirSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fetchWorkflowCatalog } from '#api/workflow_catalog.js';
+import { resolve } from 'node:path';
 import { getWorkflowsBasePath } from '#utils/paths.js';
+import { WORKFLOWS_PATHS, candidateWorkflowDirsFromPath, fetchWorkflowPath } from '#utils/workflow_dir.js';
+export { extractWorkflowRelativePath, findWorkflowDirectoryFromPath } from '#utils/workflow_dir.js';
 const SCENARIOS_DIR = 'scenarios';
-const WORKFLOWS_PATHS = ['src/workflows', 'workflows'];
-export function extractWorkflowRelativePath(path) {
-    const match = path.match(/(?:^|\/)workflows\/(.+)\/workflow\.[jt]s$/);
-    return match ? match[1] : null;
-}
-function unique(values) {
-    return [...new Set(values)];
-}
-function workflowPathSuffixes(workflowPath) {
-    const parts = dirname(workflowPath).split(/[/\\]+/).filter(Boolean);
-    return parts.map((_, index) => parts.slice(index));
-}
-function candidateWorkflowDirsFromPath(workflowPath, basePath) {
-    return unique(workflowPathSuffixes(workflowPath).flatMap(suffix => WORKFLOWS_PATHS.map(workflowsDir => resolve(basePath, workflowsDir, ...suffix))));
-}
 function candidateScenarioDirsFromPath(workflowPath, basePath) {
     return candidateWorkflowDirsFromPath(workflowPath, basePath)
         .map(workflowDir => resolve(workflowDir, SCENARIOS_DIR));
 }
-export function findWorkflowDirectoryFromPath(workflowPath, basePath = getWorkflowsBasePath()) {
-    if (!workflowPath) {
-        return null;
-    }
-    return candidateWorkflowDirsFromPath(workflowPath, basePath).find(existsSync) ?? null;
-}
-async function fetchWorkflowPath(workflowName) {
-    try {
-        const workflows = await fetchWorkflowCatalog();
-        const workflow = workflows.find(w => w.name === workflowName);
-        return workflow?.path ?? null;
-    }
-    catch {
-        return null;
-    }
-}
 function resolveScenarioFromDirectory(relativeDir, scenarioFileName, basePath) {
     const searchedPaths = [];
     for (const workflowsDir of WORKFLOWS_PATHS) {

package/dist/utils/workflow_dir.d.ts

@@ -0,0 +1,13 @@
+export declare const WORKFLOWS_PATHS: string[];
+export declare function extractWorkflowRelativePath(path: string): string | null;
+export declare function candidateWorkflowDirsFromPath(workflowPath: string, basePath: string): string[];
+export declare function findWorkflowDirectoryFromPath(workflowPath: string | undefined, basePath?: string): string | null;
+export declare function fetchWorkflowPath(workflowName: string): Promise<string | null>;
+/**
+ * Resolve the on-disk directory of a registered workflow by name.
+ *
+ * Flat-first so flat-layout projects resolve offline (no catalog round-trip)
+ * exactly as before; nested folders fall through to the worker catalog, whose
+ * `path` is re-rooted under `src/workflows` / `workflows`.
+ */
+export declare function resolveWorkflowDir(workflowName: string, basePath?: string, workflowPath?: string): Promise<string | null>;

package/dist/utils/workflow_dir.js

@@ -0,0 +1,58 @@
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fetchWorkflowCatalog } from '#api/workflow_catalog.js';
+import { getWorkflowsBasePath } from '#utils/paths.js';
+export const WORKFLOWS_PATHS = ['src/workflows', 'workflows'];
+export function extractWorkflowRelativePath(path) {
+    const match = path.match(/(?:^|\/)workflows\/(.+)\/workflow\.[jt]s$/);
+    return match ? match[1] : null;
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function workflowPathSuffixes(workflowPath) {
+    const parts = dirname(workflowPath).split(/[/\\]+/).filter(Boolean);
+    return parts.map((_, index) => parts.slice(index));
+}
+export function candidateWorkflowDirsFromPath(workflowPath, basePath) {
+    return unique(workflowPathSuffixes(workflowPath).flatMap(suffix => WORKFLOWS_PATHS.map(workflowsDir => resolve(basePath, workflowsDir, ...suffix))));
+}
+export function findWorkflowDirectoryFromPath(workflowPath, basePath = getWorkflowsBasePath()) {
+    if (!workflowPath) {
+        return null;
+    }
+    return candidateWorkflowDirsFromPath(workflowPath, basePath).find(existsSync) ?? null;
+}
+export async function fetchWorkflowPath(workflowName) {
+    try {
+        const workflows = await fetchWorkflowCatalog();
+        const workflow = workflows.find(w => w.name === workflowName);
+        return workflow?.path ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the on-disk directory of a registered workflow by name.
+ *
+ * Flat-first so flat-layout projects resolve offline (no catalog round-trip)
+ * exactly as before; nested folders fall through to the worker catalog, whose
+ * `path` is re-rooted under `src/workflows` / `workflows`.
+ */
+export async function resolveWorkflowDir(workflowName, basePath = getWorkflowsBasePath(), workflowPath) {
+    for (const workflowsDir of WORKFLOWS_PATHS) {
+        const candidate = resolve(basePath, workflowsDir, workflowName);
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    if (workflowPath) {
+        const found = findWorkflowDirectoryFromPath(workflowPath, basePath);
+        if (found) {
+            return found;
+        }
+    }
+    const catalogPath = await fetchWorkflowPath(workflowName);
+    return findWorkflowDirectoryFromPath(catalogPath ?? undefined, basePath);
+}

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

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

package/dist/utils/workflow_dir.spec.js

@@ -0,0 +1,60 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { resolveWorkflowDir } from './workflow_dir.js';
+import * as fs from 'node:fs';
+import * as catalog from '#api/workflow_catalog.js';
+vi.mock('node:fs', () => ({
+    existsSync: vi.fn()
+}));
+vi.mock('#api/workflow_catalog.js', () => ({
+    fetchWorkflowCatalog: vi.fn()
+}));
+function mockCatalog(workflows) {
+    vi.mocked(catalog.fetchWorkflowCatalog).mockResolvedValue(workflows);
+}
+function mockCatalogFailure() {
+    vi.mocked(catalog.fetchWorkflowCatalog).mockRejectedValue(new Error('API unavailable'));
+}
+describe('resolveWorkflowDir', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('resolves a flat layout without querying the catalog', async () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path) === '/project/src/workflows/simple');
+        const result = await resolveWorkflowDir('simple', '/project');
+        expect(result).toBe('/project/src/workflows/simple');
+        expect(catalog.fetchWorkflowCatalog).not.toHaveBeenCalled();
+    });
+    it('resolves the workflows/ fallback without querying the catalog', async () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path) === '/project/workflows/simple');
+        const result = await resolveWorkflowDir('simple', '/project');
+        expect(result).toBe('/project/workflows/simple');
+        expect(catalog.fetchWorkflowCatalog).not.toHaveBeenCalled();
+    });
+    it('resolves a nested folder via the catalog path', async () => {
+        mockCatalog([{ name: 'a_b_c', path: '/app/dist/workflows/a/b/c/workflow.js' }]);
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path) === '/project/src/workflows/a/b/c');
+        const result = await resolveWorkflowDir('a_b_c', '/project');
+        expect(result).toBe('/project/src/workflows/a/b/c');
+    });
+    it('returns null when the catalog is unavailable and no flat dir exists', async () => {
+        mockCatalogFailure();
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        const result = await resolveWorkflowDir('a_b_c', '/project');
+        expect(result).toBeNull();
+    });
+    it('returns null when the workflow is not in the catalog', async () => {
+        mockCatalog([{ name: 'other', path: '/app/dist/workflows/other/workflow.js' }]);
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        const result = await resolveWorkflowDir('a_b_c', '/project');
+        expect(result).toBeNull();
+    });
+    it('uses a provided workflowPath without querying the catalog', async () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path) === '/project/src/workflows/writing/editor');
+        const result = await resolveWorkflowDir('writing_editor', '/project', '/app/build-output/writing/editor/workflow.js');
+        expect(result).toBe('/project/src/workflows/writing/editor');
+        expect(catalog.fetchWorkflowCatalog).not.toHaveBeenCalled();
+    });
+});

package/oclif.manifest.json

@@ -1441,5 +1441,5 @@
       ]
     }
   },
-  "version": "0.8.0"
+  "version": "0.8.1-dev.945f2f2.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.8.0",
+  "version": "0.8.1-dev.945f2f2.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -36,9 +36,9 @@
     "semver": "7.7.4",
     "undici": "8.1.0",
     "yaml": "^2.8.3",
-    "@outputai/credentials": "0.8.0",
-    "@outputai/llm": "0.8.0",
-    "@outputai/evals": "0.8.0"
+    "@outputai/evals": "0.8.1-dev.945f2f2.0",
+    "@outputai/llm": "0.8.1-dev.945f2f2.0",
+    "@outputai/credentials": "0.8.1-dev.945f2f2.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",