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

package/dist/services/claude_client.js

@@ -38,10 +38,25 @@ date: <plan-date>
 3. Implement all workflow files following Output.ai patterns and best practices.
 
 4. After you mark all todos as complete, provide a summary of what was implemented.
+`,
+    MIGRATE: `
+! IMPORTANT !
+1. Use TodoWrite to track your progress through the migration.
+
+2. Fetch the migration guide from https://docs.output.ai/migrations — do not invent migration steps from memory.
+
+3. If the specific guide URL 404s, fall back to the /migrations index and chain the guides that cover the version range.
+
+4. Confirm the planned changes with the user before editing files.
+
+5. After you mark all todos as complete, provide a summary of which files changed and whether the type check passed.
 `
 };
-const PLAN_COMMAND = 'outputai:plan_workflow';
-const BUILD_COMMAND = 'outputai:build_workflow';
+// Slash-command naming convention used by the outputai plugin:
+// `output-<kebab-name>` — skills under coding_assistants/.../skills/, which surface as top-level slash commands without the plugin prefix.
+const PLAN_COMMAND = 'output-plan-workflow';
+const BUILD_COMMAND = 'output-build-workflow';
+const MIGRATE_COMMAND = 'output-migrate';
 const GLOBAL_CLAUDE_OPTIONS = {
     settingSources: ['user', 'project', 'local']
 };
@@ -51,6 +66,9 @@ export const PLAN_COMMAND_OPTIONS = {
 export const BUILD_COMMAND_OPTIONS = {
     permissionMode: 'bypassPermissions'
 };
+export const MIGRATE_COMMAND_OPTIONS = {
+    permissionMode: 'bypassPermissions'
+};
 export class ClaudeInvocationError extends Error {
     cause;
     constructor(message, cause) {
@@ -77,7 +95,7 @@ function validateEnvironment() {
     }
 }
 function validateSystem(systemMessage) {
-    const requiredCommands = [PLAN_COMMAND, BUILD_COMMAND];
+    const requiredCommands = [PLAN_COMMAND, BUILD_COMMAND, MIGRATE_COMMAND];
     const availableCommands = systemMessage.slash_commands;
     const missingCommands = requiredCommands.filter(command => !availableCommands.includes(command));
     return {
@@ -105,7 +123,10 @@ function getTodoWriteMessage(message) {
     if (message.type !== 'assistant') {
         return null;
     }
-    const todoWriteMessage = message.message.content.find((c) => c?.type === 'tool_use' && c.name === 'TodoWrite');
+    const todoWriteMessage = message.message.content.find((c) => {
+        const block = c;
+        return block.type === 'tool_use' && block.name === 'TodoWrite';
+    });
     return todoWriteMessage ?? null;
 }
 function applyInstructions(message, instructions) {
@@ -190,7 +211,7 @@ export async function replyToClaude(message, { anthropicOpts, applyAdditionalIns
     return singleQuery(applyInstructions(message, applyAdditionalInstructions), { continue: true, ...anthropicOpts });
 }
 /**
- * Invoke claude-code with /outputai:plan_workflow slash command
+ * Invoke claude-code with /output-plan-workflow slash command
  * The SDK loads custom commands from .claude/commands/ when settingSources includes 'project'.
  * ensureOutputAISystem() scaffolds the command files to that location.
  * @param description - Workflow description
@@ -200,7 +221,7 @@ export async function invokePlanWorkflow(description) {
     return singleQuery(applyInstructions(`/${PLAN_COMMAND} ${description}`, ADDITIONAL_INSTRUCTIONS.PLAN), PLAN_COMMAND_OPTIONS);
 }
 /**
- * Invoke claude-code with /outputai:build_workflow slash command
+ * Invoke claude-code with /output-build-workflow slash command
  * The SDK loads custom commands from .claude/commands/ when settingSources includes 'project'.
  * ensureOutputAISystem() scaffolds the command files to that location.
  * @param planFilePath - Absolute path to the plan file
@@ -216,3 +237,18 @@ export async function invokeBuildWorkflow(planFilePath, workflowDir, workflowNam
         `/${BUILD_COMMAND} ${commandArgs}`;
     return singleQuery(applyInstructions(fullCommand, ADDITIONAL_INSTRUCTIONS.BUILD), BUILD_COMMAND_OPTIONS);
 }
+/**
+ * Invoke claude-code with /output-migrate slash command (registered via the output-migrate skill).
+ * The slash command fetches migration instructions from docs.output.ai —
+ * this CLI wrapper just passes through the version arguments.
+ * @param fromVersion - Current framework version (empty string = auto-detect)
+ * @param toVersion - Target version (empty string = use npm "latest")
+ * @param additionalInstructions - Optional user-supplied guidance
+ * @returns Migration summary from claude-code
+ */
+export async function invokeMigrate(fromVersion, toVersion, additionalInstructions) {
+    const from = fromVersion || 'auto';
+    const to = toVersion || 'latest';
+    const commandArgs = [from, to, additionalInstructions].filter(Boolean).join(' ');
+    return singleQuery(applyInstructions(`/${MIGRATE_COMMAND} ${commandArgs}`, ADDITIONAL_INSTRUCTIONS.MIGRATE), MIGRATE_COMMAND_OPTIONS);
+}

package/dist/services/claude_client.spec.js

@@ -13,7 +13,7 @@ describe('invokePlanWorkflow', () => {
         // Clean up environment variables
         delete process.env.ANTHROPIC_API_KEY;
     });
-    it('should invoke /outputai:plan_workflow slash command with settingSources', async () => {
+    it('should invoke /output-plan-workflow slash command with settingSources', async () => {
         const { query } = await import('@anthropic-ai/claude-agent-sdk');
         process.env.ANTHROPIC_API_KEY = 'test-key';
         async function* mockIterator() {
@@ -22,7 +22,7 @@ describe('invokePlanWorkflow', () => {
         vi.mocked(query).mockReturnValue(mockIterator());
         await invokePlanWorkflow('Test workflow');
         const calls = vi.mocked(query).mock.calls;
-        expect(calls[0]?.[0]?.prompt).toContain('/outputai:plan_workflow Test workflow');
+        expect(calls[0]?.[0]?.prompt).toContain('/output-plan-workflow Test workflow');
         expect(calls[0]?.[0]?.options?.settingSources).toEqual(['user', 'project', 'local']);
         expect(calls[0]?.[0]?.options?.allowedTools).toEqual(['Read', 'Grep', 'WebSearch', 'WebFetch', 'TodoWrite']);
     });
@@ -36,7 +36,7 @@ describe('invokePlanWorkflow', () => {
         const description = 'Build a user authentication system';
         await invokePlanWorkflow(description);
         const calls = vi.mocked(query).mock.calls;
-        expect(calls[0]?.[0]?.prompt).toContain(`/outputai:plan_workflow ${description}`);
+        expect(calls[0]?.[0]?.prompt).toContain(`/output-plan-workflow ${description}`);
         expect(calls[0]?.[0]?.options?.settingSources).toEqual(['user', 'project', 'local']);
     });
     it('should return plan output from claude-code', async () => {

package/dist/services/datasets.d.ts

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

package/dist/services/datasets.js

@@ -24,10 +24,19 @@ export function resolveDefaultDatasetsDir(workflowName, basePath = process.cwd()
     // Default to first workflows path
     return resolve(basePath, WORKFLOWS_PATHS[0], workflowName, DATASETS_DIR);
 }
-export async function readDataset(filePath) {
-    const content = await readFile(filePath, 'utf-8');
-    const raw = yaml.load(content);
-    return DatasetSchema.parse(raw);
+export async function readDatasetFile(filePath) {
+    const raw = yaml.load(await readFile(filePath, 'utf-8'));
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error(`Invalid dataset file: ${filePath}`);
+    }
+    return Object.entries(raw).map(([name, body]) => {
+        if (!body || typeof body !== 'object' || !('input' in body)) {
+            throw new Error(`Dataset case "${name}" in ${filePath} is missing required "input" field`);
+        }
+        const dataset = DatasetSchema.parse({ name, ...body });
+        dataset._source = filePath;
+        return dataset;
+    });
 }
 export async function readAllDatasets(workflowName, filterNames, basePath) {
     const dir = resolveDatasetsDir(workflowName, basePath);
@@ -36,42 +45,35 @@ export async function readAllDatasets(workflowName, filterNames, basePath) {
     }
     const files = await readdir(dir);
     const ymlFiles = files.filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
+    const seen = new Set();
     const datasets = [];
     for (const file of ymlFiles) {
-        const dataset = await readDataset(join(dir, file));
-        if (filterNames && !filterNames.includes(dataset.name)) {
-            continue;
+        const cases = await readDatasetFile(join(dir, file));
+        for (const dataset of cases) {
+            if (seen.has(dataset.name)) {
+                throw new Error(`Duplicate dataset case name "${dataset.name}" found in ${file}`);
+            }
+            seen.add(dataset.name);
+            if (filterNames && !filterNames.includes(dataset.name)) {
+                continue;
+            }
+            datasets.push(dataset);
         }
-        datasets.push(dataset);
     }
     return { datasets, dir };
 }
-async function mergeWithExisting(dataset, filePath) {
-    if (!existsSync(filePath)) {
-        return dataset;
-    }
-    try {
-        const existing = await readDataset(filePath);
-        return {
-            ...existing,
-            ...dataset,
-            ground_truth: dataset.ground_truth ?? existing.ground_truth,
-            last_output: dataset.last_output ?? existing.last_output,
-            last_eval: dataset.last_eval ?? existing.last_eval
-        };
-    }
-    catch {
-        return dataset;
-    }
-}
 export async function writeDataset(dataset, filePath) {
-    const merged = await mergeWithExisting(dataset, filePath);
     const dir = resolve(filePath, '..');
     if (!existsSync(dir)) {
         await mkdir(dir, { recursive: true });
     }
-    const content = yaml.dump(merged, { lineWidth: 120, noRefs: true, sortKeys: false });
-    await writeFile(filePath, content, 'utf-8');
+    const loaded = existsSync(filePath) ? yaml.load(await readFile(filePath, 'utf-8')) : null;
+    const fileObj = (loaded && typeof loaded === 'object' && !Array.isArray(loaded)) ?
+        loaded :
+        {};
+    const { name, _source, ...caseBody } = dataset;
+    fileObj[name] = { ...fileObj[name], ...caseBody };
+    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);
@@ -84,14 +86,16 @@ export async function listDatasets(workflowName, basePath) {
     for (const file of ymlFiles) {
         const filePath = join(dir, file);
         try {
-            const dataset = await readDataset(filePath);
-            results.push({
-                name: dataset.name,
-                path: filePath,
-                hasLastOutput: dataset.last_output?.output !== undefined,
-                lastOutputDate: dataset.last_output?.date,
-                lastEvalDate: dataset.last_eval?.date
-            });
+            const cases = await readDatasetFile(filePath);
+            for (const dataset of cases) {
+                results.push({
+                    name: dataset.name,
+                    path: filePath,
+                    hasLastOutput: dataset.last_output?.output !== undefined,
+                    lastOutputDate: dataset.last_output?.date,
+                    lastEvalDate: dataset.last_eval?.date
+                });
+            }
         }
         catch {
             results.push({

package/dist/services/datasets.test.d.ts

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

package/dist/services/datasets.test.js

@@ -0,0 +1,202 @@
+import { describe, it, expect, beforeEach, afterEach } 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';
+const ctx = { tmpDir: '' };
+beforeEach(async () => {
+    ctx.tmpDir = await mkdtemp(join(tmpdir(), 'output-datasets-test-'));
+});
+afterEach(async () => {
+    await rm(ctx.tmpDir, { recursive: true, force: true });
+});
+function writeYaml(filePath, obj) {
+    return writeFile(filePath, yaml.dump(obj, { lineWidth: 120, noRefs: true, sortKeys: false }), 'utf-8');
+}
+// ---------------------------------------------------------------------------
+// readDatasetFile
+// ---------------------------------------------------------------------------
+describe('readDatasetFile', () => {
+    it('parses a multi-case file and returns all cases', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        await writeYaml(filePath, {
+            case_a: { input: { query: 'foo' }, ground_truth: { expected: 1 } },
+            case_b: { input: { query: 'bar' } },
+            case_c: { input: { query: 'baz' }, ground_truth: { expected: 3 } }
+        });
+        const datasets = await readDatasetFile(filePath);
+        expect(datasets).toHaveLength(3);
+        expect(datasets.map(d => d.name)).toEqual(['case_a', 'case_b', 'case_c']);
+        expect(datasets[0].input).toEqual({ query: 'foo' });
+        expect(datasets[0].ground_truth).toEqual({ expected: 1 });
+    });
+    it('attaches _source with the absolute file path to each dataset', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        await writeYaml(filePath, {
+            my_case: { input: { x: 1 } }
+        });
+        const [dataset] = await readDatasetFile(filePath);
+        expect(dataset._source).toBe(filePath);
+    });
+    it('throws when a case is missing input', async () => {
+        const filePath = join(ctx.tmpDir, 'bad.yml');
+        await writeYaml(filePath, {
+            good_case: { input: { x: 1 } },
+            bad_case: { ground_truth: { expected: 42 } }
+        });
+        await expect(readDatasetFile(filePath)).rejects.toThrow('Dataset case "bad_case" in');
+    });
+    it('throws when file content is not an object', async () => {
+        const filePath = join(ctx.tmpDir, 'bad.yml');
+        await writeFile(filePath, 'just a string', 'utf-8');
+        await expect(readDatasetFile(filePath)).rejects.toThrow('Invalid dataset file');
+    });
+    it('throws with clear message when file content is a YAML array', async () => {
+        const filePath = join(ctx.tmpDir, 'bad.yml');
+        await writeFile(filePath, '- foo\n- bar\n', 'utf-8');
+        await expect(readDatasetFile(filePath)).rejects.toThrow('Invalid dataset file');
+    });
+    it('preserves last_output and last_eval fields', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        await writeYaml(filePath, {
+            cached_case: {
+                input: { q: 'hello' },
+                last_output: { output: { result: 42 }, executionTimeMs: 100, date: '2026-01-01T00:00:00.000Z' }
+            }
+        });
+        const [dataset] = await readDatasetFile(filePath);
+        expect(dataset.last_output?.output).toEqual({ result: 42 });
+        expect(dataset.last_output?.executionTimeMs).toBe(100);
+    });
+});
+// ---------------------------------------------------------------------------
+// readAllDatasets
+// ---------------------------------------------------------------------------
+describe('readAllDatasets', () => {
+    it('flattens cases from multiple files', async () => {
+        const datasetsDir = join(ctx.tmpDir, 'src', 'workflows', 'my_workflow', 'tests', 'datasets');
+        await mkdir(datasetsDir, { recursive: true });
+        await writeYaml(join(datasetsDir, 'group_a.yml'), {
+            case_1: { input: { x: 1 } },
+            case_2: { input: { x: 2 } }
+        });
+        await writeYaml(join(datasetsDir, 'group_b.yml'), {
+            case_3: { input: { x: 3 } }
+        });
+        const { datasets } = await readAllDatasets('my_workflow', undefined, ctx.tmpDir);
+        expect(datasets).toHaveLength(3);
+        expect(datasets.map(d => d.name).sort()).toEqual(['case_1', 'case_2', 'case_3']);
+    });
+    it('filters by case name across files', async () => {
+        const datasetsDir = join(ctx.tmpDir, 'src', 'workflows', 'my_workflow', 'tests', 'datasets');
+        await mkdir(datasetsDir, { recursive: true });
+        await writeYaml(join(datasetsDir, 'group_a.yml'), {
+            case_1: { input: { x: 1 } },
+            case_2: { input: { x: 2 } }
+        });
+        await writeYaml(join(datasetsDir, 'group_b.yml'), {
+            case_3: { input: { x: 3 } }
+        });
+        const { datasets } = await readAllDatasets('my_workflow', ['case_2', 'case_3'], ctx.tmpDir);
+        expect(datasets).toHaveLength(2);
+        expect(datasets.map(d => d.name).sort()).toEqual(['case_2', 'case_3']);
+    });
+    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);
+        expect(dir).toContain('nonexistent_workflow');
+    });
+    it('throws when the same case name appears in two different files', async () => {
+        const datasetsDir = join(ctx.tmpDir, 'src', 'workflows', 'my_workflow', 'tests', 'datasets');
+        await mkdir(datasetsDir, { recursive: true });
+        await writeYaml(join(datasetsDir, 'group_a.yml'), { case_1: { input: { x: 1 } } });
+        await writeYaml(join(datasetsDir, 'group_b.yml'), { case_1: { input: { x: 2 } } });
+        await expect(readAllDatasets('my_workflow', undefined, ctx.tmpDir)).rejects.toThrow('Duplicate dataset case name "case_1"');
+    });
+});
+// ---------------------------------------------------------------------------
+// writeDataset
+// ---------------------------------------------------------------------------
+describe('writeDataset', () => {
+    it('creates a new file with one case keyed by name', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        const dataset = { name: 'new_case', input: { q: 'hello' } };
+        await writeDataset(dataset, filePath);
+        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        expect(raw).toHaveProperty('new_case');
+        expect(raw.new_case.input).toEqual({ q: 'hello' });
+        expect(raw.new_case).not.toHaveProperty('name');
+    });
+    it('does not write _source into the file', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        const dataset = { name: 'my_case', input: { q: 'x' }, _source: '/some/path.yml' };
+        await writeDataset(dataset, filePath);
+        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        expect(raw.my_case).not.toHaveProperty('_source');
+    });
+    it('updates only the target case, leaving other cases untouched', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        await writeYaml(filePath, {
+            case_a: { input: { x: 1 }, ground_truth: { expected: 1 } },
+            case_b: { input: { x: 2 }, ground_truth: { expected: 2 } }
+        });
+        await writeDataset({ name: 'case_a', input: { x: 1 }, last_output: { output: { result: 1 }, date: '2026-01-01T00:00:00.000Z' } }, filePath);
+        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        expect(raw).toHaveProperty('case_b');
+        expect(raw.case_b.ground_truth).toEqual({ expected: 2 });
+    });
+    it('preserves existing fields when writing last_output then last_eval', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        await writeYaml(filePath, {
+            my_case: { input: { q: 'hello' }, ground_truth: { expected: 42 } }
+        });
+        await writeDataset({ name: 'my_case', input: { q: 'hello' }, last_output: { output: { result: 42 }, executionTimeMs: 50, date: '2026-01-01T00:00:00.000Z' } }, filePath);
+        await writeDataset({
+            name: 'my_case', input: { q: 'hello' },
+            last_eval: { output: { datasetName: 'my_case', verdict: 'pass', evaluators: [] }, date: '2026-01-01T00:01:00.000Z' }
+        }, filePath);
+        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        const caseObj = raw.my_case;
+        expect(caseObj).toHaveProperty('last_output');
+        expect(caseObj).toHaveProperty('last_eval');
+        expect(caseObj).toHaveProperty('ground_truth');
+    });
+    it('creates parent directories if they do not exist', async () => {
+        const filePath = join(ctx.tmpDir, 'deep', 'nested', 'cases.yml');
+        await writeDataset({ name: 'my_case', input: { q: 'x' } }, filePath);
+        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        expect(raw).toHaveProperty('my_case');
+    });
+    it('recovers gracefully when existing file contains non-object YAML', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        await writeFile(filePath, 'just a string', 'utf-8');
+        await writeDataset({ name: 'my_case', input: { q: 'x' } }, filePath);
+        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        expect(raw).toHaveProperty('my_case');
+    });
+});
+// ---------------------------------------------------------------------------
+// listDatasets
+// ---------------------------------------------------------------------------
+describe('listDatasets', () => {
+    it('returns one DatasetInfo per case across all files', async () => {
+        const datasetsDir = join(ctx.tmpDir, 'src', 'workflows', 'my_workflow', 'tests', 'datasets');
+        await mkdir(datasetsDir, { recursive: true });
+        await writeYaml(join(datasetsDir, 'core.yml'), {
+            case_1: { input: { x: 1 }, last_output: { output: { r: 1 }, date: '2026-01-01T00:00:00.000Z' } },
+            case_2: { input: { x: 2 } }
+        });
+        const infos = await listDatasets('my_workflow', ctx.tmpDir);
+        expect(infos).toHaveLength(2);
+        const case1 = infos.find(i => i.name === 'case_1');
+        expect(case1.hasLastOutput).toBe(true);
+        expect(case1.path).toContain('core.yml');
+        const case2 = infos.find(i => i.name === 'case_2');
+        expect(case2.hasLastOutput).toBe(false);
+    });
+    it('returns empty array when no datasets directory exists', async () => {
+        const infos = await listDatasets('nonexistent_workflow', ctx.tmpDir);
+        expect(infos).toHaveLength(0);
+    });
+});

package/dist/services/docker.d.ts

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

package/dist/services/docker.js

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

package/dist/services/messages.d.ts

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

package/dist/services/messages.js

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

package/dist/services/workflow_builder.d.ts

@@ -1,5 +1,5 @@
 /**
- * Build a workflow from a plan file using the /outputai:build_workflow slash command
+ * Build a workflow from a plan file using the /output-build-workflow slash command
  * @param planFilePath - Absolute path to the plan file
  * @param workflowDir - Absolute path to the workflow directory
  * @param workflowName - Name of the workflow

package/dist/services/workflow_builder.js

@@ -31,7 +31,7 @@ function isEmpty(modification) {
     return modification.trim() === '';
 }
 /**
- * Build a workflow from a plan file using the /outputai:build_workflow slash command
+ * Build a workflow from a plan file using the /output-build-workflow slash command
  * @param planFilePath - Absolute path to the plan file
  * @param workflowDir - Absolute path to the workflow directory
  * @param workflowName - Name of the workflow

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

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

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

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