@output.ai/cli 0.5.6 → 0.6.0

package/dist/services/claude_client.spec.js

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

package/dist/services/coding_agents.d.ts

@@ -1,28 +1,11 @@
-export interface FileMapping {
-    from: string;
-    to: string;
-    type: 'template' | 'symlink' | 'copy';
-}
-export interface AgentSystemConfig {
-    id: string;
-    name: string;
-    mappings: FileMapping[];
-}
 export interface StructureCheckResult {
-    dirExists: boolean;
-    missingFiles: string[];
     isComplete: boolean;
+    needsInit: boolean;
 }
 export interface InitOptions {
     projectRoot: string;
     force: boolean;
-    agentProvider: string;
 }
-/**
- * Agent configuration mappings for different providers
- */
-export declare const AGENT_CONFIGS: Record<string, AgentSystemConfig>;
-export declare function getRequiredFiles(): string[];
 /**
  * Get the full path to the agent configuration directory
  */
@@ -37,14 +20,17 @@ export declare function checkAgentStructure(projectRoot: string): Promise<Struct
  */
 export declare function prepareTemplateVariables(): Record<string, string>;
 /**
- * Initialize agent configuration files
- * Main entry point for agent initialization logic
+ * Initialize agent configuration files and register Claude Code plugin
+ * Creates 3 files:
+ * - .outputai/AGENTS.md (from template with Handlebars processing)
+ * - .claude/settings.json (static JSON)
+ * - CLAUDE.md symlink to .outputai/AGENTS.md
+ * Then runs Claude CLI commands to register the plugin marketplace and install the plugin
  */
 export declare function initializeAgentConfig(options: InitOptions): Promise<void>;
 /**
- * Ensure .outputai directory structure exists by invoking agents init if needed
- * Displays warnings for missing files and prompts for reinitialization
+ * Ensure OutputAI system is initialized by invoking agents init if needed
+ * Creates configuration files and registers Claude Code plugin
  * @param projectRoot - Root directory of the project
- * @throws Error if user declines to initialize or if initialization fails
  */
-export declare function ensureOutputAIStructure(projectRoot: string): Promise<void>;
+export declare function ensureOutputAISystem(projectRoot: string): Promise<void>;

package/dist/services/coding_agents.js

@@ -7,284 +7,11 @@ import { access } from 'node:fs/promises';
 import path from 'node:path';
 import { join } from 'node:path';
 import { ux } from '@oclif/core';
-import { confirm } from '@inquirer/prompts';
 import { AGENT_CONFIG_DIR } from '#config.js';
 import { getTemplateDir } from '#utils/paths.js';
+import { executeClaudeCommand } from '#utils/claude.js';
 import { processTemplate } from '#utils/template.js';
-/**
- * Agent configuration mappings for different providers
- */
-export const AGENT_CONFIGS = {
-    outputai: {
-        id: 'outputai',
-        name: 'OutputAI Core Files',
-        mappings: [
-            {
-                type: 'template',
-                from: 'AGENTS.md.template',
-                to: `${AGENT_CONFIG_DIR}/AGENTS.md`
-            },
-            {
-                type: 'template',
-                from: 'agents/workflow_planner.md.template',
-                to: `${AGENT_CONFIG_DIR}/agents/workflow_planner.md`
-            },
-            {
-                type: 'template',
-                from: 'agents/workflow_quality.md.template',
-                to: `${AGENT_CONFIG_DIR}/agents/workflow_quality.md`
-            },
-            {
-                type: 'template',
-                from: 'agents/workflow_context_fetcher.md.template',
-                to: `${AGENT_CONFIG_DIR}/agents/workflow_context_fetcher.md`
-            },
-            {
-                type: 'template',
-                from: 'agents/workflow_prompt_writer.md.template',
-                to: `${AGENT_CONFIG_DIR}/agents/workflow_prompt_writer.md`
-            },
-            {
-                type: 'template',
-                from: 'agents/workflow_debugger.md.template',
-                to: `${AGENT_CONFIG_DIR}/agents/workflow_debugger.md`
-            },
-            {
-                type: 'template',
-                from: 'commands/plan_workflow.md.template',
-                to: `${AGENT_CONFIG_DIR}/commands/plan_workflow.md`
-            },
-            {
-                type: 'template',
-                from: 'commands/debug_workflow.md.template',
-                to: `${AGENT_CONFIG_DIR}/commands/debug_workflow.md`
-            },
-            {
-                type: 'template',
-                from: 'commands/build_workflow.md.template',
-                to: `${AGENT_CONFIG_DIR}/commands/build_workflow.md`
-            },
-            {
-                type: 'template',
-                from: 'meta/pre_flight.md.template',
-                to: '.outputai/meta/pre_flight.md'
-            },
-            {
-                type: 'template',
-                from: 'meta/post_flight.md.template',
-                to: '.outputai/meta/post_flight.md'
-            },
-            // Skills (all at top level - no nesting allowed)
-            {
-                type: 'template',
-                from: 'skills/output-services-check/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-services-check/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-workflow-trace/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-workflow-trace/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-workflow-list/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-workflow-list/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-workflow-runs-list/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-workflow-runs-list/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-workflow-run/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-workflow-run/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-workflow-start/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-workflow-start/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-workflow-status/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-workflow-status/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-workflow-result/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-workflow-result/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-workflow-stop/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-workflow-stop/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-error-zod-import/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-error-zod-import/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-error-nondeterminism/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-error-nondeterminism/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-error-try-catch/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-error-try-catch/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-error-missing-schemas/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-error-missing-schemas/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-error-direct-io/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-error-direct-io/SKILL.md`
-            },
-            {
-                type: 'template',
-                from: 'skills/output-error-http-client/SKILL.md.template',
-                to: `${AGENT_CONFIG_DIR}/skills/output-error-http-client/SKILL.md`
-            }
-        ]
-    },
-    'claude-code': {
-        id: 'claude-code',
-        name: 'Claude Code',
-        mappings: [
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/AGENTS.md`,
-                to: 'CLAUDE.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/agents/workflow_planner.md`,
-                to: '.claude/agents/workflow_planner.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/agents/workflow_quality.md`,
-                to: '.claude/agents/workflow_quality.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/agents/workflow_context_fetcher.md`,
-                to: '.claude/agents/workflow_context_fetcher.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/agents/workflow_prompt_writer.md`,
-                to: '.claude/agents/workflow_prompt_writer.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/agents/workflow_debugger.md`,
-                to: '.claude/agents/workflow_debugger.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/commands/plan_workflow.md`,
-                to: '.claude/commands/plan_workflow.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/commands/debug_workflow.md`,
-                to: '.claude/commands/debug_workflow.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/commands/build_workflow.md`,
-                to: '.claude/commands/build_workflow.md'
-            },
-            // Skills Symlinks (all at top level - no nesting allowed)
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-services-check/SKILL.md`,
-                to: '.claude/skills/output-services-check/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-workflow-trace/SKILL.md`,
-                to: '.claude/skills/output-workflow-trace/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-workflow-list/SKILL.md`,
-                to: '.claude/skills/output-workflow-list/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-workflow-runs-list/SKILL.md`,
-                to: '.claude/skills/output-workflow-runs-list/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-workflow-run/SKILL.md`,
-                to: '.claude/skills/output-workflow-run/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-workflow-start/SKILL.md`,
-                to: '.claude/skills/output-workflow-start/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-workflow-status/SKILL.md`,
-                to: '.claude/skills/output-workflow-status/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-workflow-result/SKILL.md`,
-                to: '.claude/skills/output-workflow-result/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-workflow-stop/SKILL.md`,
-                to: '.claude/skills/output-workflow-stop/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-error-zod-import/SKILL.md`,
-                to: '.claude/skills/output-error-zod-import/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-error-nondeterminism/SKILL.md`,
-                to: '.claude/skills/output-error-nondeterminism/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-error-try-catch/SKILL.md`,
-                to: '.claude/skills/output-error-try-catch/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-error-missing-schemas/SKILL.md`,
-                to: '.claude/skills/output-error-missing-schemas/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-error-direct-io/SKILL.md`,
-                to: '.claude/skills/output-error-direct-io/SKILL.md'
-            },
-            {
-                type: 'symlink',
-                from: `${AGENT_CONFIG_DIR}/skills/output-error-http-client/SKILL.md`,
-                to: '.claude/skills/output-error-http-client/SKILL.md'
-            }
-        ]
-    }
-};
-export function getRequiredFiles() {
-    const outputaiFiles = AGENT_CONFIGS.outputai.mappings.map(m => m.to);
-    const claudeCodeFiles = AGENT_CONFIGS['claude-code'].mappings.map(m => m.to);
-    return [...outputaiFiles, ...claudeCodeFiles];
-}
+const EXPECTED_MARKETPLACE_REPO = 'growthxai/output-claude-plugins';
 /**
  * Get the full path to the agent configuration directory
  */
@@ -313,31 +40,38 @@ async function fileExists(filePath) {
         return false;
     }
 }
-async function findMissingFiles(files, projectRoot) {
-    const checks = await Promise.all(files.map(async (file) => ({
-        file,
-        missing: !await fileExists(join(projectRoot, file))
-    })));
-    return checks
-        .filter(check => check.missing)
-        .map(check => check.file);
+/**
+ * Validate settings.json content has correct marketplace and plugin configuration
+ */
+async function validateSettingsJson(projectRoot) {
+    const settingsPath = join(projectRoot, '.claude/settings.json');
+    try {
+        const content = await fs.readFile(settingsPath, 'utf-8');
+        const settings = JSON.parse(content);
+        const marketplaceRepo = settings.extraKnownMarketplaces?.['team-tools']?.source?.repo;
+        const pluginEnabled = settings.enabledPlugins?.['outputai@outputai'];
+        return marketplaceRepo === EXPECTED_MARKETPLACE_REPO && pluginEnabled === true;
+    }
+    catch {
+        return false;
+    }
 }
 export async function checkAgentStructure(projectRoot) {
-    const requiredFiles = getRequiredFiles();
-    const dirExists = await checkAgentConfigDirExists(projectRoot);
-    if (!dirExists) {
-        return {
-            dirExists: false,
-            missingFiles: requiredFiles,
-            isComplete: false
-        };
+    const outputaiDirExists = await checkAgentConfigDirExists(projectRoot);
+    const settingsValid = await validateSettingsJson(projectRoot);
+    const claudeMdExists = await fileExists(join(projectRoot, 'CLAUDE.md'));
+    if (!settingsValid) {
+        ux.warn('.claude/settings.json missing critical configuration.');
     }
-    const missingFiles = await findMissingFiles(requiredFiles, projectRoot);
-    return {
-        dirExists: true,
-        missingFiles,
-        isComplete: missingFiles.length === 0
-    };
+    if (!claudeMdExists) {
+        ux.warn('CLAUDE.md missing.');
+    }
+    if (!outputaiDirExists) {
+        ux.warn('.outputai/ directory missing.');
+    }
+    const isComplete = outputaiDirExists && settingsValid && claudeMdExists;
+    const needsInit = !outputaiDirExists || !settingsValid;
+    return { isComplete, needsInit };
 }
 /**
  * Prepare template variables for file generation
@@ -368,14 +102,24 @@ async function ensureDirectoryExists(dir) {
 /**
  * Create a file from a template
  */
-async function createFromTemplate(template, output, variables) {
+async function createFromTemplate(templateSubpath, output, variables) {
     const templateDir = getTemplateDir('agent_instructions');
-    const templatePath = path.join(templateDir, template);
+    const templatePath = path.join(templateDir, templateSubpath);
     const content = await fs.readFile(templatePath, 'utf-8');
     const processed = processTemplate(content, variables);
     await fs.writeFile(output, processed, 'utf-8');
     ux.stdout(ux.colorize('gray', `Created from template: ${output}`));
 }
+/**
+ * Create a static file (no template processing)
+ */
+async function createStaticFile(templateSubpath, output) {
+    const templateDir = getTemplateDir('agent_instructions');
+    const templatePath = path.join(templateDir, templateSubpath);
+    const content = await fs.readFile(templatePath, 'utf-8');
+    await fs.writeFile(output, content, 'utf-8');
+    ux.stdout(ux.colorize('gray', `Created file: ${output}`));
+}
 /**
  * Create a symlink, falling back to copying if symlinks are not supported
  */
@@ -397,7 +141,6 @@ async function createSymlink(source, target, projectRoot) {
         const code = error.code;
         if (code === 'ENOTSUP' || code === 'EPERM') {
             ux.stdout(ux.colorize('gray', `Symlinks not supported, creating copy: ${target}`));
-            // Use resolved source path for copying
             const resolvedSource = path.isAbsolute(source) ?
                 source :
                 path.join(projectRoot, source);
@@ -409,90 +152,91 @@ async function createSymlink(source, target, projectRoot) {
     }
 }
 /**
- * Copy a file from source to target
+ * Create .outputai/AGENTS.md file from template
  */
-async function copyFile(source, target) {
-    const content = await fs.readFile(source, 'utf-8');
-    await fs.writeFile(target, content, 'utf-8');
-    ux.stdout(ux.colorize('gray', `Copied file: ${source} -> ${target}`));
+async function createAgentsMdFile(projectRoot, force, variables) {
+    const outputaiDir = join(projectRoot, AGENT_CONFIG_DIR);
+    await ensureDirectoryExists(outputaiDir);
+    const agentsMdPath = join(outputaiDir, 'AGENTS.md');
+    if (force || !await fileExists(agentsMdPath)) {
+        await createFromTemplate('dotoutputai/AGENTS.md.template', agentsMdPath, variables);
+    }
+    else {
+        ux.warn(`File already exists: ${AGENT_CONFIG_DIR}/AGENTS.md (use --force to overwrite)`);
+    }
 }
 /**
- * Process file mappings for a specific agent configuration
+ * Create .claude/settings.json file from template
  */
-async function processMappings(config, variables, force, projectRoot) {
-    for (const mapping of config.mappings) {
-        const fullPath = path.isAbsolute(mapping.to) ?
-            mapping.to :
-            path.join(projectRoot, mapping.to);
-        const dir = path.dirname(fullPath);
-        await ensureDirectoryExists(dir);
-        if (!force && await fileExists(fullPath)) {
-            ux.warn(`File already exists: ${mapping.to} (use --force to overwrite)`);
-            continue;
-        }
-        switch (mapping.type) {
-            case 'template':
-                await createFromTemplate(mapping.from, fullPath, variables);
-                break;
-            case 'symlink':
-                await createSymlink(mapping.from, fullPath, projectRoot);
-                break;
-            case 'copy':
-                await copyFile(mapping.from, fullPath);
-                break;
-        }
+async function createSettingsFile(projectRoot, force) {
+    const claudeDir = join(projectRoot, '.claude');
+    await ensureDirectoryExists(claudeDir);
+    const settingsPath = join(claudeDir, 'settings.json');
+    if (force || !await fileExists(settingsPath)) {
+        await createStaticFile('dotclaude/settings.json.template', settingsPath);
+    }
+    else {
+        ux.warn('File already exists: .claude/settings.json (use --force to overwrite)');
     }
 }
 /**
- * Initialize agent configuration files
- * Main entry point for agent initialization logic
+ * Create CLAUDE.md symlink pointing to .outputai/AGENTS.md
+ * Only checks if CLAUDE.md exists, not AGENTS.md - developers can remove AGENTS.md freely
  */
-export async function initializeAgentConfig(options) {
-    const { projectRoot, force, agentProvider } = options;
-    const variables = prepareTemplateVariables();
-    await processMappings(AGENT_CONFIGS.outputai, variables, force, projectRoot);
-    await processMappings(AGENT_CONFIGS[agentProvider], variables, force, projectRoot);
-}
-function formatMissingFilesList(files) {
-    return files.map(f => `  • ${f}`).join('\n');
+async function createClaudeMdSymlink(projectRoot, force) {
+    const claudeMdPath = join(projectRoot, 'CLAUDE.md');
+    if (force || !await fileExists(claudeMdPath)) {
+        await createSymlink(`${AGENT_CONFIG_DIR}/AGENTS.md`, claudeMdPath, projectRoot);
+    }
+    else {
+        ux.warn('File already exists: CLAUDE.md (use --force to overwrite)');
+    }
 }
-async function promptForReinitialize() {
-    return confirm({
-        message: 'Would you like to run "agents init --force" to recreate missing files?',
-        default: true
-    });
+/**
+ * Register and update the OutputAI plugin marketplace
+ */
+async function registerPluginMarketplace(projectRoot) {
+    ux.stdout(ux.colorize('gray', 'Registering plugin marketplace...'));
+    await executeClaudeCommand(['plugin', 'marketplace', 'add', 'growthxai/output-claude-plugins'], projectRoot, { ignoreFailure: true });
+    ux.stdout(ux.colorize('gray', 'Updating plugin marketplace...'));
+    await executeClaudeCommand(['plugin', 'marketplace', 'update', 'outputai'], projectRoot);
 }
-async function initializeAgentStructure(projectRoot, force) {
-    await initializeAgentConfig({
-        projectRoot,
-        force,
-        agentProvider: 'claude-code'
-    });
+/**
+ * Install the OutputAI plugin
+ */
+async function installOutputAIPlugin(projectRoot) {
+    ux.stdout(ux.colorize('gray', 'Installing OutputAI plugin...'));
+    await executeClaudeCommand(['plugin', 'install', 'outputai@outputai', '--scope', 'project'], projectRoot);
 }
-function createIncompleteConfigError(missingFiles) {
-    return new Error(`Agent configuration incomplete. Missing files:\n${missingFiles.join('\n')}\n\n` +
-        'Run "output-cli agents init --force" to recreate them.');
+/**
+ * Initialize agent configuration files and register Claude Code plugin
+ * Creates 3 files:
+ * - .outputai/AGENTS.md (from template with Handlebars processing)
+ * - .claude/settings.json (static JSON)
+ * - CLAUDE.md symlink to .outputai/AGENTS.md
+ * Then runs Claude CLI commands to register the plugin marketplace and install the plugin
+ */
+export async function initializeAgentConfig(options) {
+    const { projectRoot, force } = options;
+    const variables = prepareTemplateVariables();
+    await createAgentsMdFile(projectRoot, force, variables);
+    await createSettingsFile(projectRoot, force);
+    await createClaudeMdSymlink(projectRoot, force);
+    await registerPluginMarketplace(projectRoot);
+    await installOutputAIPlugin(projectRoot);
 }
 /**
- * Ensure .outputai directory structure exists by invoking agents init if needed
- * Displays warnings for missing files and prompts for reinitialization
+ * Ensure OutputAI system is initialized by invoking agents init if needed
+ * Creates configuration files and registers Claude Code plugin
  * @param projectRoot - Root directory of the project
- * @throws Error if user declines to initialize or if initialization fails
  */
-export async function ensureOutputAIStructure(projectRoot) {
-    const structureCheck = await checkAgentStructure(projectRoot);
-    if (structureCheck.isComplete) {
-        return;
-    }
-    if (!structureCheck.dirExists) {
-        await initializeAgentStructure(projectRoot, false);
+export async function ensureOutputAISystem(projectRoot) {
+    const { isComplete, needsInit } = await checkAgentStructure(projectRoot);
+    if (isComplete) {
         return;
     }
-    const missingList = formatMissingFilesList(structureCheck.missingFiles);
-    ux.warn(`\n⚠️  Agent configuration is incomplete. Missing files:\n${missingList}\n`);
-    const shouldReinit = await promptForReinitialize();
-    if (!shouldReinit) {
-        throw createIncompleteConfigError(structureCheck.missingFiles);
+    if (needsInit) {
+        ux.warn('Agent configuration is incomplete. Initializing...');
+        await initializeAgentConfig({ projectRoot, force: false });
     }
-    await initializeAgentStructure(projectRoot, true);
 }