codymaster 4.8.0 → 5.2.0

package/dist/advisory-report.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAdvisoryReportData = buildAdvisoryReportData;
+exports.buildAdvisoryMetricsData = buildAdvisoryMetricsData;
+exports.formatAdvisoryReport = formatAdvisoryReport;
+exports.formatAdvisoryMetrics = formatAdvisoryMetrics;
+const execution_analyzer_1 = require("./execution-analyzer");
+function fmtConfidence(value) {
+    if (typeof value !== 'number')
+        return '-';
+    return value.toFixed(2);
+}
+function summarizeTargetSkills(analysis) {
+    const targets = analysis.skill_judgments
+        .filter((judgment) => judgment.selected || judgment.applied)
+        .map((judgment) => judgment.skill);
+    return targets.length > 0 ? targets.join(', ') : '-';
+}
+function formatAnalysisLine(analysis) {
+    var _a;
+    const action = (_a = analysis.recommended_action) !== null && _a !== void 0 ? _a : 'NONE';
+    return [
+        `- ${analysis.task_title}`,
+        `status=${analysis.status}`,
+        `action=${action}`,
+        `confidence=${fmtConfidence(analysis.confidence)}`,
+        `skills=${summarizeTargetSkills(analysis)}`,
+    ].join(' | ');
+}
+function formatMetricLine(metric) {
+    var _a;
+    return [
+        `- ${metric.skill}`,
+        `quality=${metric.quality_weight.toFixed(2)}`,
+        `selected=${metric.selections}`,
+        `applied=${metric.applications}`,
+        `completed=${metric.task_completions}`,
+        `fallbacks=${metric.fallbacks}`,
+        `action=${(_a = metric.last_recommended_action) !== null && _a !== void 0 ? _a : '-'}`,
+    ].join(' | ');
+}
+function buildAdvisoryReportData(backend, options = {}) {
+    var _a;
+    const limit = (_a = options.limit) !== null && _a !== void 0 ? _a : 10;
+    return backend.getExecutionAnalyses(limit).map((analysis) => ({
+        id: analysis.id,
+        task_title: analysis.task_title,
+        status: analysis.status,
+        summary: analysis.summary,
+        source_task_type: analysis.source_task_type,
+        recommended_action: analysis.recommended_action,
+        confidence: analysis.confidence,
+        created_at: analysis.created_at,
+        active_skills: analysis.skill_judgments
+            .filter((judgment) => judgment.selected || judgment.applied)
+            .map((judgment) => judgment.skill),
+    }));
+}
+function buildAdvisoryMetricsData(backend, options = {}) {
+    var _a;
+    const limit = (_a = options.limit) !== null && _a !== void 0 ? _a : 10;
+    return backend.listSkillMetrics(limit).map((metric) => ({
+        skill: metric.skill,
+        quality_weight: (0, execution_analyzer_1.qualityWeight)(metric),
+        selections: metric.selections,
+        applications: metric.applications,
+        task_completions: metric.task_completions,
+        fallbacks: metric.fallbacks,
+        total_token_estimate: metric.total_token_estimate,
+        last_task_type: metric.last_task_type,
+        last_recommended_action: metric.last_recommended_action,
+        last_used_at: metric.last_used_at,
+        updated_at: metric.updated_at,
+    }));
+}
+function formatAdvisoryReport(backend, options = {}) {
+    const analyses = buildAdvisoryReportData(backend, options);
+    if (analyses.length === 0) {
+        return [
+            'Advisory Report',
+            '',
+            'No execution analyses recorded yet.',
+        ].join('\n');
+    }
+    return [
+        'Advisory Report',
+        '',
+        ...analyses.map((analysis) => formatAnalysisLine(Object.assign(Object.assign({}, analysis), { skill_judgments: analysis.active_skills.map((skill) => ({ skill, selected: true })) }))),
+    ].join('\n');
+}
+function formatAdvisoryMetrics(backend, options = {}) {
+    const metrics = buildAdvisoryMetricsData(backend, options);
+    if (metrics.length === 0) {
+        return [
+            'Skill Metrics',
+            '',
+            'No skill metrics recorded yet.',
+        ].join('\n');
+    }
+    return [
+        'Skill Metrics',
+        '',
+        ...metrics.map(formatMetricLine),
+    ].join('\n');
+}

package/dist/cli/command-registry.js

@@ -10,6 +10,10 @@ const task_1 = require("./commands/task");
 const engineering_1 = require("./commands/engineering");
 const design_studio_1 = require("./commands/design-studio");
 const distro_1 = require("./commands/distro");
+const mcp_serve_1 = require("./commands/mcp-serve");
+const bench_1 = require("./commands/bench");
+const brain_1 = require("./commands/brain");
+const evolve_1 = require("./commands/evolve");
 /**
  * Registers all CLI commands with the provided program instance.
  */
@@ -23,4 +27,8 @@ function registerAllCommands(program) {
     (0, engineering_1.registerEngineeringCommands)(program);
     (0, design_studio_1.registerDesignStudioCommands)(program);
     (0, distro_1.registerDistroCommands)(program);
+    (0, mcp_serve_1.registerMcpServeCommands)(program);
+    (0, bench_1.registerBenchCommands)(program);
+    (0, brain_1.registerBrainCommands)(program);
+    (0, evolve_1.registerEvolveCommands)(program);
 }

package/dist/cli/commands/bench.js

@@ -0,0 +1,69 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBenchCommands = registerBenchCommands;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const tdd_regression_1 = require("../../codybench/suites/tdd-regression");
+const token_efficiency_1 = require("../../codybench/suites/token-efficiency");
+const memory_retention_1 = require("../../codybench/suites/memory-retention");
+const claude_code_1 = require("../../codybench/runners/claude-code");
+const automated_1 = require("../../codybench/judges/automated");
+const SUITES = [tdd_regression_1.tddRegressionSuite, token_efficiency_1.tokenEfficiencySuite, memory_retention_1.memoryRetentionSuite];
+function registerBenchCommands(program) {
+    program
+        .command('bench')
+        .description('Run CodyBench evaluation suites (v0.1)')
+        .option('--suite <id>', 'Run specific suite (default: all enabled)')
+        .option('--runs <n>', 'Override repeat count per suite', parseInt)
+        .option('--output <path>', 'Output JSON file path')
+        .action((opts) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const projectPath = process.cwd();
+        const configPath = path_1.default.join(projectPath, 'codybench', 'config.json');
+        let config;
+        try {
+            config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+        }
+        catch (_b) {
+            console.error(chalk_1.default.red('Error: codybench/config.json not found. Run from project root.'));
+            process.exit(1);
+        }
+        // Override repeat if --runs provided
+        if (opts.runs)
+            config.evals = config.evals.map(e => (Object.assign(Object.assign({}, e), { repeat: opts.runs })));
+        const suitesToRun = opts.suite
+            ? SUITES.filter(s => s.id === opts.suite)
+            : SUITES.filter(s => config.evals.find(e => e.id === s.id && e.enabled));
+        if (suitesToRun.length === 0) {
+            console.error(chalk_1.default.red(`No suites found${opts.suite ? ` matching "${opts.suite}"` : ''}.`));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.bold(`\nCodyBench v${config.version} — running ${suitesToRun.length} suite(s)\n`));
+        const allResults = [];
+        for (const suite of suitesToRun) {
+            process.stdout.write(chalk_1.default.dim(`  Running ${suite.name}...`));
+            const results = yield (0, claude_code_1.runSuite)(suite, config, projectPath);
+            allResults.push(...results);
+            console.log(chalk_1.default.green(' done'));
+        }
+        const aggregates = (0, automated_1.aggregateResults)(allResults);
+        console.log('\n' + (0, automated_1.formatLeaderboard)(aggregates) + '\n');
+        const outputPath = (_a = opts.output) !== null && _a !== void 0 ? _a : path_1.default.join(projectPath, config.output_dir, `results-${Date.now()}.json`);
+        fs_1.default.mkdirSync(path_1.default.dirname(outputPath), { recursive: true });
+        fs_1.default.writeFileSync(outputPath, JSON.stringify({ config, results: allResults, aggregates }, null, 2));
+        console.log(chalk_1.default.dim(`Results saved to: ${outputPath}`));
+    }));
+}

package/dist/cli/commands/brain.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBrainCommands = registerBrainCommands;
+const smart_brain_router_1 = require("../../smart-brain-router");
+const skill_execution_cache_1 = require("../../skill-execution-cache");
+const token_budget_1 = require("../../token-budget");
+// ─── Brain & Token CLI Commands ──────────────────────────────────────────────
+function registerBrainCommands(program) {
+    const smart = program
+        .command('smart')
+        .description('Smart Brain Router — inspect brain layer selection for tasks');
+    smart
+        .command('plan <task>')
+        .description('Preview which brain layers would load for a task description')
+        .action((task) => {
+        const plan = (0, smart_brain_router_1.routeTask)(task);
+        const output = (0, smart_brain_router_1.formatBrainPlan)(plan);
+        console.log(output);
+    });
+    smart
+        .command('tiers')
+        .description('Show per-tier token budget allocations')
+        .action(() => {
+        const tierBudgets = (0, token_budget_1.getDefaultTierBudgets)();
+        console.log((0, token_budget_1.generateTierReport)(tierBudgets));
+    });
+    const token = program
+        .command('token')
+        .description('Token usage analysis and savings tracking');
+    token
+        .command('report')
+        .description('Show current token budget allocation')
+        .option('-p, --project <path>', 'Project path', process.cwd())
+        .action((opts) => {
+        const budget = (0, token_budget_1.loadBudget)(opts.project);
+        console.log((0, token_budget_1.generateBudgetReport)(budget));
+        console.log('');
+        const tierBudgets = (0, token_budget_1.getDefaultTierBudgets)();
+        console.log((0, token_budget_1.generateTierReport)(tierBudgets));
+    });
+    token
+        .command('savings')
+        .description('Show estimated token savings from smart routing and caching')
+        .option('-p, --project <path>', 'Project path', process.cwd())
+        .action((opts) => {
+        const cache = new skill_execution_cache_1.SkillExecutionCache(opts.project);
+        try {
+            cache.initialize();
+            const stats = cache.getStats();
+            console.log((0, skill_execution_cache_1.formatCacheStats)(stats));
+            console.log('');
+            // Compute savings summary
+            const savings = {
+                brainRoutingSaved: 0, // Tracked per-session (not persistent yet)
+                cacheHitsSaved: stats.estimatedTokensSaved,
+                progressiveLoadSaved: 0,
+                totalSaved: stats.estimatedTokensSaved,
+                sessionTasks: stats.totalHits,
+            };
+            console.log((0, token_budget_1.formatSavingsReport)(savings));
+        }
+        finally {
+            cache.close();
+        }
+    });
+    token
+        .command('cache')
+        .description('Show skill execution cache entries')
+        .option('-p, --project <path>', 'Project path', process.cwd())
+        .option('-n, --limit <n>', 'Max entries to show', '20')
+        .action((opts) => {
+        const cache = new skill_execution_cache_1.SkillExecutionCache(opts.project);
+        try {
+            cache.initialize();
+            const entries = cache.listCachedChains(parseInt(opts.limit));
+            if (entries.length === 0) {
+                console.log('📦 No cached skill chains yet. Complete some tasks to build the cache.');
+                return;
+            }
+            console.log(`📦 Skill Execution Cache (${entries.length} entries)`);
+            console.log('─'.repeat(70));
+            for (const entry of entries) {
+                const skills = entry.skillChain.join(' → ');
+                const eff = (entry.effectiveness * 100).toFixed(0);
+                console.log(`  ${entry.taskPattern.slice(0, 45).padEnd(45)} │ ${skills}`);
+                console.log(`  ${''.padEnd(45)} │ ${eff}% eff · ${entry.hitCount} hits · ${entry.tokenUsed} tok`);
+            }
+        }
+        finally {
+            cache.close();
+        }
+    });
+    token
+        .command('cache-clear')
+        .description('Clear the skill execution cache')
+        .option('-p, --project <path>', 'Project path', process.cwd())
+        .action((opts) => {
+        const cache = new skill_execution_cache_1.SkillExecutionCache(opts.project);
+        try {
+            cache.initialize();
+            const cleared = cache.clearCache();
+            console.log(`🗑️ Cleared ${cleared} cached entries.`);
+        }
+        finally {
+            cache.close();
+        }
+    });
+}

package/dist/cli/commands/engineering.js

@@ -25,6 +25,9 @@ const second_opinion_providers_1 = require("../../second-opinion-providers");
 const sprint_pipeline_1 = require("../../sprint-pipeline");
 const retro_summary_1 = require("../../retro-summary");
 const cm_suggest_1 = require("../../cm-suggest");
+const storage_backend_1 = require("../../storage-backend");
+const advisory_report_1 = require("../../advisory-report");
+const advisory_handoff_1 = require("../../advisory-handoff");
 function projectPath(opt) {
     return path_1.default.resolve(opt || process.cwd());
 }
@@ -100,6 +103,83 @@ function registerEngineeringCommands(program) {
         }
         console.log(chalk_1.default.green('OK'), opts.file);
     });
+    const advisory = program
+        .command('advisory')
+        .description('Operator-facing execution analysis and skill quality reports');
+    advisory
+        .command('report')
+        .description('Show recent execution analyses with recommended actions')
+        .option('--project <dir>')
+        .option('--limit <n>', 'number of analyses to show', '10')
+        .action((opts) => {
+        var _a;
+        const root = projectPath(opts.project);
+        const backend = (0, storage_backend_1.getBackend)(root);
+        backend.initialize();
+        try {
+            const limit = Math.max(1, parseInt(String((_a = opts.limit) !== null && _a !== void 0 ? _a : '10'), 10) || 10);
+            console.log((0, advisory_report_1.formatAdvisoryReport)(backend, { limit }));
+        }
+        finally {
+            backend.close();
+        }
+    });
+    advisory
+        .command('metrics')
+        .description('Show aggregated skill metrics with quality weights')
+        .option('--project <dir>')
+        .option('--limit <n>', 'number of skills to show', '10')
+        .action((opts) => {
+        var _a;
+        const root = projectPath(opts.project);
+        const backend = (0, storage_backend_1.getBackend)(root);
+        backend.initialize();
+        try {
+            const limit = Math.max(1, parseInt(String((_a = opts.limit) !== null && _a !== void 0 ? _a : '10'), 10) || 10);
+            console.log((0, advisory_report_1.formatAdvisoryMetrics)(backend, { limit }));
+        }
+        finally {
+            backend.close();
+        }
+    });
+    advisory
+        .command('handoff')
+        .description('Build a structured advisory handoff for cm-skill-health or cm-skill-evolution')
+        .requiredOption('--for <consumer>', 'cm-skill-health | cm-skill-evolution')
+        .option('--analysis <id>', 'analysis id prefix (default: latest)')
+        .option('--skill <name>', 'override target skill')
+        .option('--format <f>', 'md | json', 'md')
+        .option('--project <dir>')
+        .action((opts) => {
+        var _a;
+        const consumer = String(opts.for);
+        if (consumer !== 'cm-skill-health' && consumer !== 'cm-skill-evolution') {
+            console.error(chalk_1.default.red('Invalid --for value. Use cm-skill-health or cm-skill-evolution.'));
+            process.exit(1);
+        }
+        const root = projectPath(opts.project);
+        const backend = (0, storage_backend_1.getBackend)(root);
+        backend.initialize();
+        try {
+            const handoff = (0, advisory_handoff_1.buildAdvisoryHandoff)(backend, {
+                consumer,
+                analysisId: opts.analysis,
+                skill: opts.skill,
+            });
+            const format = String((_a = opts.format) !== null && _a !== void 0 ? _a : 'md').toLowerCase();
+            if (format === 'json')
+                console.log(JSON.stringify(handoff, null, 2));
+            else
+                console.log((0, advisory_handoff_1.formatAdvisoryHandoffMarkdown)(handoff));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(error.message));
+            process.exit(1);
+        }
+        finally {
+            backend.close();
+        }
+    });
     const sprint = program.command('sprint').description('Opinionated pipeline + .cm/sprint Context Bus');
     sprint
         .command('init')
@@ -413,6 +493,34 @@ function registerEngineeringCommands(program) {
             console.log(chalk_1.default.dim(`  ${s.reason}`));
         }
     });
+    const indexer = program.command('index').description('Project intelligence indexing');
+    indexer
+        .command('skills')
+        .description('Detect tech stack and build .cm/project-skills.md')
+        .option('--project <dir>')
+        .action((opts) => {
+        const root = projectPath(opts.project);
+        // Lazy load to avoid module compilation issues at boot if not used
+        const { generateProjectSkillsIndex } = require('../../indexer/skills');
+        const idx = generateProjectSkillsIndex(root);
+        const dotCm = path_1.default.join(root, '.cm');
+        if (!fs_1.default.existsSync(dotCm)) {
+            fs_1.default.mkdirSync(dotCm, { recursive: true });
+        }
+        const out = path_1.default.join(dotCm, 'project-skills.md');
+        const md = [
+            '# Local Project Skills Index',
+            '',
+            `Detected Technologies: **${idx.detectedTechnologies.join(', ') || 'None'}**`,
+            '',
+            '## Recommended Community Skills',
+            ...idx.recommendedSkills.map((s) => `- \`${s}\``),
+            '',
+            '> Autogenerated by `cm index skills`. Agents should run `npx skills add <skill>` if needed.'
+        ].join('\n');
+        fs_1.default.writeFileSync(out, md, 'utf-8');
+        console.log(chalk_1.default.green(`Indexed ${idx.detectedTechnologies.length} technologies and ${idx.recommendedSkills.length} skills to ${out}`));
+    });
 }
 function browseRequest(port, pathname, method, auth, body) {
     return new Promise((resolve, reject) => {

package/dist/cli/commands/evolve.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEvolveCommands = registerEvolveCommands;
+const skill_evolver_1 = require("../../skill-evolver");
+const learning_promoter_1 = require("../../learning-promoter");
+const advisory_handoff_1 = require("../../advisory-handoff");
+const storage_backend_1 = require("../../storage-backend");
+// ─── Evolution CLI Commands ─────────────────────────────────────────────────
+function registerEvolveCommands(program) {
+    const evolve = program
+        .command('evolve')
+        .description('Skill Evolution Engine — self-improving skills via FIX/DERIVED/CAPTURED modes');
+    evolve
+        .command('status')
+        .description('Show skill evolution status and records')
+        .option('-p, --project <path>', 'Project path', process.cwd())
+        .action((opts) => {
+        var _a;
+        const evolver = new skill_evolver_1.SkillEvolver(opts.project);
+        const records = evolver.listSkillRecords();
+        if (records.length === 0) {
+            console.log('🧬 No skill evolution records yet. Skills will begin evolving after task executions.');
+            return;
+        }
+        console.log('🧬 Skill Evolution Records');
+        console.log('─'.repeat(70));
+        console.log(`${'Skill'.padEnd(30)} ${'Origin'.padEnd(10)} ${'Gen'.padEnd(5)} ${'Evolutions'.padEnd(12)} Last Mode`);
+        console.log('─'.repeat(70));
+        for (const record of records) {
+            console.log(`${record.skill_name.padEnd(30)} ${record.origin.padEnd(10)} ${String(record.generation).padEnd(5)} ${String(record.evolution_count).padEnd(12)} ${(_a = record.last_evolution_mode) !== null && _a !== void 0 ? _a : '-'}`);
+        }
+    });
+    evolve
+        .command('run <mode> <skill>')
+        .description('Execute evolution on a skill (modes: FIX, DERIVED, CAPTURED)')
+        .option('-p, --project <path>', 'Project path', process.cwd())
+        .option('-c, --confidence <n>', 'Override confidence threshold', '0.85')
+        .action((mode, skill, opts) => {
+        const upperMode = mode.toUpperCase();
+        if (!['FIX', 'DERIVED', 'CAPTURED'].includes(upperMode)) {
+            console.error(`❌ Invalid mode: ${mode}. Must be FIX, DERIVED, or CAPTURED.`);
+            process.exit(1);
+        }
+        const evolver = new skill_evolver_1.SkillEvolver(opts.project);
+        const result = evolver.evolve(upperMode, skill, parseFloat(opts.confidence));
+        console.log((0, skill_evolver_1.formatEvolutionResult)(result));
+    });
+    evolve
+        .command('auto')
+        .description('Auto-evolve based on latest advisory handoff')
+        .option('-p, --project <path>', 'Project path', process.cwd())
+        .action((opts) => {
+        try {
+            const backend = (0, storage_backend_1.getBackend)(opts.project);
+            backend.initialize();
+            const handoff = (0, advisory_handoff_1.buildAdvisoryHandoff)(backend, { consumer: 'cm-skill-evolution' });
+            const evolver = new skill_evolver_1.SkillEvolver(opts.project, backend);
+            const result = evolver.evolveFromAdvisory(handoff);
+            console.log((0, skill_evolver_1.formatEvolutionResult)(result));
+        }
+        catch (err) {
+            console.error(`❌ Auto-evolve failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    evolve
+        .command('history')
+        .description('Show evolution history')
+        .option('-p, --project <path>', 'Project path', process.cwd())
+        .option('-s, --skill <name>', 'Filter by skill name')
+        .option('-n, --limit <n>', 'Max entries', '20')
+        .action((opts) => {
+        const evolver = new skill_evolver_1.SkillEvolver(opts.project);
+        const history = evolver.getHistory(opts.skill, parseInt(opts.limit));
+        console.log((0, skill_evolver_1.formatEvolutionHistory)(history));
+    });
+    evolve
+        .command('rollback <skill>')
+        .description('Rollback a skill to its pre-evolution backup')
+        .option('-p, --project <path>', 'Project path', process.cwd())
+        .action((skill, opts) => {
+        const evolver = new skill_evolver_1.SkillEvolver(opts.project);
+        const result = evolver.rollback(skill);
+        console.log((0, skill_evolver_1.formatEvolutionResult)(result));
+    });
+    // ─── Learning Promotion ─────────────────────────────────────────────────
+    evolve
+        .command('candidates')
+        .description('Show learnings that qualify for promotion to skills')
+        .option('-p, --project <path>', 'Project path', process.cwd())
+        .action((opts) => {
+        const promoter = new learning_promoter_1.LearningPromoter(opts.project);
+        const candidates = promoter.findCandidates();
+        console.log((0, learning_promoter_1.formatPromotionCandidates)(candidates));
+    });
+    evolve
+        .command('promote <learningId>')
+        .description('Promote a specific learning to a reusable skill')
+        .option('-p, --project <path>', 'Project path', process.cwd())
+        .action((learningId, opts) => {
+        const promoter = new learning_promoter_1.LearningPromoter(opts.project);
+        const result = promoter.promote(learningId);
+        const icon = result.promoted ? '✅' : '❌';
+        console.log(`${icon} ${result.reason}`);
+        if (result.promoted) {
+            console.log(`   Skill: ${result.skillName}`);
+            console.log(`   Path:  ${result.skillPath}`);
+        }
+    });
+    evolve
+        .command('auto-promote')
+        .description('Auto-promote the top learning candidate to a skill')
+        .option('-p, --project <path>', 'Project path', process.cwd())
+        .action((opts) => {
+        const promoter = new learning_promoter_1.LearningPromoter(opts.project);
+        const result = promoter.autoPromote();
+        if (!result) {
+            console.log('📚 No learnings qualify for auto-promotion yet.');
+            return;
+        }
+        const icon = result.promoted ? '✅' : '❌';
+        console.log(`${icon} ${result.reason}`);
+    });
+}

package/dist/cli/commands/mcp-serve.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMcpServeCommands = registerMcpServeCommands;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+function registerMcpServeCommands(program) {
+    program
+        .command('mcp-serve')
+        .description('Start CodyMaster MCP context server (stdio transport for Goose, Claude Desktop, etc.)')
+        .option('--project <path>', 'Project root directory (default: current working directory)')
+        .option('--print-config', 'Print Goose/Claude Desktop JSON config snippet and exit')
+        .option('--install-claude', 'Auto-install MCP servers into Claude Desktop / Cowork config')
+        .action((opts) => {
+        var _a;
+        const projectPath = path_1.default.resolve((_a = opts.project) !== null && _a !== void 0 ? _a : process.cwd());
+        if (opts.installClaude) {
+            let configPath = '';
+            if (process.platform === 'win32') {
+                configPath = path_1.default.join(process.env.APPDATA || '', 'Claude', 'claude_desktop_config.json');
+            }
+            else if (process.platform === 'darwin') {
+                configPath = path_1.default.join(os_1.default.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+            }
+            else {
+                console.error(chalk_1.default.red('Auto-install is currently only supported on Windows and macOS.'));
+                process.exit(1);
+            }
+            let config = {};
+            if (fs_1.default.existsSync(configPath)) {
+                try {
+                    config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                }
+                catch (e) {
+                    console.error(chalk_1.default.red(`Failed to parse ${configPath}: ${e.message}`));
+                    process.exit(1);
+                }
+            }
+            if (!config.mcpServers)
+                config.mcpServers = {};
+            const serverPath = path_1.default.join(__dirname, '..', '..', '..', 'dist', 'mcp-context-server.js');
+            const dashboardPath = path_1.default.join(__dirname, '..', '..', '..', 'scripts', 'mcp-bridge.js');
+            config.mcpServers['cm-context'] = {
+                command: process.execPath,
+                args: [serverPath, '--project', projectPath],
+                env: { 'CM_PROJECT_PATH': projectPath }
+            };
+            config.mcpServers['cm-dashboard'] = {
+                command: process.execPath,
+                args: [dashboardPath]
+            };
+            const configDir = path_1.default.dirname(configPath);
+            if (!fs_1.default.existsSync(configDir))
+                fs_1.default.mkdirSync(configDir, { recursive: true });
+            fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+            console.log(chalk_1.default.green(`🎉 Installed successfully into Claude Desktop: ${configPath}`));
+            process.exit(0);
+        }
+        if (opts.printConfig) {
+            const gooseConfig = {
+                id: 'codymaster',
+                name: 'CodyMaster Intelligence Layer',
+                type: 'stdio',
+                cmd: 'npx',
+                args: ['codymaster', 'mcp-serve', '--project', projectPath],
+            };
+            const claudeConfig = {
+                mcpServers: {
+                    'cm-context': {
+                        command: process.execPath,
+                        args: [
+                            path_1.default.join(__dirname, '..', '..', '..', 'dist', 'mcp-context-server.js'),
+                            '--project',
+                            projectPath,
+                        ],
+                    },
+                },
+            };
+            console.log(chalk_1.default.bold('\nGoose config (add to ~/.config/goose/config.yaml extensions):'));
+            console.log(JSON.stringify(gooseConfig, null, 2));
+            console.log(chalk_1.default.bold('\nClaude Desktop config (add to mcpServers in claude_desktop_config.json):'));
+            console.log(JSON.stringify(claudeConfig.mcpServers, null, 2));
+            process.exit(0);
+        }
+        const serverPath = path_1.default.join(__dirname, '..', '..', '..', 'dist', 'mcp-context-server.js');
+        if (!fs_1.default.existsSync(serverPath)) {
+            console.error(chalk_1.default.red(`Error: MCP server not found at ${serverPath}`));
+            console.error(chalk_1.default.yellow('Run `npm run build` first to compile the server.'));
+            process.exit(1);
+        }
+        console.error(chalk_1.default.dim(`[CodyMaster] Starting MCP server for project: ${projectPath}`));
+        const child = (0, child_process_1.spawn)(process.execPath, [serverPath, '--project', projectPath], {
+            stdio: 'inherit',
+        });
+        child.on('exit', (code) => process.exit(code !== null && code !== void 0 ? code : 0));
+        process.on('SIGINT', () => child.kill('SIGINT'));
+        process.on('SIGTERM', () => child.kill('SIGTERM'));
+    });
+}