@outputai/cli 0.1.10 → 0.1.11-next.7b8340c.0

package/bin/run.js

@@ -2,8 +2,10 @@
 
 import { execute } from '@oclif/core';
 import { loadEnvironment } from '../dist/utils/env_loader.js';
+import { resolveCredentialRefs } from '@outputai/credentials';
 
 // Load environment variables from .env files before executing CLI
 loadEnvironment();
+resolveCredentialRefs();
 
 await execute( { dir: import.meta.url } );

package/dist/assets/docker/docker-compose-dev.yml

@@ -81,7 +81,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.1.10}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.1.11-next.7b8340c.0}
     init: true
     networks:
       - main
@@ -105,11 +105,11 @@ services:
         condition: service_healthy
     image: node:24.13.0-slim
     healthcheck:
-      test: [ 'CMD', 'npx', '--yes', 'output-healthcheck' ]
+      test: [ 'CMD-SHELL', 'npx output-healthcheck' ]
       interval: 3s
-      timeout: 10s
-      retries: 20
-      start_period: 30s
+      timeout: 3s
+      retries: 2
+      start_period: 60s
     init: true
     networks:
       - main
@@ -118,6 +118,7 @@ services:
         required: false
     environment:
       - NODE_ENV=development
+      - COREPACK_ENABLE_DOWNLOAD_PROMPT=0
       - OUTPUT_CATALOG_ID=${OUTPUT_CATALOG_ID:-main}
       - OUTPUT_REDIS_URL=redis://redis:6379
       - OUTPUT_TRACE_LOCAL_ON=${OUTPUT_TRACE_LOCAL_ON:-true}
@@ -127,6 +128,7 @@ services:
       - NODE_OPTIONS=${NODE_OPTIONS:---max-old-space-size=4096}
     command: >
       sh -c "
+        corepack enable &&
         npm run output:worker:install &&
         echo 'Installed dependencies' &&
         npx nodemon --watch src --watch package.json --ext ts,js,json,prompt --ignore 'dist/**' --ignore '**/*.test.ts' --ignore '**/*.spec.ts' --exec 'npm run output:worker:install && npm run output:worker:build && npm run output:worker:start'

package/dist/commands/dev/index.js

@@ -2,7 +2,7 @@ import { Command, Flags } from '@oclif/core';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import logUpdate from 'log-update';
-import { validateDockerEnvironment, startDockerCompose, startDockerComposeDetached, stopDockerCompose, getServiceStatus, DockerComposeConfigNotFoundError, getDefaultDockerComposePath, SERVICE_HEALTH, SERVICE_STATE } from '#services/docker.js';
+import { validateDockerEnvironment, startDockerCompose, startDockerComposeDetached, stopDockerCompose, getServiceStatus, isServiceFailed, DockerComposeConfigNotFoundError, getDefaultDockerComposePath, SERVICE_HEALTH, SERVICE_STATE } from '#services/docker.js';
 import { getErrorMessage } from '#utils/error_utils.js';
 import { getDevSuccessMessage } from '#services/messages.js';
 import { ensureClaudePlugin } from '#services/coding_agents.js';
@@ -43,7 +43,7 @@ const formatService = (service) => {
     return `  ${color}${icon}${ANSI.RESET} ${name} ${ANSI.DIM}${statusPadded}${ANSI.RESET} ${ANSI.DIM}${ports}${ANSI.RESET}`;
 };
 const getFailedServicesWarning = (services) => {
-    const failedServices = services.filter(s => s.state === SERVICE_STATE.EXITED);
+    const failedServices = services.filter(isServiceFailed);
     if (failedServices.length === 0) {
         return [];
     }

package/dist/commands/dev/index.spec.js

@@ -15,6 +15,7 @@ vi.mock('#services/docker.js', () => ({
         { name: 'redis', state: 'running', health: 'healthy', ports: ['6379:6379'] },
         { name: 'temporal', state: 'running', health: 'healthy', ports: ['7233:7233'] }
     ]),
+    isServiceFailed: vi.fn((s) => s.state === 'exited' || s.health === 'unhealthy'),
     DockerComposeConfigNotFoundError: Error,
     DockerValidationError: Error,
     getDefaultDockerComposePath: vi.fn(() => '/path/to/docker-compose-dev.yml'),

package/dist/commands/init.js

@@ -1,6 +1,7 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { UserCancelledError } from '#types/errors.js';
 import { runInit } from '#services/project_scaffold.js';
+import { getErrorMessage } from '#utils/error_utils.js';
 export default class Init extends Command {
     static description = 'Initialize a new Output project by scaffolding the complete project structure';
     static examples = [
@@ -30,8 +31,7 @@ export default class Init extends Command {
                 return;
             }
             // runInit handles cleanup internally and throws Error with message
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            this.error(errorMessage);
+            this.error(getErrorMessage(error));
         }
     }
 }

package/dist/commands/workflow/generate.js

@@ -5,6 +5,8 @@ import { ensureOutputAISystem } from '#services/coding_agents.js';
 import { getWorkflowGenerateSuccessMessage } from '#services/messages.js';
 import { DEFAULT_OUTPUT_DIRS } from '#utils/paths.js';
 import path from 'node:path';
+import * as fsSync from 'node:fs';
+import { getErrorMessage } from '#utils/error_utils.js';
 export default class Generate extends Command {
     static description = 'Generate a new Output workflow from a skeleton or plan file';
     static examples = [
@@ -52,31 +54,33 @@ export default class Generate extends Command {
         if (!flags.skeleton && !planFile) {
             this.error('Full workflow generation not implemented yet. Please use --skeleton flag or --plan-file');
         }
-        try {
-            const result = await generateWorkflow({
-                name: args.name,
-                description: flags.description,
-                outputDir: flags['output-dir'],
-                skeleton: flags.skeleton,
-                force: flags.force
-            });
-            if (planFile) {
-                this.log('\nStarting AI-assisted workflow implementation...\n');
-                const projectRoot = process.cwd();
-                await ensureOutputAISystem(projectRoot);
-                const absolutePlanPath = path.resolve(projectRoot, planFile);
-                const buildOutput = await buildWorkflow(absolutePlanPath, result.targetDir, args.name);
-                await buildWorkflowInteractiveLoop(buildOutput);
-                this.log(ux.colorize('green', '\nWorkflow implementation complete!\n'));
-            }
-            this.displaySuccess(result);
+        const projectRoot = process.cwd();
+        const absolutePlanPath = planFile ? path.resolve(projectRoot, planFile) : '';
+        if (planFile && !fsSync.existsSync(absolutePlanPath)) {
+            this.error(`Plan file not found: ${absolutePlanPath}`);
         }
-        catch (error) {
-            if (error instanceof Error) {
-                this.error(error.message);
-            }
-            throw error;
+        const result = await generateWorkflow({
+            name: args.name,
+            description: flags.description,
+            outputDir: flags['output-dir'],
+            skeleton: flags.skeleton,
+            force: flags.force
+        }).catch((error) => {
+            this.error(getErrorMessage(error));
+        });
+        if (planFile) {
+            this.log('\nStarting AI-assisted workflow implementation...\n');
+            await ensureOutputAISystem(projectRoot);
+            const buildOutput = await buildWorkflow(absolutePlanPath, result.targetDir, args.name)
+                .catch((error) => {
+                fsSync.rmSync(result.targetDir, { recursive: true, force: true });
+                const message = getErrorMessage(error);
+                this.error(`Workflow implementation failed, created files have been rolled back: ${message}`);
+            });
+            await buildWorkflowInteractiveLoop(buildOutput);
+            this.log(ux.colorize('green', '\nWorkflow implementation complete!\n'));
         }
+        this.displaySuccess(result);
     }
     displaySuccess(result) {
         const message = getWorkflowGenerateSuccessMessage(result.workflowName, result.targetDir, result.filesCreated);

package/dist/commands/workflow/plan.js

@@ -52,7 +52,7 @@ export default class WorkflowPlan extends Command {
         if (modifications === acceptKey) {
             return originalPlanContent;
         }
-        const modifiedPlanContent = await replyToClaude(modifications, PLAN_COMMAND_OPTIONS);
+        const modifiedPlanContent = await replyToClaude(modifications, { anthropicOpts: PLAN_COMMAND_OPTIONS });
         return this.planModificationLoop(modifiedPlanContent);
     }
     async planGenerationLoop(promptDescription, planName, projectRoot) {
@@ -62,5 +62,7 @@ export default class WorkflowPlan extends Command {
         const modifiedPlanContent = await this.planModificationLoop(planContent);
         const modifiedSavedPath = await writePlanFile(planName, modifiedPlanContent, projectRoot);
         this.log(`✅ Plan saved to: ${modifiedSavedPath}\n`);
+        const generateCmd = ux.colorize('cyan', `npx output workflow generate <WORKFLOW_NAME> --plan-file=${modifiedSavedPath}`);
+        this.log(`⏭️  To execute this plan run: ${generateCmd}\n`);
     }
 }

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.1.10"
+    "framework": "0.1.11-next.7b8340c.0"
 }

package/dist/services/claude_client.d.ts

@@ -2,13 +2,21 @@
  * Claude Agent SDK client for workflow planning
  */
 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";
+};
 export declare const PLAN_COMMAND_OPTIONS: Options;
+interface ReplyToClaudeOptions {
+    anthropicOpts?: Options;
+    applyAdditionalInstructions?: string;
+}
 export declare const BUILD_COMMAND_OPTIONS: Options;
 export declare class ClaudeInvocationError extends Error {
     cause?: Error | undefined;
     constructor(message: string, cause?: Error | undefined);
 }
-export declare function replyToClaude(message: string, options?: Options): Promise<string>;
+export declare function replyToClaude(message: string, { anthropicOpts, applyAdditionalInstructions }?: ReplyToClaudeOptions): Promise<string>;
 /**
  * Invoke claude-code with /outputai:plan_workflow slash command
  * The SDK loads custom commands from .claude/commands/ when settingSources includes 'project'.
@@ -28,3 +36,4 @@ 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>;
+export {};

package/dist/services/claude_client.js

@@ -6,13 +6,14 @@ import { ux } from '@oclif/core';
 import * as cliProgress from 'cli-progress';
 import { getErrorMessage, toError } from '#utils/error_utils.js';
 import { config } from '#config.js';
-const ADDITIONAL_INSTRUCTIONS = `
+export const ADDITIONAL_INSTRUCTIONS = {
+    PLAN: `
 ! IMPORTANT !
 1. Use TodoWrite to track your progress through plan creation.
 
-2. Please response with only the final version of the plan.
+2. Please respond with only the final version of the plan content.
 
-3. Response in a markdown format with these metadata headers:
+3. Respond in a markdown format with these metadata headers:
 
 ---
 title: <plan-title>
@@ -23,8 +24,12 @@ date: <plan-date>
 <plan-content>
 
 4. After you mark all todos as complete, you must respond with the final version of the plan.
-`;
-const ADDITIONAL_INSTRUCTIONS_BUILD = `
+
+5. DO NOT write the plan to disk — the CLI will handle saving the file to the plans directory.
+
+6. 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.
+`,
+    BUILD: `
 ! IMPORTANT !
 1. Use TodoWrite to track your progress through workflow implementation.
 
@@ -33,7 +38,8 @@ const ADDITIONAL_INSTRUCTIONS_BUILD = `
 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.
-`;
+`
+};
 const PLAN_COMMAND = 'outputai:plan_workflow';
 const BUILD_COMMAND = 'outputai:build_workflow';
 const GLOBAL_CLAUDE_OPTIONS = {
@@ -102,11 +108,8 @@ function getTodoWriteMessage(message) {
     const todoWriteMessage = message.message.content.find((c) => c?.type === 'tool_use' && c.name === 'TodoWrite');
     return todoWriteMessage ?? null;
 }
-function applyInstructions(initialMessage, instructionsType = 'plan') {
-    const instructions = instructionsType === 'build' ?
-        ADDITIONAL_INSTRUCTIONS_BUILD :
-        ADDITIONAL_INSTRUCTIONS;
-    return `${initialMessage}\n\n${instructions}`;
+function applyInstructions(message, instructions) {
+    return `${message}\n\n${instructions}`;
 }
 function createProgressBar() {
     return new cliProgress.SingleBar({
@@ -183,8 +186,8 @@ async function singleQuery(prompt, options = {}) {
         throw new ClaudeInvocationError(`Failed to invoke claude-code: ${getErrorMessage(error)}`, toError(error));
     }
 }
-export async function replyToClaude(message, options = {}) {
-    return singleQuery(applyInstructions(message), { continue: true, ...options });
+export async function replyToClaude(message, { anthropicOpts, applyAdditionalInstructions = ADDITIONAL_INSTRUCTIONS.PLAN } = {}) {
+    return singleQuery(applyInstructions(message, applyAdditionalInstructions), { continue: true, ...anthropicOpts });
 }
 /**
  * Invoke claude-code with /outputai:plan_workflow slash command
@@ -194,7 +197,7 @@ export async function replyToClaude(message, options = {}) {
  * @returns Plan output from claude-code
  */
 export async function invokePlanWorkflow(description) {
-    return singleQuery(applyInstructions(`/${PLAN_COMMAND} ${description}`), PLAN_COMMAND_OPTIONS);
+    return singleQuery(applyInstructions(`/${PLAN_COMMAND} ${description}`, ADDITIONAL_INSTRUCTIONS.PLAN), PLAN_COMMAND_OPTIONS);
 }
 /**
  * Invoke claude-code with /outputai:build_workflow slash command
@@ -211,5 +214,5 @@ export async function invokeBuildWorkflow(planFilePath, workflowDir, workflowNam
     const fullCommand = additionalInstructions ?
         `/${BUILD_COMMAND} ${commandArgs} ${additionalInstructions}` :
         `/${BUILD_COMMAND} ${commandArgs}`;
-    return singleQuery(applyInstructions(fullCommand, 'build'), BUILD_COMMAND_OPTIONS);
+    return singleQuery(applyInstructions(fullCommand, ADDITIONAL_INSTRUCTIONS.BUILD), BUILD_COMMAND_OPTIONS);
 }

package/dist/services/docker.d.ts

@@ -27,6 +27,8 @@ export declare function validateDockerEnvironment(): void;
 export declare function getDefaultDockerComposePath(): string;
 export declare function parseServiceStatus(jsonOutput: string): ServiceStatus[];
 export declare function getServiceStatus(dockerComposePath: string): Promise<ServiceStatus[]>;
+export declare function isServiceHealthy(service: ServiceStatus): boolean;
+export declare function isServiceFailed(service: ServiceStatus): boolean;
 export declare function waitForServicesHealthy(dockerComposePath: string, timeoutMs?: number, pollIntervalMs?: number): Promise<void>;
 export interface DockerComposeProcess {
     process: ChildProcess;

package/dist/services/docker.js

@@ -103,11 +103,18 @@ const formatServiceStatus = (services) => services.map(s => {
     const status = s.health === SERVICE_HEALTH.NONE ? s.state : s.health;
     return `  ${color}${icon}${ANSI_RESET} ${s.name}: ${status}`;
 }).join('\n');
+export function isServiceHealthy(service) {
+    return service.state !== SERVICE_STATE.EXITED &&
+        (service.health === SERVICE_HEALTH.HEALTHY || service.health === SERVICE_HEALTH.NONE);
+}
+export function isServiceFailed(service) {
+    return service.state === SERVICE_STATE.EXITED || service.health === SERVICE_HEALTH.UNHEALTHY;
+}
 export async function waitForServicesHealthy(dockerComposePath, timeoutMs = 120000, pollIntervalMs = 2000) {
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
         const services = await getServiceStatus(dockerComposePath);
-        const allHealthy = services.every(s => s.health === SERVICE_HEALTH.HEALTHY || s.health === SERVICE_HEALTH.NONE);
+        const allHealthy = services.every(isServiceHealthy);
         if (services.length > 0) {
             const statusLines = formatServiceStatus(services);
             logUpdate(`⏳ Waiting for services to become healthy...\n${statusLines}`);

package/dist/services/docker.spec.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { execFileSync } from 'node:child_process';
-import { parseServiceStatus, getServiceStatus, waitForServicesHealthy } from './docker.js';
+import { parseServiceStatus, getServiceStatus, waitForServicesHealthy, isServiceHealthy, isServiceFailed } from './docker.js';
 vi.mock('node:child_process', () => ({
     execSync: vi.fn(),
     execFileSync: vi.fn(),
@@ -89,6 +89,46 @@ describe('docker service', () => {
             await expect(getServiceStatus('/path/to/docker-compose.yml')).rejects.toThrow();
         });
     });
+    describe('isServiceHealthy', () => {
+        it('should return true for a running service with health: healthy', () => {
+            expect(isServiceHealthy({ name: 'redis', state: 'running', health: 'healthy', ports: [] })).toBe(true);
+        });
+        it('should return true for a running service with no health check (health: none)', () => {
+            expect(isServiceHealthy({ name: 'api', state: 'running', health: 'none', ports: [] })).toBe(true);
+        });
+        it('should return false for a running service with health: unhealthy', () => {
+            expect(isServiceHealthy({ name: 'worker', state: 'running', health: 'unhealthy', ports: [] })).toBe(false);
+        });
+        it('should return false for an exited service with health: none', () => {
+            expect(isServiceHealthy({ name: 'worker', state: 'exited', health: 'none', ports: [] })).toBe(false);
+        });
+        it('should return false for an exited service with health: unhealthy', () => {
+            expect(isServiceHealthy({ name: 'worker', state: 'exited', health: 'unhealthy', ports: [] })).toBe(false);
+        });
+        it('should return false for a service with health: starting', () => {
+            expect(isServiceHealthy({ name: 'temporal', state: 'running', health: 'starting', ports: [] })).toBe(false);
+        });
+    });
+    describe('isServiceFailed', () => {
+        it('should return true for an exited service with health: none', () => {
+            expect(isServiceFailed({ name: 'worker', state: 'exited', health: 'none', ports: [] })).toBe(true);
+        });
+        it('should return true for a running service with health: unhealthy', () => {
+            expect(isServiceFailed({ name: 'worker', state: 'running', health: 'unhealthy', ports: [] })).toBe(true);
+        });
+        it('should return true for an exited service with health: unhealthy', () => {
+            expect(isServiceFailed({ name: 'worker', state: 'exited', health: 'unhealthy', ports: [] })).toBe(true);
+        });
+        it('should return false for a running service with health: healthy', () => {
+            expect(isServiceFailed({ name: 'redis', state: 'running', health: 'healthy', ports: [] })).toBe(false);
+        });
+        it('should return false for a running service with health: none', () => {
+            expect(isServiceFailed({ name: 'api', state: 'running', health: 'none', ports: [] })).toBe(false);
+        });
+        it('should return false for a service with health: starting — not a failure, just in progress', () => {
+            expect(isServiceFailed({ name: 'temporal', state: 'running', health: 'starting', ports: [] })).toBe(false);
+        });
+    });
     describe('waitForServicesHealthy', () => {
         it('should resolve when all services are healthy', async () => {
             const mockOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}
@@ -108,6 +148,24 @@ describe('docker service', () => {
             const promise = waitForServicesHealthy('/path/to/docker-compose.yml', 100);
             await expect(promise).rejects.toThrow('Timeout waiting for services to become healthy');
         }, 10000);
+        it('should not resolve when a service has exited with no health check — regression OUT-334', async () => {
+            // Exited containers have empty Health which parses to 'none'.
+            // Previously, state:exited + health:none was incorrectly treated as healthy.
+            const mockOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}
+{"Service":"worker","State":"exited","Health":"","Publishers":[]}`;
+            vi.mocked(execFileSync).mockReturnValue(mockOutput);
+            const promise = waitForServicesHealthy('/path/to/docker-compose.yml', 100, 50);
+            await expect(promise).rejects.toThrow('Timeout waiting for services to become healthy');
+        }, 10000);
+        it('should not resolve when a service is running but unhealthy — regression OUT-334', async () => {
+            // Nodemon keeps the container running even when the exec'd command fails,
+            // so the unhealthy case is state:running + health:unhealthy.
+            const mockOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}
+{"Service":"worker","State":"running","Health":"unhealthy","Publishers":[]}`;
+            vi.mocked(execFileSync).mockReturnValue(mockOutput);
+            const promise = waitForServicesHealthy('/path/to/docker-compose.yml', 100, 50);
+            await expect(promise).rejects.toThrow('Timeout waiting for services to become healthy');
+        }, 10000);
         it('should poll multiple times until healthy', async () => {
             const callTracker = { count: 0 };
             vi.mocked(execFileSync).mockImplementation(() => {

package/dist/services/project_scaffold.js

@@ -139,8 +139,7 @@ function formatInitError(error, projectPath) {
         case 'EPERM': return `Operation not permitted${pathSuffix}`;
         case 'ENOENT': return `Required file or directory not found${pathSuffix}`;
         default: {
-            const originalMessage = error instanceof Error ? error.message : String(error);
-            return `Failed to create project${pathSuffix}: ${originalMessage}`;
+            return `Failed to create project${pathSuffix}: ${getErrorMessage(error)}`;
         }
     }
 }

package/dist/services/workflow_builder.js

@@ -1,7 +1,7 @@
 /**
  * Workflow builder service for implementing workflows from plan files
  */
-import { BUILD_COMMAND_OPTIONS, invokeBuildWorkflow as invokeBuildWorkflowFromClient, replyToClaude } from './claude_client.js';
+import { ADDITIONAL_INSTRUCTIONS, BUILD_COMMAND_OPTIONS, invokeBuildWorkflow as invokeBuildWorkflowFromClient, replyToClaude } from './claude_client.js';
 import { input } from '@inquirer/prompts';
 import { ux } from '@oclif/core';
 import fs from 'node:fs/promises';
@@ -56,12 +56,15 @@ async function processModification(modification, currentOutput) {
         return currentOutput;
     }
     try {
-        const updatedOutput = await replyToClaude(modification, BUILD_COMMAND_OPTIONS);
+        const updatedOutput = await replyToClaude(modification, {
+            anthropicOpts: BUILD_COMMAND_OPTIONS,
+            applyAdditionalInstructions: ADDITIONAL_INSTRUCTIONS.BUILD
+        });
         displayImplementationOutput(updatedOutput, '✓ Implementation updated!');
         return updatedOutput;
     }
     catch (error) {
-        ux.error(`Failed to apply modifications: ${getErrorMessage(error)}`);
+        ux.stdout(ux.colorize('red', `Failed to apply modifications: ${getErrorMessage(error)}`));
         ux.stdout('Continuing with previous version...\n');
         return currentOutput;
     }

package/dist/services/workflow_builder.spec.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { buildWorkflow, buildWorkflowInteractiveLoop } from './workflow_builder.js';
-import { BUILD_COMMAND_OPTIONS, invokeBuildWorkflow, replyToClaude } from './claude_client.js';
+import { ADDITIONAL_INSTRUCTIONS, BUILD_COMMAND_OPTIONS, invokeBuildWorkflow, replyToClaude } from './claude_client.js';
 import { input } from '@inquirer/prompts';
 import { ux } from '@oclif/core';
 import fs from 'node:fs/promises';
@@ -97,7 +97,10 @@ describe('workflow-builder service', () => {
                 .mockResolvedValueOnce('ACCEPT');
             vi.mocked(replyToClaude).mockResolvedValue('Updated implementation with error handling');
             const result = await buildWorkflowInteractiveLoop('Initial implementation');
-            expect(replyToClaude).toHaveBeenCalledWith('Add error handling', BUILD_COMMAND_OPTIONS);
+            expect(replyToClaude).toHaveBeenCalledWith('Add error handling', {
+                anthropicOpts: BUILD_COMMAND_OPTIONS,
+                applyAdditionalInstructions: ADDITIONAL_INSTRUCTIONS.BUILD
+            });
             expect(result).toBe('Updated implementation with error handling');
             expect(input).toHaveBeenCalledTimes(2);
         });
@@ -111,8 +114,14 @@ describe('workflow-builder service', () => {
                 .mockResolvedValueOnce('Implementation with logging and validation');
             const result = await buildWorkflowInteractiveLoop('Initial implementation');
             expect(replyToClaude).toHaveBeenCalledTimes(2);
-            expect(replyToClaude).toHaveBeenNthCalledWith(1, 'Add logging', BUILD_COMMAND_OPTIONS);
-            expect(replyToClaude).toHaveBeenNthCalledWith(2, 'Add validation', BUILD_COMMAND_OPTIONS);
+            expect(replyToClaude).toHaveBeenNthCalledWith(1, 'Add logging', {
+                anthropicOpts: BUILD_COMMAND_OPTIONS,
+                applyAdditionalInstructions: ADDITIONAL_INSTRUCTIONS.BUILD
+            });
+            expect(replyToClaude).toHaveBeenNthCalledWith(2, 'Add validation', {
+                anthropicOpts: BUILD_COMMAND_OPTIONS,
+                applyAdditionalInstructions: ADDITIONAL_INSTRUCTIONS.BUILD
+            });
             expect(result).toBe('Implementation with logging and validation');
         });
         it('should prompt again when user provides empty input', async () => {
@@ -146,7 +155,7 @@ describe('workflow-builder service', () => {
             const result = await buildWorkflowInteractiveLoop('Original implementation');
             // Should return original implementation after error
             expect(result).toBe('Original implementation');
-            expect(ux.error).toHaveBeenCalledWith(expect.stringContaining('Failed to apply modifications'));
+            expect(ux.stdout).toHaveBeenCalledWith(expect.stringContaining('Failed to apply modifications'));
             expect(ux.stdout).toHaveBeenCalledWith(expect.stringContaining('Continuing with previous version'));
         });
         it('should continue looping after handling error', async () => {

package/dist/services/workflow_generator.js

@@ -15,9 +15,9 @@ function validateConfig(config) {
  * Check if target directory exists and handle accordingly
  */
 import * as fsSync from 'node:fs';
-async function checkTargetDirectory(targetDir, force) {
+async function checkTargetDirectory(name, targetDir, force) {
     if (fsSync.existsSync(targetDir) && !force) {
-        throw new WorkflowExistsError('', targetDir);
+        throw new WorkflowExistsError(name, targetDir);
     }
 }
 /**
@@ -27,7 +27,7 @@ export async function generateWorkflow(config) {
     validateConfig(config);
     const targetDir = createTargetDir(config.outputDir, config.name);
     const templatesDir = getTemplateDir('workflow');
-    await checkTargetDirectory(targetDir, config.force);
+    await checkTargetDirectory(config.name, targetDir, config.force);
     await fs.mkdir(targetDir, { recursive: true });
     const variables = prepareTemplateVariables(config.name, config.description || '');
     const templateFiles = await getTemplateFiles(templatesDir);

package/dist/types/domain.d.ts

@@ -3,7 +3,6 @@
  */
 export type TodoStatus = 'pending' | 'in_progress' | 'completed';
 export type FileMappingType = 'template' | 'symlink' | 'copy';
-export type InstructionsType = 'plan' | 'build';
 export interface Todo {
     content: string;
     activeForm: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.1.10",
+  "version": "0.1.11-next.7b8340c.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -33,9 +33,9 @@
     "log-update": "7.2.0",
     "semver": "7.7.4",
     "yaml": "^2.8.3",
-    "@outputai/credentials": "0.1.10",
-    "@outputai/llm": "0.1.10",
-    "@outputai/evals": "0.1.10"
+    "@outputai/evals": "0.1.11-next.7b8340c.0",
+    "@outputai/credentials": "0.1.11-next.7b8340c.0",
+    "@outputai/llm": "0.1.11-next.7b8340c.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",