@output.ai/cli 0.5.6 → 0.7.0

package/README.md

@@ -54,6 +54,7 @@ OUTPUT_CLI_ENV=/etc/output/production.env npx output workflow status wf-123
 | `output workflow status` | Get workflow execution status |
 | `output workflow result` | Get workflow execution result |
 | `output workflow stop` | Stop a workflow execution |
+| `output workflow terminate` | Terminate a workflow execution (force stop) |
 | `output workflow debug` | Display workflow execution trace |
 
 ## Development Services

package/dist/api/generated/api.d.ts

@@ -198,6 +198,10 @@ export type GetWorkflowIdStatus200 = {
     /** An epoch timestamp representing when the workflow ended */
     completedAt?: number;
 };
+export type PostWorkflowIdTerminateBody = {
+    /** Optional reason for termination */
+    reason?: string;
+};
 export type GetWorkflowIdResult200 = {
     /** The workflow execution id */
     workflowId?: string;
@@ -316,6 +320,27 @@ export type patchWorkflowIdStopResponseError = (patchWorkflowIdStopResponse404)
 export type patchWorkflowIdStopResponse = (patchWorkflowIdStopResponseSuccess | patchWorkflowIdStopResponseError);
 export declare const getPatchWorkflowIdStopUrl: (id: string) => string;
 export declare const patchWorkflowIdStop: (id: string, options?: ApiRequestOptions) => Promise<patchWorkflowIdStopResponse>;
+/**
+ * Force terminates a workflow. Unlike stop/cancel, terminate immediately stops the workflow without allowing cleanup.
+ * @summary Terminate a workflow execution (force stop)
+ */
+export type postWorkflowIdTerminateResponse200 = {
+    data: void;
+    status: 200;
+};
+export type postWorkflowIdTerminateResponse404 = {
+    data: void;
+    status: 404;
+};
+export type postWorkflowIdTerminateResponseSuccess = (postWorkflowIdTerminateResponse200) & {
+    headers: Headers;
+};
+export type postWorkflowIdTerminateResponseError = (postWorkflowIdTerminateResponse404) & {
+    headers: Headers;
+};
+export type postWorkflowIdTerminateResponse = (postWorkflowIdTerminateResponseSuccess | postWorkflowIdTerminateResponseError);
+export declare const getPostWorkflowIdTerminateUrl: (id: string) => string;
+export declare const postWorkflowIdTerminate: (id: string, postWorkflowIdTerminateBody: PostWorkflowIdTerminateBody, options?: ApiRequestOptions) => Promise<postWorkflowIdTerminateResponse>;
 /**
  * @summary Return the result of a workflow
  */

package/dist/api/generated/api.js

@@ -87,6 +87,17 @@ export const patchWorkflowIdStop = async (id, options) => {
         method: 'PATCH'
     });
 };
+export const getPostWorkflowIdTerminateUrl = (id) => {
+    return `/workflow/${id}/terminate`;
+};
+export const postWorkflowIdTerminate = async (id, postWorkflowIdTerminateBody, options) => {
+    return customFetchInstance(getPostWorkflowIdTerminateUrl(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(postWorkflowIdTerminateBody)
+    });
+};
 export const getGetWorkflowIdResultUrl = (id) => {
     return `/workflow/${id}/result`;
 };

package/dist/commands/agents/init.d.ts

@@ -4,7 +4,6 @@ export default class Init extends Command {
     static examples: string[];
     static args: {};
     static flags: {
-        'agent-provider': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/agents/init.js

@@ -1,21 +1,14 @@
 import { Command, Flags } from '@oclif/core';
-import { AGENT_CONFIG_DIR } from '#config.js';
-import { initializeAgentConfig, AGENT_CONFIGS } from '#services/coding_agents.js';
+import { initializeAgentConfig } from '#services/coding_agents.js';
 import { getErrorMessage, getErrorCode } from '#utils/error_utils.js';
 export default class Init extends Command {
-    static description = 'Initialize agent configuration files for AI assistant integration';
+    static description = 'Initialize agent configuration files for Claude Code plugin integration';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --agent-provider claude-code',
         '<%= config.bin %> <%= command.id %> --force'
     ];
     static args = {};
     static flags = {
-        'agent-provider': Flags.string({
-            description: 'Specify the coding agent provider',
-            default: AGENT_CONFIGS['claude-code'].id,
-            options: [AGENT_CONFIGS['claude-code'].id]
-        }),
         force: Flags.boolean({
             char: 'f',
             description: 'Overwrite existing files',
@@ -28,16 +21,16 @@ export default class Init extends Command {
         try {
             await initializeAgentConfig({
                 projectRoot: process.cwd(),
-                force: flags.force,
-                agentProvider: flags['agent-provider']
+                force: flags.force
             });
-            this.log('✅ Agent configuration initialized successfully!');
+            this.log('Agent configuration initialized successfully!');
             this.log('');
-            this.log('Created:');
-            this.log(`  • ${AGENT_CONFIG_DIR}/ directory with agent and command configurations`);
-            this.log('  • .claude/ directory with symlinks for Claude Code integration');
+            this.log('Configured:');
+            this.log('  - Registered marketplace: growthxai/output-claude-plugins');
+            this.log('  - Updated marketplace: outputai');
+            this.log('  - Installed plugin: outputai@outputai');
             this.log('');
-            this.log('Claude Code will automatically detect and use these configurations.');
+            this.log('Claude Code will automatically use the OutputAI plugin.');
         }
         catch (error) {
             if (getErrorCode(error) === 'EACCES') {

package/dist/commands/agents/init.spec.js

@@ -1,36 +1,15 @@
-/* eslint-disable no-restricted-syntax, @typescript-eslint/no-explicit-any, init-declarations */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import fs from 'node:fs/promises';
-import path from 'node:path';
 import Init from './init.js';
-import { getTemplateDir } from '#utils/paths.js';
-import { processTemplate } from '#utils/template.js';
-vi.mock('node:fs/promises');
-vi.mock('node:path', async () => {
-    const actual = await vi.importActual('node:path');
-    return {
-        ...actual,
-        join: vi.fn((...args) => args.join('/')),
-        dirname: vi.fn(p => p.split('/').slice(0, -1).join('/') || '.'),
-        relative: vi.fn((from, to) => {
-            if (to === 'CLAUDE.md' && from === '.') {
-                return '.outputai/AGENTS.md';
-            }
-            if (to.includes('.outputai/agents')) {
-                return `../../.outputai/agents/${path.basename(to)}`;
-            }
-            if (to.includes('.outputai/commands')) {
-                return `../../.outputai/commands/${path.basename(to)}`;
-            }
-            return to;
-        })
-    };
-});
-vi.mock('../../utils/paths.js');
-vi.mock('../../utils/template.js');
+import { initializeAgentConfig } from '#services/coding_agents.js';
+vi.mock('#services/coding_agents.js', () => ({
+    initializeAgentConfig: vi.fn(),
+    AGENT_CONFIGS: { 'claude-code': { id: 'claude-code' } }
+}));
+vi.mock('#config.js', () => ({
+    AGENT_CONFIG_DIR: '.outputai'
+}));
 describe('agents init', () => {
-    let mockGetTemplateDir;
-    let mockProcessTemplate;
     const createTestCommand = (args = []) => {
         const cmd = new Init(args, {});
         cmd.log = vi.fn();
@@ -42,19 +21,7 @@ describe('agents init', () => {
     };
     beforeEach(() => {
         vi.clearAllMocks();
-        vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-        vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-        vi.mocked(fs.symlink).mockResolvedValue(undefined);
-        vi.mocked(fs.stat).mockRejectedValue({ code: 'ENOENT' });
-        vi.mocked(fs.access).mockRejectedValue({ code: 'ENOENT' }); // Files don't exist by default
-        vi.mocked(fs.unlink).mockResolvedValue(undefined);
-        vi.mocked(fs.readFile).mockResolvedValue('Template content with {{date}}');
-        mockGetTemplateDir = vi.mocked(getTemplateDir);
-        mockGetTemplateDir.mockReturnValue('/templates/agent_instructions');
-        mockProcessTemplate = vi.mocked(processTemplate);
-        mockProcessTemplate.mockImplementation((content, variables) => {
-            return content.replace(/\{\{(\w+)\}\}/g, (_match, key) => variables[key] || _match);
-        });
+        vi.mocked(initializeAgentConfig).mockResolvedValue(undefined);
     });
     afterEach(() => {
         vi.restoreAllMocks();
@@ -64,221 +31,79 @@ describe('agents init', () => {
             expect(Init.description).toBeDefined();
             expect(Init.description).toContain('agent configuration');
         });
-        it('should have correct examples', () => {
+        it('should have correct examples without agent-provider flag', () => {
             expect(Init.examples).toBeDefined();
             expect(Array.isArray(Init.examples)).toBe(true);
+            const examplesStr = Init.examples.join(' ');
+            expect(examplesStr).not.toContain('agent-provider');
         });
         it('should have no required arguments', () => {
             expect(Init.args).toBeDefined();
             expect(Object.keys(Init.args)).toHaveLength(0);
         });
-        it('should have appropriate flags', () => {
+        it('should only have force flag', () => {
             expect(Init.flags).toBeDefined();
             expect(Init.flags.force).toBeDefined();
+            expect(Object.keys(Init.flags)).toHaveLength(1);
         });
     });
-    describe('directory creation', () => {
-        it('should create .outputai directory structure', async () => {
-            const mockMkdir = vi.mocked(fs.mkdir);
-            mockMkdir.mockResolvedValue(undefined);
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
-            await cmd.run();
-            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai'), expect.objectContaining({ recursive: true }));
-            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai/agents'), expect.objectContaining({ recursive: true }));
-            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai/commands'), expect.objectContaining({ recursive: true }));
-            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai/meta'), expect.objectContaining({ recursive: true }));
-        });
-        it('should create .claude directory structure', async () => {
-            const mockMkdir = vi.mocked(fs.mkdir);
-            mockMkdir.mockResolvedValue(undefined);
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
-            await cmd.run();
-            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.claude'), expect.objectContaining({ recursive: true }));
-            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.claude/agents'), expect.objectContaining({ recursive: true }));
-            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.claude/commands'), expect.objectContaining({ recursive: true }));
-        });
-    });
-    describe('file creation from templates', () => {
-        it('should create AGENTS.md file from template', async () => {
-            const mockWriteFile = vi.mocked(fs.writeFile);
-            const mockReadFile = vi.mocked(fs.readFile);
-            mockReadFile.mockResolvedValue('Agent instructions {{date}}');
+    describe('successful execution', () => {
+        it('should call initializeAgentConfig with correct options', async () => {
             const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            cmd.parse.mockResolvedValue({ flags: { force: false }, args: {} });
             await cmd.run();
-            expect(mockReadFile).toHaveBeenCalledWith(expect.stringContaining('AGENTS.md.template'), 'utf-8');
-            expect(mockWriteFile).toHaveBeenCalledWith(expect.stringContaining('.outputai/AGENTS.md'), expect.stringContaining('Agent instructions'), 'utf-8');
+            expect(initializeAgentConfig).toHaveBeenCalledWith({
+                projectRoot: expect.any(String),
+                force: false
+            });
         });
-        it('should create all agent configuration files', async () => {
-            const mockWriteFile = vi.mocked(fs.writeFile);
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
-            await cmd.run();
-            const agentFiles = [
-                '.outputai/agents/workflow_planner.md'
-            ];
-            for (const file of agentFiles) {
-                expect(mockWriteFile).toHaveBeenCalledWith(expect.stringContaining(file), expect.any(String), 'utf-8');
-            }
-        });
-        it('should create all command configuration files', async () => {
-            const mockWriteFile = vi.mocked(fs.writeFile);
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
-            await cmd.run();
-            const commandFiles = [
-                '.outputai/commands/plan_workflow.md'
-            ];
-            for (const file of commandFiles) {
-                expect(mockWriteFile).toHaveBeenCalledWith(expect.stringContaining(file), expect.any(String), 'utf-8');
-            }
-        });
-        it('should create all meta configuration files', async () => {
-            const mockWriteFile = vi.mocked(fs.writeFile);
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
-            await cmd.run();
-            const metaFiles = [
-                '.outputai/meta/pre_flight.md',
-                '.outputai/meta/post_flight.md'
-            ];
-            for (const file of metaFiles) {
-                expect(mockWriteFile).toHaveBeenCalledWith(expect.stringContaining(file), expect.any(String), 'utf-8');
-            }
-        });
-    });
-    describe('symlink creation', () => {
-        it('should create symlink from CLAUDE.md to .outputai/AGENTS.md', async () => {
-            const mockSymlink = vi.mocked(fs.symlink);
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
-            await cmd.run();
-            // Symlink creates a relative link from target to source
-            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/AGENTS.md'), expect.stringContaining('CLAUDE.md'));
-        });
-        it('should create symlinks for all agent files', async () => {
-            const mockSymlink = vi.mocked(fs.symlink);
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+        it('should pass force flag to initializeAgentConfig', async () => {
+            const cmd = createTestCommand(['--force']);
+            cmd.parse.mockResolvedValue({ flags: { force: true }, args: {} });
             await cmd.run();
-            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/agents/workflow_planner.md'), expect.stringContaining('.claude/agents/workflow_planner.md'));
+            expect(initializeAgentConfig).toHaveBeenCalledWith({
+                projectRoot: expect.any(String),
+                force: true
+            });
         });
-        it('should create symlinks for all command files', async () => {
-            const mockSymlink = vi.mocked(fs.symlink);
+        it('should display success messages', async () => {
             const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            cmd.parse.mockResolvedValue({ flags: { force: false }, args: {} });
             await cmd.run();
-            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/commands/plan_workflow.md'), expect.stringContaining('.claude/commands/plan_workflow.md'));
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('initialized successfully'));
+            expect(cmd.log).toHaveBeenCalledWith('Configured:');
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('OutputAI plugin'));
         });
-        it('should handle Windows by copying files when symlinks are not supported', async () => {
-            const mockSymlink = vi.mocked(fs.symlink);
-            const mockWriteFile = vi.mocked(fs.writeFile);
-            const mockReadFile = vi.mocked(fs.readFile);
-            mockSymlink.mockRejectedValue({ code: 'ENOTSUP' });
-            // readFile is called for both templates AND fallback copy
-            mockReadFile.mockResolvedValue('File content');
+        it('should display plugin configuration messages', async () => {
             const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            cmd.parse.mockResolvedValue({ flags: { force: false }, args: {} });
             await cmd.run();
-            // When symlinks fail, it falls back to copying the source files
-            // Source files are the .outputai files, targets are CLAUDE.md and .claude/ files
-            const writeCalls = mockWriteFile.mock.calls;
-            // Should have written template files + fallback copies
-            expect(writeCalls.length).toBeGreaterThan(3); // At least 3 templates + 3 symlink fallbacks
-            // Verify at least one fallback copy happened
-            const claudeFileCalls = writeCalls.filter(call => typeof call[0] === 'string' && (call[0].includes('CLAUDE.md') ||
-                call[0].includes('.claude/')));
-            expect(claudeFileCalls.length).toBeGreaterThan(0);
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('marketplace'));
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('plugin'));
         });
     });
     describe('error handling', () => {
-        it('should handle existing directory gracefully', async () => {
-            const mockMkdir = vi.mocked(fs.mkdir);
-            mockMkdir.mockRejectedValue({ code: 'EEXIST' });
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
-            await cmd.run();
-            expect(cmd.error).not.toHaveBeenCalled();
-        });
         it('should handle permission errors', async () => {
-            const mockMkdir = vi.mocked(fs.mkdir);
-            mockMkdir.mockRejectedValue({ code: 'EACCES' });
+            vi.mocked(initializeAgentConfig).mockRejectedValue({ code: 'EACCES' });
             const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            cmd.parse.mockResolvedValue({ flags: { force: false }, args: {} });
             await cmd.run();
             expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Permission denied'));
         });
-        it('should be idempotent (safe to run multiple times)', async () => {
-            const mockWriteFile = vi.mocked(fs.writeFile);
-            mockWriteFile.mockResolvedValue(undefined);
+        it('should handle general errors with message', async () => {
+            vi.mocked(initializeAgentConfig).mockRejectedValue(new Error('Something went wrong'));
             const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
-            await cmd.run();
+            cmd.parse.mockResolvedValue({ flags: { force: false }, args: {} });
             await cmd.run();
-            expect(cmd.error).not.toHaveBeenCalled();
+            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Failed to initialize agent configuration'));
+            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Something went wrong'));
         });
-    });
-    describe('complete initialization', () => {
-        it('should create all required files and directories', async () => {
-            const mockMkdir = vi.mocked(fs.mkdir);
-            const mockWriteFile = vi.mocked(fs.writeFile);
-            const mockSymlink = vi.mocked(fs.symlink);
+        it('should handle Claude CLI not found error', async () => {
+            vi.mocked(initializeAgentConfig).mockRejectedValue(new Error('Claude CLI not found. Please install Claude Code CLI and ensure \'claude\' is in your PATH.'));
             const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
-            await cmd.run();
-            // Verify all expected directories are created
-            const expectedDirs = [
-                '.outputai',
-                '.outputai/agents',
-                '.outputai/commands',
-                '.outputai/meta',
-                '.claude',
-                '.claude/agents',
-                '.claude/commands'
-            ];
-            for (const dir of expectedDirs) {
-                expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining(dir), expect.objectContaining({ recursive: true }));
-            }
-            // Verify all expected template files are created
-            const expectedFiles = [
-                '.outputai/AGENTS.md',
-                '.outputai/agents/workflow_planner.md',
-                '.outputai/commands/plan_workflow.md',
-                '.outputai/meta/pre_flight.md',
-                '.outputai/meta/post_flight.md'
-            ];
-            for (const file of expectedFiles) {
-                expect(mockWriteFile).toHaveBeenCalledWith(expect.stringContaining(file), expect.any(String), 'utf-8');
-            }
-            // Verify symlinks are created
-            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/AGENTS.md'), expect.stringContaining('CLAUDE.md'));
-            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/agents/workflow_planner.md'), expect.stringContaining('.claude/agents/workflow_planner.md'));
-            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/commands/plan_workflow.md'), expect.stringContaining('.claude/commands/plan_workflow.md'));
-        });
-    });
-    describe('force flag', () => {
-        it('should overwrite existing files when force flag is set', async () => {
-            const mockWriteFile = vi.mocked(fs.writeFile);
-            const mockStat = vi.mocked(fs.stat);
-            mockStat.mockResolvedValue({ isFile: () => true });
-            mockWriteFile.mockResolvedValue(undefined);
-            const cmd = createTestCommand(['--force']);
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: true }, args: {} });
+            cmd.parse.mockResolvedValue({ flags: { force: false }, args: {} });
             await cmd.run();
-            expect(mockWriteFile).toHaveBeenCalled();
-            expect(cmd.warn).not.toHaveBeenCalled();
-        });
-        it('should skip existing files without force flag', async () => {
-            const mockAccess = vi.mocked(fs.access);
-            mockAccess.mockResolvedValue(undefined);
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
-            await cmd.run();
-            // Files exist, so they should be skipped
-            // The command should complete without errors
-            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('initialized successfully'));
+            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Claude CLI not found'));
         });
     });
 });

package/dist/commands/workflow/generate.js

@@ -1,7 +1,7 @@
 import { Args, Command, Flags, ux } from '@oclif/core';
 import { generateWorkflow } from '#services/workflow_generator.js';
 import { buildWorkflow, buildWorkflowInteractiveLoop } from '#services/workflow_builder.js';
-import { ensureOutputAIStructure } from '#services/coding_agents.js';
+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';
@@ -63,7 +63,7 @@ export default class Generate extends Command {
             if (planFile) {
                 this.log('\nStarting AI-assisted workflow implementation...\n');
                 const projectRoot = process.cwd();
-                await ensureOutputAIStructure(projectRoot);
+                await ensureOutputAISystem(projectRoot);
                 const absolutePlanPath = path.resolve(projectRoot, planFile);
                 const buildOutput = await buildWorkflow(absolutePlanPath, result.targetDir, args.name);
                 await buildWorkflowInteractiveLoop(buildOutput);

package/dist/commands/workflow/plan.js

@@ -1,7 +1,7 @@
 import { Command, Flags, ux } from '@oclif/core';
 import { input } from '@inquirer/prompts';
 import { generatePlanName, updateAgentTemplates, writePlanFile } from '#services/workflow_planner.js';
-import { ensureOutputAIStructure } from '#services/coding_agents.js';
+import { ensureOutputAISystem } from '#services/coding_agents.js';
 import { invokePlanWorkflow, PLAN_COMMAND_OPTIONS, replyToClaude } from '#services/claude_client.js';
 export default class WorkflowPlan extends Command {
     static description = 'Generate a workflow plan from a description';
@@ -25,7 +25,7 @@ export default class WorkflowPlan extends Command {
         const { flags } = await this.parse(WorkflowPlan);
         const projectRoot = process.cwd();
         this.log('Checking .outputai directory structure...');
-        await ensureOutputAIStructure(projectRoot);
+        await ensureOutputAISystem(projectRoot);
         if (flags['force-agent-file-write']) {
             this.log('Updating agent templates...');
             await updateAgentTemplates(projectRoot);
@@ -56,7 +56,7 @@ export default class WorkflowPlan extends Command {
         return this.planModificationLoop(modifiedPlanContent);
     }
     async planGenerationLoop(promptDescription, planName, projectRoot) {
-        this.log('\nInvoking the /plan_workflow command...');
+        this.log('\nInvoking the /outputai:plan_workflow command...');
         this.log('This may take a moment...\n');
         const planContent = await invokePlanWorkflow(promptDescription);
         const modifiedPlanContent = await this.planModificationLoop(planContent);

package/dist/commands/workflow/plan.spec.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import WorkflowPlan from './plan.js';
 import { generatePlanName, writePlanFile, updateAgentTemplates } from '#services/workflow_planner.js';
-import { ensureOutputAIStructure } from '#services/coding_agents.js';
+import { ensureOutputAISystem } from '#services/coding_agents.js';
 import { invokePlanWorkflow, replyToClaude, ClaudeInvocationError } from '#services/claude_client.js';
 import { input } from '@inquirer/prompts';
 vi.mock('#services/workflow_planner.js');
@@ -28,7 +28,7 @@ describe('WorkflowPlan Command', () => {
             }
             return 'ACCEPT'; // Always accept on second call to stop recursion
         }));
-        vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+        vi.mocked(ensureOutputAISystem).mockResolvedValue();
         vi.mocked(generatePlanName).mockResolvedValue(planName);
         vi.mocked(invokePlanWorkflow).mockResolvedValue(planContent);
         vi.mocked(replyToClaude).mockResolvedValue(planContent);
@@ -69,7 +69,7 @@ describe('WorkflowPlan Command', () => {
             });
             setupSuccessfulMocks('Build a user authentication system', '2025_10_06_user_authentication', '# Workflow Plan\n\nPlan content here');
             await command.run();
-            expect(ensureOutputAIStructure).toHaveBeenCalled();
+            expect(ensureOutputAISystem).toHaveBeenCalled();
             expect(generatePlanName).toHaveBeenCalledWith('Build a user authentication system');
             expect(invokePlanWorkflow).toHaveBeenCalledWith('Build a user authentication system');
             expect(writePlanFile).toHaveBeenCalledWith('2025_10_06_user_authentication', '# Workflow Plan\n\nPlan content here', expect.any(String));
@@ -106,7 +106,7 @@ describe('WorkflowPlan Command', () => {
                 return 'ACCEPT'; // Second call from modification loop
             });
             vi.mocked(input).mockImplementation(inputMock);
-            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
             vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
             vi.mocked(invokePlanWorkflow).mockResolvedValue('# Plan');
             vi.mocked(replyToClaude).mockResolvedValue('# Plan');
@@ -122,7 +122,7 @@ describe('WorkflowPlan Command', () => {
                 args: {},
                 flags: { 'force-agent-file-write': false }
             });
-            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
             vi.mocked(input).mockResolvedValue('Test workflow');
             vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
             vi.mocked(invokePlanWorkflow).mockRejectedValue(new Error('ANTHROPIC_API_KEY environment variable is required'));
@@ -134,7 +134,7 @@ describe('WorkflowPlan Command', () => {
                 args: {},
                 flags: { 'force-agent-file-write': false }
             });
-            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
             vi.mocked(input).mockResolvedValue('Test workflow');
             vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
             const claudeError = new ClaudeInvocationError('Failed to invoke claude-code: API error');
@@ -158,7 +158,7 @@ describe('WorkflowPlan Command', () => {
                 state.inputCallCount++;
                 return state.inputCallCount === 1 ? 'Test workflow' : 'ACCEPT';
             }));
-            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
             vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
             vi.mocked(invokePlanWorkflow).mockResolvedValue('# Plan');
             vi.mocked(replyToClaude).mockResolvedValue('# Plan');
@@ -247,7 +247,7 @@ describe('WorkflowPlan Command', () => {
                 args: {},
                 flags: { 'force-agent-file-write': false }
             });
-            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
             vi.mocked(input).mockResolvedValue('Test workflow');
             vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
             const timeoutError = new Error('Request timeout');
@@ -261,7 +261,7 @@ describe('WorkflowPlan Command', () => {
                 args: {},
                 flags: { 'force-agent-file-write': false }
             });
-            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
             vi.mocked(input).mockResolvedValue('Test workflow');
             vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
             const rateLimitError = new ClaudeInvocationError('Rate limit exceeded');
@@ -279,7 +279,7 @@ describe('WorkflowPlan Command', () => {
                 state.inputCallCount++;
                 return state.inputCallCount === 1 ? 'Test workflow' : 'ACCEPT';
             }));
-            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
             vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
             vi.mocked(invokePlanWorkflow).mockResolvedValue('# Plan');
             vi.mocked(replyToClaude).mockResolvedValue('# Plan');
@@ -295,7 +295,7 @@ describe('WorkflowPlan Command', () => {
                 flags: { 'force-agent-file-write': false }
             });
             // First call fails with ENOENT, second succeeds
-            vi.mocked(ensureOutputAIStructure).mockRejectedValueOnce(Object.assign(new Error('Directory does not exist'), { code: 'ENOENT' }));
+            vi.mocked(ensureOutputAISystem).mockRejectedValueOnce(Object.assign(new Error('Directory does not exist'), { code: 'ENOENT' }));
             await expect(command.run()).rejects.toThrow();
         });
         it('should handle malformed API responses', async () => {
@@ -304,7 +304,7 @@ describe('WorkflowPlan Command', () => {
                 args: {},
                 flags: { 'force-agent-file-write': false }
             });
-            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
             vi.mocked(input).mockResolvedValue('Test workflow');
             vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
             const malformedError = new ClaudeInvocationError('Invalid JSON response');
@@ -323,7 +323,7 @@ describe('WorkflowPlan Command', () => {
             vi.mocked(updateAgentTemplates).mockResolvedValue();
             await command.run();
             // Verify templates are updated before plan generation
-            const ensureCall = vi.mocked(ensureOutputAIStructure).mock.invocationCallOrder[0];
+            const ensureCall = vi.mocked(ensureOutputAISystem).mock.invocationCallOrder[0];
             const updateCall = vi.mocked(updateAgentTemplates).mock.invocationCallOrder[0];
             expect(updateCall).toBeGreaterThan(ensureCall);
         });

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

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class WorkflowTerminate extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workflowId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        reason: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+}