@outputai/cli 0.1.13-next.91c5d78.0 → 0.1.13-next.934347c.0

package/dist/commands/workflow/test_eval.js

@@ -114,7 +114,7 @@ export default class WorkflowTest extends Command {
                 }
             };
             if (save) {
-                const filePath = join(dir, `${dataset.name}.yml`);
+                const filePath = dataset._source ?? join(dir, `${dataset.name}.yml`);
                 await writeDataset(updated, filePath);
                 this.log(`    Saved output to ${filePath}`);
             }
@@ -137,7 +137,7 @@ export default class WorkflowTest extends Command {
                     date: now
                 }
             };
-            const filePath = join(dir, `${dataset.name}.yml`);
+            const filePath = dataset._source ?? join(dir, `${dataset.name}.yml`);
             await writeDataset(updated, filePath);
             this.log(`  Saved eval result to ${filePath}`);
         }

package/dist/components/command_footer.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface CommandHint {
+    key: string;
+    label: string;
+}
+export declare const CommandFooter: React.FC<{
+    hints: CommandHint[];
+}>;

package/dist/components/command_footer.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+export const CommandFooter = ({ hints }) => (_jsx(Box, { marginTop: 1, children: hints.map((hint, i) => (_jsxs(React.Fragment, { children: [i > 0 && _jsx(Text, { dimColor: true, children: ' | ' }), _jsx(Text, { dimColor: true, children: '(' }), _jsx(Text, { dimColor: true, bold: true, children: hint.key }), _jsx(Text, { dimColor: true, children: ')' }), _jsx(Text, { dimColor: true, children: ` ${hint.label}` })] }, hint.key))) }));

package/dist/components/status_icon.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface StatusDisplay {
+    icon: string;
+    color: string;
+}
+export declare const resolveStatus: (status: string) => StatusDisplay;
+export declare const statusColor: (status: string) => string;
+export declare const StatusIcon: React.FC<{
+    status: string;
+}>;
+export {};

package/dist/components/status_icon.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from 'ink';
+const STATUS_MAP = {
+    // Docker service health
+    healthy: { icon: '●', color: 'green' },
+    unhealthy: { icon: '○', color: 'red' },
+    starting: { icon: '◐', color: 'yellow' },
+    none: { icon: '●', color: 'blue' },
+    exited: { icon: '✗', color: 'red' },
+    // Workflow run status
+    running: { icon: '●', color: 'blue' },
+    completed: { icon: '●', color: 'green' },
+    failed: { icon: '✗', color: 'red' },
+    canceled: { icon: '○', color: 'gray' },
+    terminated: { icon: '✗', color: 'red' },
+    timed_out: { icon: '✗', color: 'red' },
+    continued: { icon: '↻', color: 'blue' }
+};
+const DEFAULT_DISPLAY = { icon: '?', color: 'white' };
+export const resolveStatus = (status) => STATUS_MAP[status] ?? DEFAULT_DISPLAY;
+export const statusColor = (status) => resolveStatus(status).color;
+export const StatusIcon = ({ status }) => {
+    const { icon, color } = resolveStatus(status);
+    return _jsx(Text, { color: color, children: icon });
+};

package/dist/components/workflow_summary.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface WorkflowSummary {
+    running: number;
+    completed: number;
+    failed: number;
+    total: number;
+}
+export declare const WorkflowSummarySection: React.FC<{
+    summary: WorkflowSummary;
+}>;

package/dist/components/workflow_summary.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { statusColor } from '#components/status_icon.js';
+export const WorkflowSummarySection = ({ summary }) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "\uD83D\uDCCB Workflows" }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: statusColor('running'), children: [summary.running, " running"] }), _jsx(Text, { children: ", " }), _jsxs(Text, { color: statusColor('failed'), children: [summary.failed, " failed"] }), _jsx(Text, { children: ", " }), _jsxs(Text, { color: statusColor('completed'), children: [summary.completed, " complete"] })] })] }));

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.1.13-next.91c5d78.0"
+    "framework": "0.1.13-next.934347c.0"
 }

package/dist/services/claude_client.d.ts

@@ -5,6 +5,7 @@ import { Options } from '@anthropic-ai/claude-agent-sdk';
 export declare const ADDITIONAL_INSTRUCTIONS: {
     readonly PLAN: "\n! IMPORTANT !\n1. Use TodoWrite to track your progress through plan creation.\n\n2. Please respond with only the final version of the plan content.\n\n3. Respond in a markdown format with these metadata headers:\n\n---\ntitle: <plan-title>\ndescription: <plan-description>\ndate: <plan-date>\n---\n\n<plan-content>\n\n4. After you mark all todos as complete, you must respond with the final version of the plan.\n\n5. DO NOT write the plan to disk — the CLI will handle saving the file to the plans directory.\n\n6. DO NOT suggest any next steps, follow-up commands, or instructions for the user — the CLI will inform the user of next steps after saving.\n";
     readonly BUILD: "\n! IMPORTANT !\n1. Use TodoWrite to track your progress through workflow implementation.\n\n2. Follow the implementation plan exactly as specified in the plan file.\n\n3. Implement all workflow files following Output.ai patterns and best practices.\n\n4. After you mark all todos as complete, provide a summary of what was implemented.\n";
+    readonly MIGRATE: "\n! IMPORTANT !\n1. Use TodoWrite to track your progress through the migration.\n\n2. Fetch the migration guide from https://docs.output.ai/migrations — do not invent migration steps from memory.\n\n3. If the specific guide URL 404s, fall back to the /migrations index and chain the guides that cover the version range.\n\n4. Confirm the planned changes with the user before editing files.\n\n5. After you mark all todos as complete, provide a summary of which files changed and whether the type check passed.\n";
 };
 export declare const PLAN_COMMAND_OPTIONS: Options;
 interface ReplyToClaudeOptions {
@@ -12,13 +13,14 @@ interface ReplyToClaudeOptions {
     applyAdditionalInstructions?: string;
 }
 export declare const BUILD_COMMAND_OPTIONS: Options;
+export declare const MIGRATE_COMMAND_OPTIONS: Options;
 export declare class ClaudeInvocationError extends Error {
     cause?: Error | undefined;
     constructor(message: string, cause?: Error | undefined);
 }
 export declare function replyToClaude(message: string, { anthropicOpts, applyAdditionalInstructions }?: ReplyToClaudeOptions): Promise<string>;
 /**
- * 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
@@ -26,7 +28,7 @@ export declare function replyToClaude(message: string, { anthropicOpts, applyAdd
  */
 export declare function invokePlanWorkflow(description: string): Promise<string>;
 /**
- * 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
@@ -36,4 +38,14 @@ export declare function invokePlanWorkflow(description: string): Promise<string>
  * @returns Implementation output from claude-code
  */
 export declare function invokeBuildWorkflow(planFilePath: string, workflowDir: string, workflowName: string, additionalInstructions?: string): Promise<string>;
+/**
+ * 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 declare function invokeMigrate(fromVersion: string, toVersion: string, additionalInstructions?: string): Promise<string>;
 export {};

package/dist/services/claude_client.integration.test.js

@@ -15,7 +15,7 @@ describe('invokePlanWorkflow - Integration Tests', () => {
         const messages = [];
         try {
             for await (const message of query({
-                prompt: `/outputai:plan_workflow ${description}`,
+                prompt: `/output-plan-workflow ${description}`,
                 options: { maxTurns: 1 }
             })) {
                 console.log('\nReceived message:', JSON.stringify(message, null, 2));
@@ -31,7 +31,7 @@ describe('invokePlanWorkflow - Integration Tests', () => {
         // This test is just for debugging - we expect messages
         expect(messages.length).toBeGreaterThan(0);
     }, 60000); // 60 second timeout
-    it('should successfully invoke /outputai:plan_workflow slash command and return content', async () => {
+    it('should successfully invoke /output-plan-workflow slash command and return content', async () => {
         const description = 'Simple workflow that takes a number and doubles it';
         const result = await invokePlanWorkflow(description);
         console.log('\n===== PLAN RESULT =====');

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:
+// `outputai:<kebab-name>` — skills under coding_assistants/.../skills/, which surface as top-level slash commands without the plugin prefix.
+const PLAN_COMMAND = 'outputai:output-plan-workflow';
+const BUILD_COMMAND = 'outputai:output-build-workflow';
+const MIGRATE_COMMAND = 'outputai: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 /outputai: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('/outputai: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(`/outputai: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/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