@output.ai/cli 0.8.0 → 0.8.2

package/dist/commands/agents/{init.d.ts → update.d.ts}

@@ -1,10 +1,8 @@
 import { Command } from '@oclif/core';
-export default class Init extends Command {
+export default class Update extends Command {
     static description: string;
     static examples: string[];
     static args: {};
-    static flags: {
-        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-    };
+    static flags: {};
     run(): Promise<void>;
 }

package/dist/commands/agents/update.js

@@ -0,0 +1,29 @@
+import { Command } from '@oclif/core';
+import { ensureClaudePlugin } from '#services/coding_agents.js';
+import { getErrorMessage, getErrorCode } from '#utils/error_utils.js';
+export default class Update extends Command {
+    static description = 'Update Claude Code plugin for Output.ai';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>'
+    ];
+    static args = {};
+    static flags = {};
+    async run() {
+        this.log('Updating Claude Code plugin...');
+        try {
+            await ensureClaudePlugin(process.cwd());
+            this.log('Claude Code plugin updated successfully!');
+            this.log('');
+            this.log('Updated:');
+            this.log('  - Registered marketplace: growthxai/output-claude-plugins');
+            this.log('  - Updated marketplace: outputai');
+            this.log('  - Installed plugin: outputai@outputai');
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'EACCES') {
+                this.warn('Permission denied. Please check file permissions and try again.');
+            }
+            this.error(`Failed to update Claude Code plugin: ${getErrorMessage(error)}`);
+        }
+    }
+}

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

@@ -0,0 +1,84 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import Update from './update.js';
+import { ensureClaudePlugin } from '#services/coding_agents.js';
+vi.mock('#services/coding_agents.js', () => ({
+    ensureClaudePlugin: vi.fn()
+}));
+describe('agents update', () => {
+    const createTestCommand = (args = []) => {
+        const cmd = new Update(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(ensureClaudePlugin).mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('command structure', () => {
+        it('should have correct description', () => {
+            expect(Update.description).toBeDefined();
+            expect(Update.description).toContain('Update Claude Code plugin');
+        });
+        it('should have correct examples', () => {
+            expect(Update.examples).toBeDefined();
+            expect(Array.isArray(Update.examples)).toBe(true);
+        });
+        it('should have no required arguments', () => {
+            expect(Update.args).toBeDefined();
+            expect(Object.keys(Update.args)).toHaveLength(0);
+        });
+        it('should have no flags', () => {
+            expect(Update.flags).toBeDefined();
+            expect(Object.keys(Update.flags)).toHaveLength(0);
+        });
+    });
+    describe('successful execution', () => {
+        it('should call ensureClaudePlugin with process.cwd()', async () => {
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: {}, args: {} });
+            await cmd.run();
+            expect(ensureClaudePlugin).toHaveBeenCalledWith(expect.any(String));
+        });
+        it('should display success messages', async () => {
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: {}, args: {} });
+            await cmd.run();
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('updated successfully'));
+            expect(cmd.log).toHaveBeenCalledWith('Updated:');
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('marketplace'));
+        });
+    });
+    describe('error handling', () => {
+        it('should handle permission errors', async () => {
+            vi.mocked(ensureClaudePlugin).mockRejectedValue({ code: 'EACCES' });
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: {}, args: {} });
+            await cmd.run();
+            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('Permission denied'));
+            expect(cmd.error).toHaveBeenCalled();
+        });
+        it('should handle general errors with message', async () => {
+            vi.mocked(ensureClaudePlugin).mockRejectedValue(new Error('Something went wrong'));
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: {}, args: {} });
+            await cmd.run();
+            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Failed to update Claude Code plugin'));
+            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Something went wrong'));
+        });
+        it('should handle Claude CLI not found error', async () => {
+            vi.mocked(ensureClaudePlugin).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: {}, args: {} });
+            await cmd.run();
+            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Claude CLI not found'));
+        });
+    });
+});

package/dist/commands/dev/index.js

@@ -5,6 +5,7 @@ import logUpdate from 'log-update';
 import { validateDockerEnvironment, startDockerCompose, stopDockerCompose, getServiceStatus, DockerComposeConfigNotFoundError, getDefaultDockerComposePath, SERVICE_HEALTH, SERVICE_STATE } from '#services/docker.js';
 import { getErrorMessage } from '#utils/error_utils.js';
 import { getDevSuccessMessage } from '#services/messages.js';
+import { ensureClaudePlugin } from '#services/coding_agents.js';
 const ANSI = {
     RESET: '\x1b[0m',
     DIM: '\x1b[2m',
@@ -96,6 +97,8 @@ export default class Dev extends Command {
     dockerProcess = null;
     async run() {
         const { flags } = await this.parse(Dev);
+        // Ensure Claude plugin is configured (fire-and-forget, silent)
+        ensureClaudePlugin(process.cwd(), { silent: true }).catch(() => { });
         validateDockerEnvironment();
         const dockerComposePath = flags['compose-file'] ?
             path.resolve(process.cwd(), flags['compose-file']) :

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

@@ -2,7 +2,11 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import fs from 'node:fs/promises';
 import * as dockerService from '#services/docker.js';
+import * as codingAgentsService from '#services/coding_agents.js';
 import Dev from './index.js';
+vi.mock('#services/coding_agents.js', () => ({
+    ensureClaudePlugin: vi.fn().mockResolvedValue(undefined)
+}));
 vi.mock('#services/docker.js', () => ({
     validateDockerEnvironment: vi.fn(),
     startDockerCompose: vi.fn(),
@@ -48,6 +52,8 @@ describe('dev command', () => {
         vi.mocked(dockerService.startDockerCompose).mockResolvedValue(createMockDockerProcess());
         // By default, fs.access succeeds (file exists)
         vi.mocked(fs).access.mockResolvedValue(undefined);
+        // By default, ensureClaudePlugin succeeds
+        vi.mocked(codingAgentsService.ensureClaudePlugin).mockResolvedValue(undefined);
     });
     afterEach(() => {
         vi.restoreAllMocks();
@@ -128,6 +134,36 @@ describe('dev command', () => {
             expect(vi.mocked(dockerService.validateDockerEnvironment)).toBeDefined();
         });
     });
+    describe('Claude plugin update', () => {
+        it('should call ensureClaudePlugin on startup', async () => {
+            const cmd = new Dev([], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({ flags: { 'no-watch': false, 'compose-file': undefined, 'image-pull-policy': 'always' }, args: {} }),
+                configurable: true
+            });
+            const runPromise = cmd.run();
+            await new Promise(resolve => setImmediate(resolve));
+            expect(codingAgentsService.ensureClaudePlugin).toHaveBeenCalledWith(process.cwd(), { silent: true });
+            runPromise.catch(() => { });
+        });
+        it('should not block dev if ensureClaudePlugin fails', async () => {
+            vi.mocked(codingAgentsService.ensureClaudePlugin).mockRejectedValue(new Error('Plugin update failed'));
+            const cmd = new Dev([], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            Object.defineProperty(cmd, 'parse', {
+                value: vi.fn().mockResolvedValue({ flags: { 'no-watch': false, 'compose-file': undefined, 'image-pull-policy': 'always' }, args: {} }),
+                configurable: true
+            });
+            const runPromise = cmd.run();
+            await new Promise(resolve => setImmediate(resolve));
+            // Docker compose should still be called even if plugin update fails
+            expect(dockerService.startDockerCompose).toHaveBeenCalled();
+            runPromise.catch(() => { });
+        });
+    });
     describe('watch functionality', () => {
         it('should enable watch by default', async () => {
             const cmd = new Dev([], {});

package/dist/generated/framework_version.json

@@ -0,0 +1,3 @@
+{
+    "framework": "0.1.0"
+}

package/dist/services/claude_client.js

@@ -87,7 +87,7 @@ function displaySystemValidationWarnings(validation) {
         ux.warn(`Missing required claude-code slash command: /${command}`);
     });
     ux.warn('Your claude-code agent is missing key configurations, it may not behave as expected.');
-    ux.warn('Please run "npx output agents init" to fix this.');
+    ux.warn('Please run "npx output agents update" to fix this.');
 }
 function applyDefaultOptions(options) {
     return {

package/dist/services/coding_agents.d.ts

@@ -6,31 +6,31 @@ export interface InitOptions {
     projectRoot: string;
     force: boolean;
 }
-/**
- * Get the full path to the agent configuration directory
- */
-export declare function getAgentConfigDir(projectRoot: string): string;
-/**
- * Check if .outputai directory exists
- */
-export declare function checkAgentConfigDirExists(projectRoot: string): Promise<boolean>;
+interface EnsureClaudePluginOptions {
+    silent?: boolean;
+}
 export declare function checkAgentStructure(projectRoot: string): Promise<StructureCheckResult>;
 /**
  * Prepare template variables for file generation
  */
 export declare function prepareTemplateVariables(): Record<string, string>;
+/**
+ * Ensure Claude Code plugin is configured
+ * Registers marketplace, updates it, and installs the plugin
+ */
+export declare function ensureClaudePlugin(projectRoot: string, options?: EnsureClaudePluginOptions): Promise<void>;
 /**
  * Initialize agent configuration files and register Claude Code plugin
- * Creates 3 files:
- * - .outputai/AGENTS.md (from template with Handlebars processing)
+ * Creates:
  * - .claude/settings.json (static JSON)
- * - CLAUDE.md symlink to .outputai/AGENTS.md
+ * - CLAUDE.md (from template - user-customizable file)
  * Then runs Claude CLI commands to register the plugin marketplace and install the plugin
  */
 export declare function initializeAgentConfig(options: InitOptions): Promise<void>;
 /**
- * Ensure OutputAI system is initialized by invoking agents init if needed
+ * Ensure OutputAI system is initialized
  * Creates configuration files and registers Claude Code plugin
  * @param projectRoot - Root directory of the project
  */
 export declare function ensureOutputAISystem(projectRoot: string): Promise<void>;
+export {};

package/dist/services/coding_agents.js

@@ -8,30 +8,15 @@ import path from 'node:path';
 import { join } from 'node:path';
 import { ux } from '@oclif/core';
 import { confirm } from '@inquirer/prompts';
-import { config } from '#config.js';
+import debugFactory from 'debug';
 import { getTemplateDir } from '#utils/paths.js';
 import { executeClaudeCommand } from '#utils/claude.js';
 import { processTemplate } from '#utils/template.js';
 import { ClaudePluginError, UserCancelledError } from '#types/errors.js';
+const debug = debugFactory('output-cli:agent');
 const EXPECTED_MARKETPLACE_REPO = 'growthxai/output-claude-plugins';
-/**
- * Get the full path to the agent configuration directory
- */
-export function getAgentConfigDir(projectRoot) {
-    return join(projectRoot, config.agentConfigDir);
-}
-/**
- * Check if .outputai directory exists
- */
-export async function checkAgentConfigDirExists(projectRoot) {
-    const agentConfigDir = getAgentConfigDir(projectRoot);
-    try {
-        await access(agentConfigDir);
-        return true;
-    }
-    catch {
-        return false;
-    }
+function createLogger(silent) {
+    return silent ? debug : (msg) => ux.stdout(ux.colorize('gray', msg));
 }
 async function fileExists(filePath) {
     try {
@@ -59,7 +44,6 @@ async function validateSettingsJson(projectRoot) {
     }
 }
 export async function checkAgentStructure(projectRoot) {
-    const outputaiDirExists = await checkAgentConfigDirExists(projectRoot);
     const settingsValid = await validateSettingsJson(projectRoot);
     const claudeMdExists = await fileExists(join(projectRoot, 'CLAUDE.md'));
     if (!settingsValid) {
@@ -68,11 +52,8 @@ export async function checkAgentStructure(projectRoot) {
     if (!claudeMdExists) {
         ux.warn('CLAUDE.md missing.');
     }
-    if (!outputaiDirExists) {
-        ux.warn('.outputai/ directory missing.');
-    }
-    const isComplete = outputaiDirExists && settingsValid && claudeMdExists;
-    const needsInit = !outputaiDirExists || !settingsValid;
+    const isComplete = settingsValid && claudeMdExists;
+    const needsInit = !settingsValid;
     return { isComplete, needsInit };
 }
 /**
@@ -122,51 +103,6 @@ async function createStaticFile(templateSubpath, output) {
     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
- */
-async function createSymlink(source, target, projectRoot) {
-    try {
-        if (await fileExists(target)) {
-            await fs.unlink(target);
-        }
-        // Resolve source path relative to project root if it's relative
-        const resolvedSource = path.isAbsolute(source) ?
-            source :
-            path.join(projectRoot, source);
-        // Calculate relative path from target directory to resolved source
-        const relativePath = path.relative(path.dirname(target), resolvedSource);
-        await fs.symlink(relativePath, target);
-        ux.stdout(ux.colorize('gray', `Created symlink: ${target} -> ${source}`));
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === 'ENOTSUP' || code === 'EPERM') {
-            ux.stdout(ux.colorize('gray', `Symlinks not supported, creating copy: ${target}`));
-            const resolvedSource = path.isAbsolute(source) ?
-                source :
-                path.join(projectRoot, source);
-            const content = await fs.readFile(resolvedSource, 'utf-8');
-            await fs.writeFile(target, content, 'utf-8');
-            return;
-        }
-        throw error;
-    }
-}
-/**
- * Create .outputai/AGENTS.md file from template
- */
-async function createAgentsMdFile(projectRoot, force, variables) {
-    const outputaiDir = join(projectRoot, config.agentConfigDir);
-    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: ${config.agentConfigDir}/AGENTS.md (use --force to overwrite)`);
-    }
-}
 /**
  * Create .claude/settings.json file from template
  */
@@ -182,13 +118,12 @@ async function createSettingsFile(projectRoot, force) {
     }
 }
 /**
- * Create CLAUDE.md symlink pointing to .outputai/AGENTS.md
- * Only checks if CLAUDE.md exists, not AGENTS.md - developers can remove AGENTS.md freely
+ * Create CLAUDE.md file from template
  */
-async function createClaudeMdSymlink(projectRoot, force) {
+async function createClaudeMdFile(projectRoot, force, variables) {
     const claudeMdPath = join(projectRoot, 'CLAUDE.md');
     if (force || !await fileExists(claudeMdPath)) {
-        await createSymlink(`${config.agentConfigDir}/AGENTS.md`, claudeMdPath, projectRoot);
+        await createFromTemplate('CLAUDE.md.template', claudeMdPath, variables);
     }
     else {
         ux.warn('File already exists: CLAUDE.md (use --force to overwrite)');
@@ -198,10 +133,15 @@ async function createClaudeMdSymlink(projectRoot, force) {
  * Handle Claude plugin command errors with user confirmation to proceed
  * @param error - The error that occurred
  * @param commandName - Name of the command that failed
+ * @param silent - If true, log to debug and re-throw without user confirmation
  * @throws UserCancelledError if user declines to proceed or presses Ctrl+C
  */
-async function handlePluginError(error, commandName) {
+async function handlePluginError(error, commandName, silent = false) {
     const pluginError = new ClaudePluginError(commandName, error instanceof Error ? error : undefined);
+    if (silent) {
+        debug('Plugin error: %s', pluginError.message);
+        throw error;
+    }
     ux.warn(pluginError.message);
     try {
         const shouldProceed = await confirm({
@@ -225,54 +165,62 @@ async function handlePluginError(error, commandName) {
 /**
  * Register and update the OutputAI plugin marketplace
  */
-async function registerPluginMarketplace(projectRoot) {
-    ux.stdout(ux.colorize('gray', 'Registering plugin marketplace...'));
+async function registerPluginMarketplace(projectRoot, silent = false) {
+    const log = createLogger(silent);
+    log('Registering plugin marketplace...');
     try {
         await executeClaudeCommand(['plugin', 'marketplace', 'add', 'growthxai/output-claude-plugins'], projectRoot, { ignoreFailure: true });
     }
     catch (error) {
-        await handlePluginError(error, 'plugin marketplace add');
+        await handlePluginError(error, 'plugin marketplace add', silent);
         return;
     }
-    ux.stdout(ux.colorize('gray', 'Updating plugin marketplace...'));
+    log('Updating plugin marketplace...');
     try {
         await executeClaudeCommand(['plugin', 'marketplace', 'update', 'outputai'], projectRoot);
     }
     catch (error) {
-        await handlePluginError(error, 'plugin marketplace update outputai');
+        await handlePluginError(error, 'plugin marketplace update outputai', silent);
     }
 }
 /**
  * Install the OutputAI plugin
  */
-async function installOutputAIPlugin(projectRoot) {
-    ux.stdout(ux.colorize('gray', 'Installing OutputAI plugin...'));
+async function installOutputAIPlugin(projectRoot, silent = false) {
+    const log = createLogger(silent);
+    log('Installing OutputAI plugin...');
     try {
         await executeClaudeCommand(['plugin', 'install', 'outputai@outputai', '--scope', 'project'], projectRoot);
     }
     catch (error) {
-        await handlePluginError(error, 'plugin install outputai@outputai');
+        await handlePluginError(error, 'plugin install outputai@outputai', silent);
     }
 }
+/**
+ * Ensure Claude Code plugin is configured
+ * Registers marketplace, updates it, and installs the plugin
+ */
+export async function ensureClaudePlugin(projectRoot, options = {}) {
+    const { silent = false } = options;
+    await registerPluginMarketplace(projectRoot, silent);
+    await installOutputAIPlugin(projectRoot, silent);
+}
 /**
  * Initialize agent configuration files and register Claude Code plugin
- * Creates 3 files:
- * - .outputai/AGENTS.md (from template with Handlebars processing)
+ * Creates:
  * - .claude/settings.json (static JSON)
- * - CLAUDE.md symlink to .outputai/AGENTS.md
+ * - CLAUDE.md (from template - user-customizable file)
  * 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);
+    await createClaudeMdFile(projectRoot, force, variables);
+    await ensureClaudePlugin(projectRoot);
 }
 /**
- * Ensure OutputAI system is initialized by invoking agents init if needed
+ * Ensure OutputAI system is initialized
  * Creates configuration files and registers Claude Code plugin
  * @param projectRoot - Root directory of the project
  */

package/dist/services/coding_agents.spec.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { checkAgentConfigDirExists, checkAgentStructure, getAgentConfigDir, prepareTemplateVariables, initializeAgentConfig, ensureOutputAISystem } from './coding_agents.js';
+import { checkAgentStructure, prepareTemplateVariables, initializeAgentConfig, ensureOutputAISystem, ensureClaudePlugin } from './coding_agents.js';
 import { access } from 'node:fs/promises';
 import fs from 'node:fs/promises';
 vi.mock('node:fs/promises');
@@ -26,35 +26,17 @@ describe('coding_agents service', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
-    describe('getAgentConfigDir', () => {
-        it('should return the correct path to .outputai directory', () => {
-            const result = getAgentConfigDir('/test/project');
-            expect(result).toBe('/test/project/.outputai');
-        });
-    });
-    describe('checkAgentConfigDirExists', () => {
-        it('should return true when .outputai directory exists', async () => {
-            vi.mocked(access).mockResolvedValue(undefined);
-            const result = await checkAgentConfigDirExists('/test/project');
-            expect(result).toBe(true);
-            expect(access).toHaveBeenCalledWith('/test/project/.outputai');
-        });
-        it('should return false when .outputai directory does not exist', async () => {
-            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
-            const result = await checkAgentConfigDirExists('/test/project');
-            expect(result).toBe(false);
-        });
-    });
     describe('checkAgentStructure', () => {
-        it('should return needsInit true when directory does not exist', async () => {
+        it('should return needsInit true when settings.json does not exist', async () => {
             vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
             const result = await checkAgentStructure('/test/project');
             expect(result).toEqual({
                 isComplete: false,
                 needsInit: true
             });
         });
-        it('should return complete when all files exist with valid settings', async () => {
+        it('should return complete when settings and CLAUDE.md exist with valid configuration', async () => {
             vi.mocked(access).mockResolvedValue(undefined);
             vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
                 extraKnownMarketplaces: {
@@ -113,19 +95,6 @@ describe('coding_agents service', () => {
             expect(result.isComplete).toBe(false);
             expect(result.needsInit).toBe(true);
         });
-        it('should return needsInit true when settings.json does not exist', async () => {
-            vi.mocked(access).mockImplementation(async (path) => {
-                const pathStr = path.toString();
-                if (pathStr.endsWith('.claude/settings.json')) {
-                    throw { code: 'ENOENT' };
-                }
-                return undefined;
-            });
-            vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
-            const result = await checkAgentStructure('/test/project');
-            expect(result.isComplete).toBe(false);
-            expect(result.needsInit).toBe(true);
-        });
     });
     describe('prepareTemplateVariables', () => {
         it('should return template variables with formatted date', () => {
@@ -141,19 +110,18 @@ describe('coding_agents service', () => {
             vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
             vi.mocked(fs.readFile).mockResolvedValue('template content');
             vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-            vi.mocked(fs.symlink).mockResolvedValue(undefined);
         });
-        it('should create exactly 3 outputs: AGENTS.md, settings.json, and CLAUDE.md symlink', async () => {
+        it('should create exactly 2 outputs: settings.json and CLAUDE.md file', async () => {
             await initializeAgentConfig({
                 projectRoot: '/test/project',
                 force: false
             });
-            expect(fs.mkdir).toHaveBeenCalledTimes(2);
-            expect(fs.mkdir).toHaveBeenCalledWith('/test/project/.outputai', expect.objectContaining({ recursive: true }));
+            expect(fs.mkdir).toHaveBeenCalledTimes(1);
             expect(fs.mkdir).toHaveBeenCalledWith('/test/project/.claude', expect.objectContaining({ recursive: true }));
-            expect(fs.writeFile).toHaveBeenCalledWith('/test/project/.outputai/AGENTS.md', expect.any(String), 'utf-8');
             expect(fs.writeFile).toHaveBeenCalledWith('/test/project/.claude/settings.json', expect.any(String), 'utf-8');
-            expect(fs.symlink).toHaveBeenCalledTimes(1);
+            expect(fs.writeFile).toHaveBeenCalledWith('/test/project/CLAUDE.md', expect.any(String), 'utf-8');
+            // No symlink should be created - CLAUDE.md is now a real file
+            expect(fs.symlink).not.toHaveBeenCalled();
         });
         it('should skip existing files when force is false', async () => {
             vi.mocked(access).mockResolvedValue(undefined);
@@ -162,7 +130,6 @@ describe('coding_agents service', () => {
                 force: false
             });
             expect(fs.writeFile).not.toHaveBeenCalled();
-            expect(fs.symlink).not.toHaveBeenCalled();
         });
         it('should overwrite existing files when force is true', async () => {
             vi.mocked(access).mockResolvedValue(undefined);
@@ -173,15 +140,40 @@ describe('coding_agents service', () => {
             });
             expect(fs.writeFile).toHaveBeenCalled();
         });
-        it('should handle symlink errors by falling back to copy', async () => {
-            vi.mocked(fs.symlink).mockRejectedValue({ code: 'ENOTSUP' });
-            await initializeAgentConfig({
-                projectRoot: '/test/project',
-                force: false
-            });
-            const writeFileCalls = vi.mocked(fs.writeFile).mock.calls;
-            const claudeMdCalls = writeFileCalls.filter(call => call[0].toString().includes('CLAUDE.md'));
-            expect(claudeMdCalls.length).toBe(1);
+    });
+    describe('ensureClaudePlugin', () => {
+        beforeEach(() => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            vi.mocked(fs.readFile).mockResolvedValue('template content');
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+        });
+        it('should call registerPluginMarketplace and installOutputAIPlugin', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            await ensureClaudePlugin('/test/project');
+            expect(executeClaudeCommand).toHaveBeenCalledWith(['plugin', 'marketplace', 'add', 'growthxai/output-claude-plugins'], '/test/project', { ignoreFailure: true });
+            expect(executeClaudeCommand).toHaveBeenCalledWith(['plugin', 'marketplace', 'update', 'outputai'], '/test/project');
+            expect(executeClaudeCommand).toHaveBeenCalledWith(['plugin', 'install', 'outputai@outputai', '--scope', 'project'], '/test/project');
+        });
+        it('should show error and prompt user when plugin commands fail', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(executeClaudeCommand)
+                .mockResolvedValueOnce(undefined) // marketplace add
+                .mockRejectedValueOnce(new Error('Plugin update failed')); // marketplace update
+            vi.mocked(confirm).mockResolvedValue(true);
+            await expect(ensureClaudePlugin('/test/project')).resolves.not.toThrow();
+            expect(confirm).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('proceed')
+            }));
+        });
+        it('should allow user to proceed without plugin setup if they confirm', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(executeClaudeCommand)
+                .mockRejectedValue(new Error('All plugin commands fail'));
+            vi.mocked(confirm).mockResolvedValue(true);
+            await expect(ensureClaudePlugin('/test/project')).resolves.not.toThrow();
         });
     });
     describe('ensureOutputAISystem', () => {
@@ -190,7 +182,6 @@ describe('coding_agents service', () => {
             vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
             vi.mocked(fs.readFile).mockResolvedValue('template content');
             vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-            vi.mocked(fs.symlink).mockResolvedValue(undefined);
         });
         it('should return immediately when agent structure is complete', async () => {
             vi.mocked(access).mockResolvedValue(undefined);
@@ -205,12 +196,6 @@ describe('coding_agents service', () => {
             await ensureOutputAISystem('/test/project');
             expect(fs.mkdir).not.toHaveBeenCalled();
         });
-        it('should auto-initialize when directory does not exist', async () => {
-            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
-            await ensureOutputAISystem('/test/project');
-            expect(fs.mkdir).toHaveBeenCalled();
-            expect(fs.writeFile).toHaveBeenCalled();
-        });
         it('should auto-initialize when settings.json is invalid', async () => {
             vi.mocked(access).mockResolvedValue(undefined);
             vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
@@ -231,7 +216,6 @@ describe('coding_agents service', () => {
             vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
             vi.mocked(fs.readFile).mockResolvedValue('template content');
             vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-            vi.mocked(fs.symlink).mockResolvedValue(undefined);
         });
         it('should show error and prompt user when registerPluginMarketplace fails', async () => {
             const { executeClaudeCommand } = await import('../utils/claude.js');