codymaster 5.2.0 → 7.0.0

package/dist/cli/commands/parallel.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * cm parallel — Execute tasks in parallel using Gemini CLI
+ *
+ * TRIZ Principle #1 (Segmentation):
+ *   Split task into independent subtasks, run in parallel.
+ *
+ * TRIZ Principle #15 (Dynamicity):
+ *   Adapt batch size based on task complexity.
+ */
+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.registerParallelCommands = registerParallelCommands;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const box_1 = require("../../ui/box");
+function registerParallelCommands(program) {
+    program
+        .command('parallel <task>')
+        .description('Execute task in parallel using Gemini CLI')
+        .option('-n, --count <n>', 'Number of parallel instances', '3')
+        .option('-c, --context <files>', 'Context files to include (comma-separated)')
+        .option('-m, --model <model>', 'Gemini model to use', 'gemini-2.0-flash')
+        .option('--timeout <ms>', 'Timeout per instance in milliseconds', '120000')
+        .action((task, opts) => __awaiter(this, void 0, void 0, function* () {
+        const count = parseInt(opts.count, 10);
+        const timeout = parseInt(opts.timeout, 10);
+        console.log((0, box_1.renderCommandHeader)('Parallel Execution', '⚡'));
+        console.log(chalk_1.default.dim(`  Task: ${task}`));
+        console.log(chalk_1.default.dim(`  Instances: ${count}`));
+        console.log(chalk_1.default.dim(`  Model: ${opts.model}`));
+        console.log('');
+        // Check if gemini CLI is available
+        const geminiAvailable = yield checkGeminiCli();
+        if (!geminiAvailable) {
+            console.log(chalk_1.default.yellow('⚠ Gemini CLI not found. Falling back to single-agent execution.'));
+            console.log(chalk_1.default.dim('Install: npm install -g @anthropic-ai/gemini-cli'));
+            console.log('');
+            yield executeSingleAgent(task, opts);
+            return;
+        }
+        // Execute in parallel
+        const results = yield executeParallel(task, count, opts);
+        // Display results
+        console.log(chalk_1.default.bold('\n📊 Results:\n'));
+        for (const result of results) {
+            const status = result.exitCode === 0 ? chalk_1.default.green('✅') : chalk_1.default.red('❌');
+            console.log(`  ${status} Instance ${result.instance}: exit=${result.exitCode}`);
+            if (result.output) {
+                console.log(chalk_1.default.dim(`     ${result.output.slice(0, 100)}...`));
+            }
+        }
+        // Summary
+        const passed = results.filter(r => r.exitCode === 0).length;
+        const failed = results.filter(r => r.exitCode !== 0).length;
+        console.log('');
+        console.log(chalk_1.default.bold(`  Summary: ${chalk_1.default.green(`${passed} passed`)} / ${chalk_1.default.red(`${failed} failed`)}`));
+    }));
+}
+function checkGeminiCli() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)('which', ['gemini'], { stdio: 'pipe' });
+            proc.on('close', (code) => resolve(code === 0));
+            proc.on('error', () => resolve(false));
+        });
+    });
+}
+function executeParallel(task, count, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = [];
+        const promises = [];
+        for (let i = 1; i <= count; i++) {
+            promises.push(executeInstance(task, i, opts));
+        }
+        return Promise.all(promises);
+    });
+}
+function executeInstance(task, instance, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            const args = [
+                '-p', `Instance ${instance}: ${task}`,
+                '--model', opts.model,
+            ];
+            if (opts.context) {
+                args.push('--context', opts.context);
+            }
+            const proc = (0, child_process_1.spawn)('gemini', args, {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                timeout: parseInt(opts.timeout, 10),
+            });
+            let output = '';
+            let error = '';
+            proc.stdout.on('data', (data) => {
+                output += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                error += data.toString();
+            });
+            proc.on('close', (code) => {
+                resolve({
+                    instance,
+                    exitCode: code,
+                    output: output.trim(),
+                    error: error.trim(),
+                });
+            });
+            proc.on('error', (err) => {
+                resolve({
+                    instance,
+                    exitCode: 1,
+                    output: '',
+                    error: err.message,
+                });
+            });
+        });
+    });
+}
+function executeSingleAgent(task, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(chalk_1.default.dim('  Executing with single agent...'));
+        // Fallback: just print the task for the AI agent to handle
+        console.log(chalk_1.default.bold(`  Task: ${task}`));
+        console.log(chalk_1.default.dim('  (Single-agent mode — use Gemini CLI for parallel execution)'));
+    });
+}

package/dist/cli/commands/quality.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * `cm quality` — Vibecoding Index CLI.
+ *
+ * Reads .cm/handoff/{plan,exec,review,quality}.json (when present) plus
+ * git-derived signals to estimate the five Vibecoding components, then
+ * prints a score 0–100 with advice.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerQualityCommands = registerQualityCommands;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const vibecoding_index_1 = require("../../vibecoding-index");
+function isMode(s) {
+    return s === 'OFF' || s === 'WARNING' || s === 'SOFT' || s === 'FULL';
+}
+function parseFraction(v, fallback) {
+    if (!v)
+        return fallback;
+    const n = Number(v);
+    if (Number.isNaN(n))
+        return fallback;
+    if (n > 1)
+        return Math.min(1, n / 100);
+    return Math.max(0, Math.min(1, n));
+}
+function deriveFromHandoff(projectPath) {
+    var _a, _b, _c;
+    const dir = path_1.default.join(projectPath, '.cm', 'handoff');
+    if (!fs_1.default.existsSync(dir))
+        return {};
+    const out = {};
+    // intent — from intent.json or plan.json presence
+    if (fs_1.default.existsSync(path_1.default.join(dir, 'plan.json')))
+        out.intent = 0.85;
+    else if (fs_1.default.existsSync(path_1.default.join(dir, 'intent.json')))
+        out.intent = 0.65;
+    // context — handoff chain length proxy
+    const present = ['intent.json', 'plan.json', 'exec.json', 'review.json']
+        .filter((f) => fs_1.default.existsSync(path_1.default.join(dir, f))).length;
+    if (present > 0)
+        out.context = Math.min(1, present / 4);
+    // tests — from quality.json
+    try {
+        const q = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, 'quality.json'), 'utf8'));
+        if (typeof ((_a = q === null || q === void 0 ? void 0 : q.data) === null || _a === void 0 ? void 0 : _a.coverage_pct) === 'number') {
+            out.tests = Math.max(0, Math.min(1, q.data.coverage_pct / 100));
+        }
+        else if (((_b = q === null || q === void 0 ? void 0 : q.data) === null || _b === void 0 ? void 0 : _b.tests_passed) === true) {
+            out.tests = 0.7;
+        }
+    }
+    catch ( /* missing or malformed */_d) { /* missing or malformed */ }
+    // review — from review.json
+    try {
+        const r = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, 'review.json'), 'utf8'));
+        if (Array.isArray((_c = r === null || r === void 0 ? void 0 : r.data) === null || _c === void 0 ? void 0 : _c.findings))
+            out.review = 0.8;
+    }
+    catch ( /* none */_e) { /* none */ }
+    return out;
+}
+function registerQualityCommands(program) {
+    const quality = program.command('quality').description('Vibecoding Index — score 0..100 for the current change');
+    quality
+        .command('score')
+        .description('compute and print the Vibecoding Index')
+        .option('--mode <mode>', 'OFF|WARNING|SOFT|FULL', 'WARNING')
+        .option('--intent <n>', 'override intent score (0..1 or 0..100)')
+        .option('--ownership <n>', 'override ownership score (0..1 or 0..100)')
+        .option('--context <n>', 'override context score (0..1 or 0..100)')
+        .option('--tests <n>', 'override tests score (0..1 or 0..100)')
+        .option('--review <n>', 'override review score (0..1 or 0..100)')
+        .option('--json', 'print raw JSON')
+        .action((opts) => {
+        var _a, _b, _c, _d, _e, _f;
+        const cwd = process.cwd();
+        const derived = deriveFromHandoff(cwd);
+        const inputs = {
+            intent: parseFraction(opts.intent, (_a = derived.intent) !== null && _a !== void 0 ? _a : 0.5),
+            ownership: parseFraction(opts.ownership, (_b = derived.ownership) !== null && _b !== void 0 ? _b : 0.6),
+            context: parseFraction(opts.context, (_c = derived.context) !== null && _c !== void 0 ? _c : 0.4),
+            tests: parseFraction(opts.tests, (_d = derived.tests) !== null && _d !== void 0 ? _d : 0.4),
+            review: parseFraction(opts.review, (_e = derived.review) !== null && _e !== void 0 ? _e : 0.4),
+        };
+        const result = (0, vibecoding_index_1.computeVibeIndex)(inputs);
+        const mode = isMode(String((_f = opts.mode) !== null && _f !== void 0 ? _f : '').toUpperCase())
+            ? String(opts.mode).toUpperCase()
+            : 'WARNING';
+        const outcome = (0, vibecoding_index_1.applyVibeMode)(result, mode);
+        if (opts.json) {
+            process.stdout.write(JSON.stringify({ outcome }, null, 2) + '\n');
+        }
+        else {
+            process.stdout.write((0, vibecoding_index_1.formatVibeReport)(result) + '\n');
+            if (outcome.message)
+                process.stdout.write(outcome.message + '\n');
+        }
+        if (outcome.status === 'block')
+            process.exit(1);
+    });
+}

package/dist/cli/commands/stack.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * `cm stack` — detect ecosystems/frameworks and emit .cm/project-skills.md.
+ * `cm tier`  — classify project size tier and emit .cm/project-tier.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStackCommands = registerStackCommands;
+const stack_detect_1 = require("../../indexer/stack-detect");
+const tier_classify_1 = require("../../tier-classify");
+function registerStackCommands(program) {
+    const stack = program.command('stack').description('Detect project stack and suggest skills');
+    stack
+        .command('detect')
+        .description('scan the current project and print suggestions')
+        .option('--write', 'write report to .cm/project-skills.md')
+        .option('--json', 'print raw JSON')
+        .action((opts) => {
+        const r = (0, stack_detect_1.detectStack)(process.cwd());
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(r, null, 2) + '\n');
+        }
+        else {
+            process.stdout.write((0, stack_detect_1.renderStackMarkdown)(r));
+        }
+        if (opts.write) {
+            const file = (0, stack_detect_1.writeProjectSkills)(process.cwd(), r);
+            process.stdout.write(`\nWrote ${file}\n`);
+        }
+    });
+    const tier = program.command('tier').description('Classify project tier (LITE/STANDARD/PROFESSIONAL/ENTERPRISE)');
+    tier
+        .command('classify')
+        .description('measure and classify the current project')
+        .option('--write', 'write report to .cm/project-tier.md')
+        .option('--json', 'print raw JSON')
+        .action((opts) => {
+        const r = (0, tier_classify_1.classifyProject)(process.cwd());
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(r, null, 2) + '\n');
+        }
+        else {
+            process.stdout.write((0, tier_classify_1.renderTierMarkdown)(r));
+        }
+        if (opts.write) {
+            const file = (0, tier_classify_1.writeTierReport)(process.cwd(), r);
+            process.stdout.write(`\nWrote ${file}\n`);
+        }
+    });
+}

package/dist/cli/commands/update.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * cm update — Unified update command for CodyMaster
+ *
+ * TRIZ Principle #15 (Dynamicity):
+ *   Adapt update behavior based on flags.
+ *
+ * TRIZ Principle #40 (Composite):
+ *   Combine sync + changelog + version check in one command.
+ */
+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.registerUpdateCommands = registerUpdateCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const box_1 = require("../../ui/box");
+const repoRoot = path_1.default.join(__dirname, '..', '..', '..');
+const pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(repoRoot, 'package.json'), 'utf-8'));
+function registerUpdateCommands(program) {
+    program
+        .command('update')
+        .description('Update CodyMaster skills, changelog, and check for upgrades')
+        .option('-s, --sync', 'Sync skills to all platforms')
+        .option('-c, --changelog', 'Update CHANGELOG.md from git commits')
+        .option('--check', 'Check for available updates')
+        .option('-f, --full', 'Full update (sync + changelog)')
+        .option('--dry-run', 'Show what would be done without making changes')
+        .action((opts) => __awaiter(this, void 0, void 0, function* () {
+        console.log((0, box_1.renderCommandHeader)('CodyMaster Update', '🔄'));
+        // Default: full update if no flags
+        if (!opts.sync && !opts.changelog && !opts.check) {
+            opts.full = true;
+        }
+        // Check for updates
+        if (opts.check) {
+            yield checkForUpdates();
+            return;
+        }
+        // Sync skills
+        if (opts.sync || opts.full) {
+            yield syncSkills(opts.dryRun);
+        }
+        // Update changelog
+        if (opts.changelog || opts.full) {
+            yield updateChangelog(opts.dryRun);
+        }
+        // Summary
+        console.log('');
+        console.log(chalk_1.default.green('  ✅ Update complete!'));
+        console.log('');
+    }));
+    // ─── Upgrade Command ─────────────────────────────────────────
+    program
+        .command('upgrade')
+        .description('Upgrade CodyMaster package and sync skills')
+        .option('--dry-run', 'Show what would be done without making changes')
+        .action((opts) => __awaiter(this, void 0, void 0, function* () {
+        console.log((0, box_1.renderCommandHeader)('CodyMaster Upgrade', '⬆️'));
+        if (opts.dryRun) {
+            console.log(chalk_1.default.dim('  [DRY RUN] Would run: npm update -g codymaster'));
+            console.log(chalk_1.default.dim('  [DRY RUN] Would run: cm update --full'));
+            return;
+        }
+        // Step 1: Update package
+        console.log(chalk_1.default.bold('  Step 1: Updating CodyMaster package...'));
+        try {
+            (0, child_process_1.execSync)('npm update -g codymaster', { stdio: 'inherit', cwd: repoRoot });
+            console.log(chalk_1.default.green('  ✅ Package updated'));
+        }
+        catch (error) {
+            console.log(chalk_1.default.yellow('  ⚠️  Package update failed (may already be latest)'));
+        }
+        // Step 2: Sync skills
+        console.log(chalk_1.default.bold('\n  Step 2: Syncing skills...'));
+        yield syncSkills(false);
+        // Step 3: Update changelog
+        console.log(chalk_1.default.bold('\n  Step 3: Updating changelog...'));
+        yield updateChangelog(false);
+        console.log('');
+        console.log(chalk_1.default.green('  ✅ Upgrade complete!'));
+        console.log(chalk_1.default.dim('  Run `cm --version` to verify.'));
+        console.log('');
+    }));
+}
+function checkForUpdates() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(chalk_1.default.bold('\n  Checking for updates...\n'));
+        // Current version
+        console.log(chalk_1.default.dim(`  Current: v${pkg.version}`));
+        // Check npm for latest
+        try {
+            const latest = (0, child_process_1.execSync)('npm view codymaster version', { encoding: 'utf-8' }).trim();
+            console.log(chalk_1.default.dim(`  Latest:  v${latest}`));
+            if (latest !== pkg.version) {
+                console.log(chalk_1.default.yellow(`\n  ⚠️  Update available: v${latest}`));
+                console.log(chalk_1.default.dim('  Run `cm upgrade` to update.'));
+            }
+            else {
+                console.log(chalk_1.default.green('\n  ✅ You are on the latest version.'));
+            }
+        }
+        catch (error) {
+            console.log(chalk_1.default.dim('  Could not check npm registry.'));
+        }
+    });
+}
+function syncSkills(dryRun) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(chalk_1.default.bold('\n  Syncing skills to all platforms...'));
+        if (dryRun) {
+            console.log(chalk_1.default.dim('  [DRY RUN] Would run: node scripts/build-skills.mjs --all-platforms'));
+            return;
+        }
+        try {
+            const output = (0, child_process_1.execSync)('node scripts/build-skills.mjs --all-platforms', {
+                encoding: 'utf-8',
+                cwd: repoRoot,
+                timeout: 60000,
+            });
+            console.log(chalk_1.default.green('  ✅ Skills synced'));
+        }
+        catch (error) {
+            console.log(chalk_1.default.red('  ❌ Sync failed: ' + (error.message || 'Unknown error')));
+        }
+    });
+}
+function updateChangelog(dryRun) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(chalk_1.default.bold('\n  Updating changelog...'));
+        if (dryRun) {
+            console.log(chalk_1.default.dim('  [DRY RUN] Would run: bash scripts/update-changelog.sh'));
+            return;
+        }
+        try {
+            const output = (0, child_process_1.execSync)('bash scripts/update-changelog.sh', {
+                encoding: 'utf-8',
+                cwd: repoRoot,
+                timeout: 30000,
+            });
+            console.log(chalk_1.default.green('  ✅ Changelog updated'));
+        }
+        catch (error) {
+            console.log(chalk_1.default.red('  ❌ Changelog update failed: ' + (error.message || 'Unknown error')));
+        }
+    });
+}

package/dist/cli/update-check.js

@@ -12,18 +12,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._updateMessage = void 0;
+exports.VERSION = void 0;
 exports.checkForUpdates = checkForUpdates;
+exports.showUpdateNotification = showUpdateNotification;
+exports.promptForUpgrade = promptForUpgrade;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const https_1 = __importDefault(require("https"));
 const pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(__dirname, '..', '..', 'package.json'), 'utf-8'));
-const VERSION = pkg.version;
-exports._updateMessage = '';
+exports.VERSION = pkg.version;
 /**
  * Checks for updates to CodyMaster on the npm registry.
  * Caches results for 24 hours to avoid frequent network calls.
+ * Returns UpdateInfo if a newer version is available, null otherwise.
  */
 function checkForUpdates() {
     return __awaiter(this, void 0, void 0, function* () {
@@ -41,10 +43,12 @@ function checkForUpdates() {
                     const age = Date.now() - stat.mtimeMs;
                     if (age < 24 * 60 * 60 * 1000) {
                         const cached = fs_1.default.readFileSync(cacheFile, 'utf-8').trim();
-                        if (cached && cached !== VERSION) {
-                            exports._updateMessage = cached;
+                        if (cached && cached !== exports.VERSION) {
+                            return { currentVersion: exports.VERSION, latestVersion: cached };
+                        }
+                        if (!cached || cached === exports.VERSION) {
+                            return null; // up to date
                         }
-                        return;
                     }
                 }
             }
@@ -59,25 +63,105 @@ function checkForUpdates() {
                         clearTimeout(timer);
                         try {
                             const json = JSON.parse(data);
-                            resolve(json.version || VERSION);
+                            resolve(json.version || exports.VERSION);
                         }
                         catch (_a) {
-                            resolve(VERSION);
+                            resolve(exports.VERSION);
                         }
                     });
                 }).on('error', () => { clearTimeout(timer); reject(new Error('fetch failed')); });
             });
             // Cache result
-            if (latestVersion && latestVersion !== VERSION) {
-                exports._updateMessage = latestVersion;
+            if (latestVersion && latestVersion !== exports.VERSION) {
                 fs_1.default.writeFileSync(cacheFile, latestVersion);
+                return { currentVersion: exports.VERSION, latestVersion };
             }
             else {
                 fs_1.default.writeFileSync(cacheFile, '');
+                return null;
             }
         }
         catch (e) {
             // Silent failure for update checks
+            return null;
         }
     });
 }
+/**
+ * Display update notification with upgrade prompt.
+ * Shows a colored banner and optionally prompts for upgrade.
+ */
+function showUpdateNotification(info) {
+    const chalk = require('chalk');
+    console.log('');
+    console.log(chalk.yellow('  ┌──────────────────────────────────────────────┐'));
+    console.log(chalk.yellow('  │ ') + chalk.bold('Update available!') + `  v${info.currentVersion} → v${info.latestVersion}` + chalk.yellow('  │'));
+    console.log(chalk.yellow('  │ ') + chalk.dim('Run `cm upgrade` to update') + chalk.yellow('                      │'));
+    console.log(chalk.yellow('  └──────────────────────────────────────────────┘'));
+    console.log('');
+}
+/**
+ * Show update notification and optionally prompt for upgrade.
+ * Respects CM_NO_UPDATE_CHECK env var to skip entirely.
+ * Only prompts in TTY environments (not pipes/CI).
+ */
+function promptForUpgrade(info) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Skip if user disabled it
+        if (process.env.CM_NO_UPDATE_CHECK === '1' || process.env.CM_NO_UPDATE_CHECK === 'true') {
+            return;
+        }
+        // Skip if not a TTY (piped, CI, etc.)
+        if (!process.stdin.isTTY) {
+            showUpdateNotification(info);
+            return;
+        }
+        // Only prompt for interactive commands (not help, version, or help subcommands)
+        const args = process.argv.slice(2);
+        const skipPrompts = args.includes('--help') || args.includes('-h') || args.includes('--version') || args.includes('-V');
+        if (skipPrompts) {
+            return;
+        }
+        const chalk = require('chalk');
+        const readline = require('readline');
+        console.log('');
+        console.log(chalk.yellow('  ┌──────────────────────────────────────────────┐'));
+        console.log(chalk.yellow('  │ ') + chalk.bold('Update available!') + `  v${info.currentVersion} → v${info.latestVersion}` + chalk.yellow('  │'));
+        console.log(chalk.yellow('  └──────────────────────────────────────────────┘'));
+        console.log('');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question(chalk.bold('  Upgrade now?') + chalk.dim(' (y/N) '), (answer) => {
+                rl.close();
+                const choice = (answer || '').trim().toLowerCase();
+                if (choice === 'y' || choice === 'yes') {
+                    console.log('');
+                    console.log(chalk.dim('  Running cm upgrade...'));
+                    console.log('');
+                    const { execSync } = require('child_process');
+                    try {
+                        execSync('npm update -g codymaster', { stdio: 'inherit', timeout: 60000 });
+                        console.log('');
+                        console.log(chalk.green('  ✅ Upgrade complete! Restart your shell or run:'));
+                        console.log(chalk.dim('    hash -r'));
+                        console.log('');
+                    }
+                    catch (err) {
+                        console.log('');
+                        console.log(chalk.red('  ❌ Upgrade failed. Try manually:'));
+                        console.log(chalk.dim('    npm install -g codymaster@latest'));
+                        console.log('');
+                    }
+                }
+                else {
+                    console.log(chalk.dim('  Skipped. Run `cm upgrade` when ready.'));
+                    console.log('');
+                }
+                resolve();
+            });
+        });
+    });
+}

package/dist/continuity.js

@@ -21,6 +21,7 @@ const path_1 = __importDefault(require("path"));
 const crypto_1 = __importDefault(require("crypto"));
 const l0_indexer_1 = require("./l0-indexer");
 const token_budget_1 = require("./token-budget");
+const learnings_1 = require("./learnings");
 // ─── Constants ──────────────────────────────────────────────────────────────
 const CM_DIR = '.cm';
 const CONTINUITY_FILE = 'CONTINUITY.md';
@@ -237,7 +238,8 @@ ${state.workingContext || '[No additional context]'}
 ${state.filesModified.length > 0
         ? state.filesModified.map(f => `- ${f.path}: ${f.change}`).join('\n')
         : '- [No files being modified]'}
-`;
+
+${(0, learnings_1.renderLearningsForContinuity)(projectPath, 10)}`;
     fs_1.default.writeFileSync(filePath, content, 'utf-8');
 }
 // ─── Learnings Management ───────────────────────────────────────────────────