@output.ai/cli 0.0.1 → 0.0.2

package/README.md

@@ -1,6 +1,6 @@
 # @output.ai/cli
 
-CLI tool for generating Output.ai workflows.
+CLI tool for generating Output workflows.
 
 ## Installation
 
@@ -83,6 +83,38 @@ my-workflow/
 └── README.md         # Workflow documentation
 ```
 
+### Initialize Agent Configuration
+
+```bash
+# Initialize agent configuration for your coding agent
+output-cli agents init
+
+# Specify your agent provider (default: claude-code)
+output-cli agents init --agent-provider claude-code
+
+# Force overwrite existing configuration
+output-cli agents init --force
+```
+
+#### What It Does
+
+Sets up your coding agent of choice with context files, sub-agents, and slash commands for working with the Output SDK effectively. It creates a `.outputai/` directory and wires up your coding agent to the context files.
+
+**Note:** Currently this only works for [Claude Code](https://claude.ai/code), but we plan to add support for other coding agents over time.
+
+#### Command Options
+
+- `--agent-provider` - Specify the coding agent provider (default: `claude-code`)
+- `--force, -f` - Overwrite existing agent configuration files
+
+#### Output Agent Commands
+
+**`/plan_workflow`** - Guides you through structured workflow planning to create comprehensive implementation blueprints before writing code.
+
+#### Output Sub-Agents
+
+**`workflow_planner`** - A specialized AI agent that helps with workflow architecture and planning, including requirements analysis, schema design, and testing strategy definition.
+
 ## About
 
 Built with [OCLIF](https://oclif.io) - see their documentation for advanced CLI features, plugins, and configuration options.

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

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class Init extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {};
+    static flags: {
+        'agent-provider': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private prepareTemplateVariables;
+    private processMappings;
+    private ensureDirectoryExists;
+    private fileExists;
+    private createFromTemplate;
+    private createSymlink;
+    private copyFile;
+}

package/dist/commands/agents/init.js

@@ -0,0 +1,175 @@
+import { Command, Flags } from '@oclif/core';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getTemplateDir } from '../../utils/paths.js';
+import { processTemplate } from '../../utils/template.js';
+const AGENT_CONFIGS = {
+    outputai: {
+        id: 'outputai',
+        name: 'OutputAI Core Files',
+        mappings: [
+            {
+                type: 'template',
+                from: 'AGENTS.md.template',
+                to: '.outputai/AGENTS.md'
+            },
+            {
+                type: 'template',
+                from: 'agents/workflow_planner.md.template',
+                to: '.outputai/agents/workflow_planner.md'
+            },
+            {
+                type: 'template',
+                from: 'commands/plan_workflow.md.template',
+                to: '.outputai/commands/plan_workflow.md'
+            }
+        ]
+    },
+    'claude-code': {
+        id: 'claude-code',
+        name: 'Claude Code',
+        mappings: [
+            {
+                type: 'symlink',
+                from: '.outputai/AGENTS.md',
+                to: 'CLAUDE.md'
+            },
+            {
+                type: 'symlink',
+                from: '.outputai/agents/workflow_planner.md',
+                to: '.claude/agents/workflow_planner.md'
+            },
+            {
+                type: 'symlink',
+                from: '.outputai/commands/plan_workflow.md',
+                to: '.claude/commands/plan_workflow.md'
+            }
+        ]
+    }
+};
+export default class Init extends Command {
+    static description = 'Initialize agent configuration files for AI assistant 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',
+            default: false
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(Init);
+        this.log('Initializing agent configuration for Claude Code...');
+        try {
+            const variables = this.prepareTemplateVariables();
+            await this.processMappings(AGENT_CONFIGS.outputai, variables, flags.force);
+            await this.processMappings(AGENT_CONFIGS[flags['agent-provider']], variables, flags.force);
+            this.log('✅ Agent configuration initialized successfully!');
+            this.log('');
+            this.log('Created:');
+            this.log('  • .outputai/ directory with agent and command configurations');
+            this.log('  • .claude/ directory with symlinks for Claude Code integration');
+            this.log('');
+            this.log('Claude Code will automatically detect and use these configurations.');
+        }
+        catch (error) {
+            if (error.code === 'EACCES') {
+                this.error('Permission denied. Please check file permissions and try again.');
+            }
+            this.error(`Failed to initialize agent configuration: ${error.message}`);
+        }
+    }
+    prepareTemplateVariables() {
+        return {
+            date: new Date().toLocaleDateString('en-US', {
+                year: 'numeric',
+                month: 'long',
+                day: 'numeric'
+            })
+        };
+    }
+    async processMappings(config, variables, force) {
+        for (const mapping of config.mappings) {
+            const dir = path.dirname(mapping.to);
+            await this.ensureDirectoryExists(dir);
+            if (!force && await this.fileExists(mapping.to)) {
+                this.warn(`File already exists: ${mapping.to} (use --force to overwrite)`);
+                continue;
+            }
+            switch (mapping.type) {
+                case 'template':
+                    await this.createFromTemplate(mapping.from, mapping.to, variables);
+                    break;
+                case 'symlink':
+                    await this.createSymlink(mapping.from, mapping.to);
+                    break;
+                case 'copy':
+                    await this.copyFile(mapping.from, mapping.to);
+                    break;
+            }
+        }
+    }
+    async ensureDirectoryExists(dir) {
+        try {
+            await fs.mkdir(dir, { recursive: true });
+            this.debug(`Created directory: ${dir}`);
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST') {
+                throw error;
+            }
+        }
+    }
+    async fileExists(filePath) {
+        try {
+            await fs.stat(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async createFromTemplate(template, output, variables) {
+        const templateDir = getTemplateDir('agent_instructions');
+        const templatePath = path.join(templateDir, template);
+        const content = await fs.readFile(templatePath, 'utf-8');
+        const processed = processTemplate(content, variables);
+        await fs.writeFile(output, processed, 'utf-8');
+        this.debug(`Created from template: ${output}`);
+    }
+    async createSymlink(source, target) {
+        try {
+            if (await this.fileExists(target)) {
+                await fs.unlink(target);
+            }
+            const relativePath = path.relative(path.dirname(target), source);
+            await fs.symlink(relativePath, target);
+            this.debug(`Created symlink: ${target} -> ${source}`);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOTSUP' || code === 'EPERM') {
+                this.debug(`Symlinks not supported, creating copy: ${target}`);
+                const content = await fs.readFile(source, 'utf-8');
+                await fs.writeFile(target, content, 'utf-8');
+                return;
+            }
+            throw error;
+        }
+    }
+    async copyFile(source, target) {
+        const content = await fs.readFile(source, 'utf-8');
+        await fs.writeFile(target, content, 'utf-8');
+        this.debug(`Copied file: ${source} -> ${target}`);
+    }
+}

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

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

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

@@ -0,0 +1,227 @@
+/* eslint-disable no-restricted-syntax, @typescript-eslint/no-explicit-any, init-declarations */
+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');
+describe('agents init', () => {
+    let mockGetTemplateDir;
+    let mockProcessTemplate;
+    const createTestCommand = (args = []) => {
+        const cmd = new Init(args, {});
+        cmd.log = vi.fn();
+        cmd.warn = vi.fn();
+        cmd.error = vi.fn();
+        cmd.debug = vi.fn();
+        cmd.parse = vi.fn();
+        return cmd;
+    };
+    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.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);
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('command structure', () => {
+        it('should have correct description', () => {
+            expect(Init.description).toBeDefined();
+            expect(Init.description).toContain('agent configuration');
+        });
+        it('should have correct examples', () => {
+            expect(Init.examples).toBeDefined();
+            expect(Array.isArray(Init.examples)).toBe(true);
+        });
+        it('should have no required arguments', () => {
+            expect(Init.args).toBeDefined();
+            expect(Object.keys(Init.args)).toHaveLength(0);
+        });
+        it('should have appropriate flags', () => {
+            expect(Init.flags).toBeDefined();
+            expect(Init.flags.force).toBeDefined();
+        });
+    });
+    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 }));
+        });
+        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}}');
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockReadFile).toHaveBeenCalledWith(expect.stringContaining('AGENTS.md.template'), 'utf-8');
+            expect(mockWriteFile).toHaveBeenCalledWith('.outputai/AGENTS.md', expect.stringContaining('Agent instructions'), 'utf-8');
+        });
+        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(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(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 mockStat = vi.mocked(fs.stat);
+            mockStat.mockImplementation(async (path) => {
+                if (typeof path === 'string' && path.startsWith('.outputai')) {
+                    return { isFile: () => true };
+                }
+                throw { code: 'ENOENT' };
+            });
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockSymlink).toHaveBeenCalledWith('.outputai/AGENTS.md', '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: {} });
+            await cmd.run();
+            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/agents/workflow_planner.md'), '.claude/agents/workflow_planner.md');
+        });
+        it('should create symlinks for all command files', async () => {
+            const mockSymlink = vi.mocked(fs.symlink);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/commands/plan_workflow.md'), '.claude/commands/plan_workflow.md');
+        });
+        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' });
+            mockReadFile.mockResolvedValue('File content');
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockReadFile).toHaveBeenCalledWith('.outputai/AGENTS.md', 'utf-8');
+            expect(mockWriteFile).toHaveBeenCalledWith('CLAUDE.md', 'File content', 'utf-8');
+        });
+    });
+    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' });
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', 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);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            await cmd.run();
+            expect(cmd.error).not.toHaveBeenCalled();
+        });
+    });
+    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: {} });
+            await cmd.run();
+            expect(mockWriteFile).toHaveBeenCalled();
+            expect(cmd.warn).not.toHaveBeenCalled();
+        });
+        it('should warn about existing files without force flag', async () => {
+            const mockStat = vi.mocked(fs.stat);
+            mockStat.mockResolvedValue({ isFile: () => true });
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('already exists'));
+        });
+    });
+});

package/dist/commands/workflow/generate.js

@@ -2,7 +2,7 @@ import { Args, Command, Flags } from '@oclif/core';
 import { generateWorkflow } from '../../services/workflow_generator.js';
 import { DEFAULT_OUTPUT_DIRS } from '../../utils/paths.js';
 export default class Generate extends Command {
-    static description = 'Generate a new Flow SDK workflow';
+    static description = 'Generate a new Output SDK workflow';
     static examples = [
         '<%= config.bin %> <%= command.id %> my-workflow',
         '<%= config.bin %> <%= command.id %> my-workflow --skeleton',

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

@@ -0,0 +1,30 @@
+---
+generated_by: "@output.ai/cli"
+version: "{{cliVersion}}"
+generated_on: "{{date}}"
+---
+
+# Output SDK Workflow Planning Agent Configuration
+
+This directory contains AI agent configuration for workflow planning assistance in Output SDK development. Claude Code will automatically detect and use this configuration when planning workflows in your project.
+
+## Available Agent
+
+### 🤖 workflow_planner
+- **Purpose**: Assists with workflow architecture and planning
+- **Capabilities**: System design, workflow structure, step organization, requirements analysis
+- **Usage**: Planning new workflows, architectural decisions, creating implementation blueprints
+
+## Integration
+
+This agent configuration integrates with:
+- **Claude Code**: AI-powered development assistant
+- **Output SDK**: Temporal-based workflow orchestration framework
+- **TypeScript**: Type-safe development patterns
+- **XML Process Flow**: Structured planning with validation checkpoints
+
+## Usage
+
+The workflow planning agent is automatically available when using Claude Code in projects with this configuration. It provides specialized expertise for the planning and architecture phase of Output SDK workflow development.
+
+To regenerate this configuration: `output-cli agents init --force`

package/dist/templates/agent_instructions/agents/workflow_planner.md.template

@@ -0,0 +1,104 @@
+---
+name: workflow-planner
+description: Use this agent when you need to design new workflows for the Output SDK system, plan complex workflow orchestrations, or create comprehensive implementation blueprints before coding. This agent should be invoked at the beginning of workflow development to ensure proper architecture and complete requirements gathering.
+model: opus
+color: blue
+---
+
+# Workflow Planner Agent
+
+## Identity
+You are a Output SDK workflow planning specialist who follows structured XML-based planning processes to create comprehensive workflow implementation blueprints. You operate within a systematic framework defined by pre-flight and post-flight validation checks.
+
+## Core Process
+Your workflow planning follows the structured process defined in `/plan_workflow` command with explicit numbered steps and validation checkpoints. You must adhere to the meta rules defined in:
+- **Pre-Flight**: `@{{projectPath}}/.outputai/instructions/meta/pre_flight.md`
+- **Post-Flight**: `@{{projectPath}}/.outputai/instructions/meta/post_flight.md`
+
+## Expertise
+- **Temporal based Workflow Design**: Orchestrating complex business processes with proper activity boundaries
+- **Output SDK Architecture**: Leveraging Output SDK abstractions and patterns effectively
+- **System Integration**: Designing workflows that integrate with external services and APIs
+- **Scalability Planning**: Architecting workflows for performance and growth
+- **Error Handling Strategy**: Planning comprehensive error handling and retry policies
+- **Smart Defaults**: Applying intelligent defaults to minimize user interaction
+
+## Smart Defaults Strategy
+
+### Automatic Inference
+Apply these defaults unless explicitly overridden:
+- **Retry Policy**: 3 attempts, exponential backoff (1s initial, 10s max)
+- **Timeouts**: 30 seconds for activities, 5 minutes for workflows
+- **OpenAI Model**: gpt-4o for LLM operations
+- **Error Handling**: ApplicationFailure patterns with appropriate types
+- **Performance**: Optimize for clarity and maintainability over speed
+
+### Critical Questions Only
+Only request clarification for:
+- Ambiguous input/output structures that cannot be inferred
+- Non-standard API integrations not in the codebase
+- Complex orchestration patterns requiring specific sequencing
+- Unusual error handling or recovery requirements
+
+## Primary Responsibilities
+
+### 🎯 Step 1-2: Requirements & Pattern Analysis
+- Analyze requirements with smart inference to minimize questions
+- Search for similar workflows and reusable patterns
+- Identify applicable activities and utilities
+- Document requirements in structured format
+
+### 📋 Step 3-4: Schema & Activity Design
+- Define Zod schemas with OpenAI compatibility
+- Design activities with clear boundaries and responsibilities
+- Plan error handling and retry strategies
+- Specify workerModule service usage
+
+### 🏗️ Step 5-6: Prompt & Orchestration Planning
+- Design LLM prompts with template variables (if applicable)
+- Define workflow execution logic step-by-step
+- Plan conditional logic and data flow
+- Generate TypeScript code templates
+
+### ⚖️ Step 7-9: Documentation & Review
+- Create comprehensive plan document
+- Define testing strategy with specific scenarios
+- Prepare implementation checklist
+- Request user review and approval
+
+## Output SDK Conventions
+
+### Mandatory Rules
+- All imports MUST use `.js` extension for ESM modules
+- NEVER use axios directly - always use HttpClient wrapper
+- Export workflow in entrypoint.ts: `export * from './path/to/workflow.js';`
+- Restart worker after creating workflows: `overmind restart worker`
+- All workflows must have test files with validation tests
+- Run `yarn g:workflow-doc` after modifications
+
+### Service Access
+- Use workerModule for all external services
+- Available clients: OpenAI, Anthropic, Perplexity, S3, logger
+- Reference: `@{{projectPath}}/docs/sdk/third-party-clients.md`
+
+## Context Awareness
+- **Output SDK Patterns**: Deep understanding of workflow, step, and LLM abstractions
+- **Temporal Best Practices**: Knowledge of workflow determinism and activity patterns
+- **TypeScript Integration**: Expertise with type-safe workflow development
+- **Testing Strategy**: Planning workflows for comprehensive test coverage
+- **XML Process Flow**: Following structured steps with explicit subagent delegation
+
+## Communication Style
+- **Strategic**: Focus on high-level architecture and long-term maintainability
+- **Analytical**: Break down complex requirements into manageable components
+- **Advisory**: Provide recommendations with clear reasoning and trade-offs
+- **Forward-thinking**: Consider future extensibility and scaling needs
+
+## Example Interactions
+- "How should I structure a workflow that processes customer orders with external payment validation?"
+- "What's the best way to handle retry logic for workflows with multiple API integrations?"
+- "How do I design a workflow that can be easily extended with new processing steps?"
+- "What error handling strategy should I use for a workflow with both synchronous and asynchronous steps?"
+
+---
+*This agent specializes in the planning and architecture phase of Output SDK workflow development.*

package/dist/templates/agent_instructions/commands/plan_workflow.md.template

@@ -0,0 +1,466 @@
+---
+description: Workflow Planning Command for Output SDK
+version: 2.0
+encoding: UTF-8
+---
+
+# Plan Workflow Command
+
+## Overview
+
+Generate comprehensive workflow implementation plans following Output SDK patterns and best practices.
+
+<pre_flight_check>
+  EXECUTE: @{{projectPath}}/.outputai/instructions/meta/pre_flight.md
+</pre_flight_check>
+
+<process_flow>
+
+<step number="1" subagent="workflow_planner" name="requirements_analysis">
+
+### Step 1: Requirements Analysis
+
+Use the workflow_planner subagent to analyze the workflow requirements and infer smart defaults.
+
+<smart_inference>
+  <approach>Infer requirements from description and apply defaults</approach>
+  <defaults>
+    - retry_policy: 3 attempts with exponential backoff
+    - timeout: 30s for activities, 5m for workflows
+    - openai_model: gpt-4o unless specified
+    - error_handling: ApplicationFailure patterns
+    - performance: clarity over speed optimization
+  </defaults>
+</smart_inference>
+
+<critical_questions>
+  ASK ONLY if cannot be inferred:
+  - Ambiguous input/output structures
+  - Non-standard API integrations
+  - Complex orchestration patterns
+  - Unusual error handling requirements
+</critical_questions>
+
+<requirements_template>
+  ## Requirements Analysis
+
+  **Goal**: {{workflowGoal}}
+  **Input**: {{inputDescription}}
+  **Output**: {{outputDescription}}
+  **External Services**: {{servicesList}}
+  **Constraints**: {{constraintsList}}
+</requirements_template>
+
+</step>
+
+<step number="2" name="pattern_analysis">
+
+### Step 2: Pattern Analysis
+
+<analysis_targets>
+  - Check the repository for similar implementations
+  - Identify reusable activities
+  - Find applicable prompt templates in workflow directories
+  - Locate relevant schemas and types
+</analysis_targets>
+
+<pattern_collection>
+  <existing_workflows>workflows with similar purpose or structure</existing_workflows>
+  <reusable_activities>activities that can be leveraged</reusable_activities>
+  <error_patterns>established error handling patterns</error_patterns>
+  <retry_policies>common retry configurations</retry_policies>
+</pattern_collection>
+
+</step>
+
+<step number="3" subagent="workflow_planner" name="schema_definition">
+
+### Step 3: Schema Definition
+
+Use the workflow_planner subagent to define input/output schemas with Zod validation.
+
+<schema_requirements>
+  - Use simple TypeScript interfaces for basic types
+  - Use Zod schemas when validation is needed
+  - Keep field types simple: string, number, boolean, object
+  - Mark optional fields with ? in interfaces or .optional() in Zod
+  - Export types for reuse across workflow files
+</schema_requirements>
+
+<input_schema_template>
+  ```typescript
+  // For simple types (types.ts)
+  export interface {{WorkflowName}}Input {
+    {{requiredField}}: string;
+    {{optionalField}}?: string;
+  }
+
+  // Or for validation with Zod
+  import { z } from 'zod';
+
+  export const {{WorkflowName}}InputSchema = z.object({
+    {{requiredField}}: z.string(),
+    {{optionalField}}: z.string().optional()
+  });
+
+  export type {{WorkflowName}}Input = z.infer<typeof {{WorkflowName}}InputSchema>;
+  ```
+</input_schema_template>
+
+<output_schema_template>
+  ```typescript
+  export interface {{WorkflowName}}Output {
+    result: string;
+    // Additional fields as needed
+    {{additionalFields}}
+  }
+  ```
+</output_schema_template>
+
+</step>
+
+<step number="4" subagent="workflow_planner" name="activity_design">
+
+### Step 4: Activity Design
+
+Use the workflow_planner subagent to design workflow activities with clear boundaries.
+
+<activity_template>
+  ### Step: `{{stepName}}`
+
+  **Purpose**: {{stepPurpose}}
+
+  **Implementation (steps.ts)**:
+  ```typescript
+  import { step } from '@output.ai/core';
+  import { generateText, generateObject } from '@output.ai/llm';
+  import { loadPrompt } from '@output.ai/prompt';
+  import type { Prompt } from '@output.ai/llm';
+
+  export const {{stepName}} = step({
+    name: '{{stepName}}',
+    description: '{{stepDescription}}',
+    inputSchema: {
+      type: 'object',
+      required: [{{requiredFields}}],
+      properties: {
+        {{fieldName}}: { type: '{{fieldType}}' }
+        // Add more fields as needed
+      }
+    },
+    outputSchema: {
+      type: '{{outputType}}'
+    },
+    fn: async (input) => {
+      // Implementation logic
+      {{implementationLogic}}
+
+      // For LLM operations:
+      // const prompt = loadPrompt('{{promptName}}', input);
+      // const response = await generateText(prompt as Prompt);
+
+      return {{returnValue}};
+    }
+  });
+  ```
+
+  **Error Handling**:
+  - Use `FatalError` from '@output.ai/core' for non-retryable errors
+  - Standard errors will be retried based on workflow configuration
+</activity_template>
+
+<decision_tree>
+  IF step_uses_llm:
+    USE generateText or generateObject from @output.ai/llm
+    LOAD prompts with loadPrompt from @output.ai/prompt
+    DEFINE error handling with FatalError
+  ELSE IF step_uses_external_service:
+    IMPORT required service libraries
+    HANDLE errors appropriately
+  ELSE:
+    IMPLEMENT pure logic
+    VALIDATE inputs/outputs
+</decision_tree>
+
+</step>
+
+<step number="5" subagent="workflow_planner" name="prompt_engineering">
+
+### Step 5: Prompt Engineering (Conditional)
+
+Use the workflow_planner subagent to design LLM prompts if the workflow uses AI services.
+
+<decision_tree>
+  IF workflow_uses_llm:
+    EXECUTE prompt_design
+  ELSE:
+    SKIP to step 6
+</decision_tree>
+
+<prompt_template>
+  **Prompt File ({{promptName}}@v1.prompt)**:
+  ```yaml
+  ---
+  provider: {{provider}}  # anthropic, openai, etc.
+  model: {{model}}  # e.g., claude-sonnet-4-20250514, gpt-4o
+  temperature: {{temperature}}  # e.g., 0.7
+  ---
+
+  <assistant>
+  {{systemPrompt}}
+  </assistant>
+
+  <user>
+  {{userPrompt}}
+
+  Variables to include:
+  {{ "{{ " }}{{variableName}}{{ " }}" }}
+  </user>
+  ```
+</prompt_template>
+
+<template_variables>
+  **Template Variables**:
+  - `{{ "{{ " }}{{variableName1}}{{ " }}" }}` - {{description1}}
+  - `{{ "{{ " }}{{variableName2}}{{ " }}" }}` - {{description2}}
+
+  **Loading in Step**:
+  ```typescript
+  const prompt = loadPrompt('{{promptName}}@v1', {
+    {{variableName1}}: input.{{field1}},
+    {{variableName2}}: input.{{field2}}
+  });
+  ```
+</template_variables>
+
+</step>
+
+<step number="6" subagent="workflow_planner" name="orchestration_planning">
+
+### Step 6: Workflow Orchestration
+
+Use the workflow_planner subagent to define the workflow execution logic.
+
+<orchestration_template>
+  ## Workflow Logic
+
+  1. **Input Validation**: `validateWorkflowInput(rawInput, {{WorkflowName}}InputSchema)`
+  2. **{{Step2Name}}**: {{step2Description}}
+  3. **{{Step3Name}}**: Call `{{activityName}}({{parameters}})`
+  4. **{{Step4Name}}**: {{step4Description}}
+  5. **Result Assembly**: Structure final output with metadata
+  6. **Return**: Complete {{WorkflowName}}Output object
+
+  **Conditional Logic**:
+  {{conditionalRules}}
+</orchestration_template>
+
+<workflow_code_template>
+  **Workflow File (workflow.ts)**:
+  ```typescript
+  import { workflow } from '@output.ai/core';
+  import { {{stepImports}} } from './steps.js';
+  import type { {{WorkflowName}}Input, {{WorkflowName}}Output } from './types.js';
+
+  export default workflow({
+    name: '{{workflowName}}',
+    description: '{{workflowDescription}}',
+    inputSchema: {
+      type: 'object',
+      required: [{{requiredFields}}],
+      properties: {
+        {{fieldName}}: { type: '{{fieldType}}' }
+        // Define all input fields
+      }
+    },
+    outputSchema: {
+      type: 'object',
+      required: [{{outputRequiredFields}}],
+      properties: {
+        result: { type: 'string' }
+        // Define output structure
+      }
+    },
+    fn: async (input: {{WorkflowName}}Input): Promise<{{WorkflowName}}Output> => {
+      // Workflow orchestration logic
+      {{orchestrationSteps}}
+
+      // Example step invocation:
+      // const result = await {{stepName}}({ {{stepParams}} });
+
+      return {
+        result: {{resultValue}}
+      };
+    }
+  });
+  ```
+</workflow_code_template>
+
+</step>
+
+<step number="7" name="plan_document_creation">
+
+### Step 7: Create Plan Document
+
+<plan_structure>
+  # Workflow Plan: {{WorkflowName}}
+
+  ## Overview
+  - **Purpose**: {{purpose}}
+  - **Use Case**: {{useCase}}
+  - **Key Features**: {{features}}
+
+  ## Technical Specifications
+  {{schemaDefinitions}}
+
+  ## Activity Specifications
+  {{activityDefinitions}}
+
+  ## Prompt Specifications (if applicable)
+  {{promptDefinitions}}
+
+  ## Workflow Orchestration
+  {{orchestrationLogic}}
+
+  ## Implementation Checklist
+  - [ ] Create workflow directory structure
+  - [ ] Implement input/output schemas
+  - [ ] Create activity functions
+  - [ ] Design prompt templates (if needed)
+  - [ ] Implement workflow logic
+  - [ ] Add to entrypoint.ts
+  - [ ] Write unit tests
+  - [ ] Test with flow-cli
+  - [ ] Run integration tests
+  - [ ] Update documentation
+</plan_structure>
+
+<file_location>
+  workflow_plans/{{workflowName}}-plan.md
+</file_location>
+
+</step>
+
+<step number="8" subagent="workflow_planner" name="testing_strategy">
+
+### Step 8: Define Testing Strategy
+
+Use the workflow_planner subagent to create comprehensive testing requirements.
+
+<test_scenarios>
+  ## Testing Plan
+
+  ### Happy Path Tests
+  1. **Complete Input**: All fields provided, successful execution
+  2. **Minimal Input**: Required fields only
+  3. **Variations**: Different input combinations
+
+  ### Edge Cases
+  1. **Boundary Values**: Min/max values, empty strings
+  2. **Special Characters**: Unicode, punctuation
+  3. **Optional Fields**: With/without optional data
+
+  ### Error Scenarios
+  1. **Invalid Input**: Malformed data, wrong types
+  2. **Service Failures**: API errors, timeouts
+  3. **Schema Violations**: Invalid responses
+
+  ### Performance Tests
+  1. **Response Time**: Must complete within {{timeout}}
+  2. **Concurrent Execution**: Multiple workflow instances
+  3. **Resource Usage**: Monitor memory and CPU
+</test_scenarios>
+
+<test_commands>
+  ```bash
+  # Build the workflow
+  npm run build
+
+  # Start the worker (in one terminal)
+  npm run start  # or flow-worker
+
+  # Execute workflow (in another terminal or via API)
+  # Via API endpoint if configured
+  curl -X POST http://localhost:3000/workflows/{{workflowName}} \
+    -H "Content-Type: application/json" \
+    -d '{{testPayload}}'
+
+  # Run validation
+  ./run.sh validate
+
+  # Development mode with Docker
+  ./run.sh dev
+  ```
+</test_commands>
+
+</step>
+
+<step number="9" name="review_checkpoint">
+
+### Step 9: Review and Approval
+
+Request user review of the workflow plan before proceeding to implementation.
+
+<review_template>
+  I've completed the workflow plan for {{workflowName}}:
+
+  📋 **Plan Document**: `workflow_plans/{{workflowName}}-plan.md`
+
+  The plan includes:
+  - Complete input/output schemas with Zod validation
+  - {{activityCount}} activity specifications with error handling
+  - Workflow orchestration logic
+  - Comprehensive testing strategy
+  - Implementation checklist
+
+  Please review the plan and let me know if any modifications are needed.
+</review_template>
+
+</step>
+
+</process_flow>
+
+<post_flight_check>
+  EXECUTE: @{{projectPath}}/.outputai/instructions/meta/post_flight.md
+</post_flight_check>
+
+## Command Usage
+
+### Basic Planning
+```
+/plan-workflow "Process customer support tickets using AI categorization"
+```
+
+### With Complexity Hints
+```
+/plan-workflow "Multi-step data pipeline with validation" --complexity=complex --integrations=apis,llm
+```
+
+### Integration-Heavy Workflow
+```
+/plan-workflow "E-commerce order fulfillment" --integrations=payment,inventory,shipping
+```
+
+## Quality Standards
+
+### Plan Completeness
+- All schemas defined with exact types
+- Every activity specified with I/O and processing logic
+- External services identified with SDK references
+- Error handling complete for all scenarios
+- Testing scenarios documented with commands
+
+### Output SDK Compliance
+- ES module imports with .js extensions
+- Use @output.ai/core for workflow and step functions
+- Use @output.ai/llm for AI operations
+- Use @output.ai/prompt for prompt loading
+- Use FatalError from @output.ai/core for non-retryable errors
+- Follow established workflow file structure (workflow.ts, steps.ts, types.ts, *.prompt)
+
+### Implementation Readiness
+- Developer can implement without clarification
+- All code examples compile without modification
+- Testing approach is comprehensive
+- Performance requirements are measurable
+- Documentation is clear and actionable

package/dist/templates/agent_instructions/meta/post_flight.md.template

@@ -0,0 +1,94 @@
+---
+description: Post-Flight Validation for Output SDK Workflow Operations
+version: 1.0
+encoding: UTF-8
+---
+
+# Post-Flight Rules for Output SDK Workflows
+
+## Execution Verification
+
+After completing all steps in the process_flow, systematically verify:
+
+### Step Completion Audit
+- [ ] Every numbered step has been read, executed, and delivered according to its instructions
+- [ ] All steps that specified a subagent were delegated to the correct subagent
+- [ ] If any subagent was not used as specified, document why and report to the user
+- [ ] If any step was not executed according to instructions, explain which part was misread or skipped
+
+### Output SDK Convention Compliance
+
+Verify the following conventions were followed:
+
+#### Import Conventions
+- [ ] All TypeScript/JavaScript imports use `.js` extension for ES modules
+- [ ] No direct axios usage - HttpClient wrapper used throughout
+- [ ] Proper import paths for Output SDK packages (@flowsdk/core, @flowsdk/llm, etc.)
+
+#### Workflow Structure
+- [ ] Workflow exported in entrypoint.ts: `export * from './path/to/workflow.js';`
+- [ ] All external operations wrapped in Temporal activities (steps)
+- [ ] Proper error handling with ApplicationFailure patterns
+- [ ] Retry policies configured appropriately
+
+#### Documentation & Testing
+- [ ] Comprehensive plan document created with all required sections
+- [ ] Testing strategy defined with specific test scenarios
+- [ ] Implementation checklist provided for developers
+- [ ] All code examples are complete and would compile
+
+## Quality Validation
+
+### Plan Completeness Check
+Ensure the workflow plan includes:
+- [ ] **Overview**: Clear purpose and use case definition
+- [ ] **Technical Specifications**: Complete input/output schemas with Zod validation
+- [ ] **Activity Definitions**: Each activity fully specified with purpose, I/O, and error handling
+- [ ] **Prompt Engineering**: LLM prompts designed (if applicable) with template variables
+- [ ] **Orchestration Logic**: Step-by-step workflow execution flow
+- [ ] **Retry Policies**: Configured for each activity with appropriate timeouts
+- [ ] **Testing Requirements**: Comprehensive test scenarios and commands
+
+### Implementation Readiness
+Confirm the plan is ready for implementation:
+- [ ] All schemas defined with exact field types and descriptions
+- [ ] Every activity specified with input/output/processing logic
+- [ ] External services identified with specific SDK client references
+- [ ] Error handling complete for all failure scenarios
+- [ ] Testing scenarios documented with expected outcomes
+- [ ] Performance requirements clear with measurable criteria
+
+## Deliverable Verification
+
+### Required Outputs
+Verify these deliverables were created or updated:
+- [ ] Workflow plan document with full specifications
+- [ ] Activity schemas with Zod validation
+- [ ] Prompt templates (if LLM integration required)
+- [ ] Testing strategy with specific commands
+- [ ] Implementation checklist for developers
+
+### Next Steps Documentation
+Ensure the following guidance is provided:
+- [ ] Clear handoff to implementation phase
+- [ ] Specific Output SDK CLI commands to execute
+- [ ] Dependencies to install (if any)
+- [ ] Configuration requirements documented
+- [ ] Success criteria clearly defined
+
+## Error Reporting
+
+If any issues were encountered:
+1. Document the specific issue and step where it occurred
+2. Explain any deviations from the planned process
+3. Provide recommendations for resolution
+4. Note any missing information that prevented completion
+
+## Final Validation
+
+Before marking the workflow planning complete:
+- [ ] Developer can implement without additional clarification
+- [ ] All Output SDK patterns and conventions are followed
+- [ ] Testing approach is comprehensive and executable
+- [ ] Documentation is clear and complete
+- [ ] Plan aligns with project's existing workflow patterns

package/dist/templates/agent_instructions/meta/pre_flight.md.template

@@ -0,0 +1,60 @@
+---
+description: Pre-Flight Checks for Output SDK Workflow Operations
+version: 1.0
+encoding: UTF-8
+---
+
+# Pre-Flight Rules for Output SDK Workflows
+
+## Execution Requirements
+
+- **CRITICAL**: For any step that specifies a subagent in the `subagent=""` XML attribute, you MUST use the specified subagent to perform the instructions for that step
+- Process all XML blocks sequentially and completely
+- Execute every numbered step in the process_flow EXACTLY as specified
+
+## Output SDK Conventions Check
+
+Before proceeding with any workflow operation, verify:
+
+- **ES Modules**: All imports MUST use `.js` extension for ESM modules
+- **HTTP Client**: NEVER use axios directly - always use @output.ai/http wrapper
+- **LLM Client**: NEVER use a direct llm call - always use @output.ai/llm wrapper
+- **Worker Restarts**: Remember to restart worker after creating workflows: `overmind restart worker`
+- **Documentation**: Run `yarn g:workflow-doc` after modifications
+
+## Requirements Gathering Strategy
+
+### Smart Defaults Application
+When information is not explicitly provided, apply these defaults:
+- **Retry Policies**: 3 attempts with exponential backoff (1s initial, 10s max)
+- **OpenAI Models**: Use `gpt-4o` unless specified otherwise
+- **Error Handling**: ApplicationFailure patterns with appropriate error types
+- **Performance**: Optimize for clarity and maintainability over raw speed
+- **Timeouts**: 30 seconds for activities, 5 minutes for workflows
+
+### Critical Information Requirements
+Only stop to ask for clarification on:
+- Ambiguous input/output structures that cannot be inferred from context
+- Specific API keys or services not commonly used in the project
+- Non-standard error handling or recovery requirements
+- Complex orchestration patterns requiring specific sequencing
+- External dependencies not already in the project
+
+## Template Processing Rules
+
+- Use exact templates as provided in each step
+- Replace all template variables with actual values:
+  - `{{workflowName}}` - The workflow being planned
+  - `{{projectPath}}` - Root project directory path
+  - `{{requirements}}` - User-provided requirements
+  - `{{currentDate}}` - Current date in YYYY-MM-DD format
+  - `{{sdkVersion}}` - Current Output SDK version
+
+## Quality Gates
+
+Before proceeding past pre-flight:
+1. Confirm all required context is available
+2. Verify understanding of the workflow's purpose
+3. Check for existing similar workflows to use as patterns
+4. Ensure Output SDK conventions are understood
+5. Validate that necessary subagents are available

package/dist/templates/workflow/README.md.template

@@ -4,7 +4,7 @@
 
 ## Overview
 
-This workflow was generated using the Flow SDK CLI. It provides a starting point for building Temporal-based workflows with LLM integration.
+This workflow was generated using the Output SDK CLI. It provides a starting point for building Temporal-based workflows with LLM integration.
 
 ## Files
 
@@ -63,7 +63,7 @@ Example:
 
 ### Workflow Structure
 
-The workflow follows the new Flow SDK conventions:
+The workflow follows the new Output SDK conventions:
 
 ```typescript
 import { workflow } from '@output.ai/core';
@@ -193,7 +193,7 @@ To test your workflow:
 
 1. Build the parent project containing this workflow
 2. Start the Flow worker
-3. Execute the workflow using the Flow SDK API
+3. Execute the workflow using the Output SDK API
 
 Example execution:
 ```bash
@@ -210,6 +210,6 @@ curl -X POST http://localhost:3001/workflow \
 
 ## Resources
 
-- [Flow SDK Documentation](https://github.com/growthxai/flow-sdk)
+- [Output SDK Documentation](https://github.com/growthxai/flow-sdk)
 - [Temporal Documentation](https://docs.temporal.io)
 - [AI SDK Documentation](https://sdk.vercel.ai/docs)

package/dist/utils/paths.d.ts

@@ -3,6 +3,7 @@
  */
 export declare const TEMPLATE_DIRS: {
     readonly workflow: string;
+    readonly agent_instructions: string;
 };
 /**
  * Default output directories
@@ -22,3 +23,7 @@ export declare function createTargetDir(outputDir: string, workflowName: string)
  * Get the template directory for a specific template type
  */
 export declare function getTemplateDir(templateType: keyof typeof TEMPLATE_DIRS): string;
+/**
+ * Get the agent instruction directory for a specific category
+ */
+export declare function getAgentInstructionDir(category: 'agents' | 'commands'): string;

package/dist/utils/paths.js

@@ -6,7 +6,8 @@ const __dirname = path.dirname(__filename);
  * Template directory paths
  */
 export const TEMPLATE_DIRS = {
-    workflow: path.join(__dirname, '..', 'templates', 'workflow')
+    workflow: path.join(__dirname, '..', 'templates', 'workflow'),
+    agent_instructions: path.join(__dirname, '..', 'templates', 'agent_instructions')
 };
 /**
  * Default output directories
@@ -33,3 +34,9 @@ export function createTargetDir(outputDir, workflowName) {
 export function getTemplateDir(templateType) {
     return TEMPLATE_DIRS[templateType];
 }
+/**
+ * Get the agent instruction directory for a specific category
+ */
+export function getAgentInstructionDir(category) {
+    return path.join(TEMPLATE_DIRS.agent_instructions, category);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@output.ai/cli",
   "description": "CLI for Output.ai workflow generation",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "author": "Ben Church",
   "bin": {
     "output-cli": "./bin/run.js"
@@ -53,6 +53,14 @@
     "topics": {
       "workflow": {
         "description": "Manage Output.ai workflows"
+      },
+      "config": {
+        "description": "Configure Output.ai CLI",
+        "subtopics": {
+          "agents": {
+            "description": "Manage AI agent configurations"
+          }
+        }
       }
     }
   },