codymaster 4.5.4 → 4.8.0

package/dist/cli/commands/design-studio.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDesignStudioArtifacts = initDesignStudioArtifacts;
+exports.registerDesignStudioCommands = registerDesignStudioCommands;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+function projectPath(opt) {
+    return path_1.default.resolve(opt || process.cwd());
+}
+const CHECKLIST = `# Design studio — checklist
+
+- [ ] Problem / JTBD one-liner
+- [ ] 2–3 UI variants named (A/B/C)
+- [ ] Chosen variant + rationale
+- [ ] Handoff block filled in HANDOFF.md
+`;
+const VARIANTS = `# Variants
+
+| Id | Name | Notes |
+|----|------|-------|
+| A  |      |       |
+| B  |      |       |
+| C  |      |       |
+`;
+const HANDOFF = `# Handoff to implementation
+
+**Chosen variant:** (A/B/C)
+
+**Screens / flows:**
+
+**Tokens / components to reuse:**
+
+**Out of scope:**
+
+**Agent prompt stub:**
+
+\`\`\`
+Implement the chosen variant using existing design system tokens. …
+\`\`\`
+`;
+const README = `# .cm/design-studio
+
+Local artifact folder for **cm-design-studio**: variants, checklist, handoff.
+
+Happy path:
+
+1. \`cm design-studio init\`
+2. Edit CHECKLIST.md + VARIANTS.md
+3. Fill HANDOFF.md, then run your build skill (e.g. cm-execution) with that stub.
+`;
+/** Writes default artifact files; skips paths that already exist. Returns created + skipped counts. */
+function initDesignStudioArtifacts(root) {
+    const base = path_1.default.join(root, '.cm', 'design-studio');
+    fs_1.default.mkdirSync(base, { recursive: true });
+    const files = [
+        ['README.md', README],
+        ['CHECKLIST.md', CHECKLIST],
+        ['VARIANTS.md', VARIANTS],
+        ['HANDOFF.md', HANDOFF],
+    ];
+    let created = 0;
+    let skipped = 0;
+    for (const [name, body] of files) {
+        const p = path_1.default.join(base, name);
+        if (fs_1.default.existsSync(p)) {
+            skipped++;
+        }
+        else {
+            fs_1.default.writeFileSync(p, body, 'utf8');
+            created++;
+        }
+    }
+    return { created, skipped };
+}
+function registerDesignStudioCommands(program) {
+    const ds = program
+        .command('design-studio')
+        .description('Design variant workspace under .cm/design-studio');
+    ds.command('init')
+        .description('Create .cm/design-studio with checklist and handoff templates')
+        .option('--project <dir>', 'project root', process.cwd())
+        .action((opts) => {
+        const root = projectPath(opts.project);
+        const { created, skipped } = initDesignStudioArtifacts(root);
+        const base = path_1.default.join(root, '.cm', 'design-studio');
+        if (created)
+            console.log(chalk_1.default.green(`wrote ${created} file(s) under`), base);
+        if (skipped)
+            console.log(chalk_1.default.yellow(`skipped ${skipped} existing`));
+    });
+    ds.command('status')
+        .description('List design-studio artifact files if present')
+        .option('--project <dir>', 'project root', process.cwd())
+        .action((opts) => {
+        const root = projectPath(opts.project);
+        const base = path_1.default.join(root, '.cm', 'design-studio');
+        if (!fs_1.default.existsSync(base)) {
+            console.log(chalk_1.default.yellow('Not initialized. Run:'), chalk_1.default.cyan('cm design-studio init'));
+            return;
+        }
+        for (const f of fs_1.default.readdirSync(base)) {
+            const p = path_1.default.join(base, f);
+            const st = fs_1.default.statSync(p);
+            console.log(st.isDirectory() ? `${f}/` : f);
+        }
+    });
+}

package/dist/cli/commands/distro.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDistroCommands = registerDistroCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const distro_validate_1 = require("../../distro-validate");
+function registerDistroCommands(program) {
+    const distro = program.command('distro').description('Skill pack validation (ecosystem roadmap)');
+    distro
+        .command('validate')
+        .description('Validate a skill directory (SKILL.md / tmpl + optional meta.json)')
+        .argument('<dir>', 'path to skill folder')
+        .action((dir) => {
+        const r = (0, distro_validate_1.validateSkillPackDir)(dir);
+        for (const w of r.warnings)
+            console.log(chalk_1.default.yellow('warning:'), w);
+        for (const e of r.errors)
+            console.error(chalk_1.default.red('error:'), e);
+        if (!r.ok)
+            process.exit(1);
+        console.log(chalk_1.default.green('OK'), dir);
+    });
+}

package/dist/cli/commands/engineering.js

@@ -0,0 +1,488 @@
+"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.registerEngineeringCommands = registerEngineeringCommands;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const http_1 = __importDefault(require("http"));
+const chalk_1 = __importDefault(require("chalk"));
+const browse_server_1 = require("../../browse-server");
+const guardian_core_1 = require("../../guardian-core");
+const cm_config_1 = require("../../cm-config");
+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");
+function projectPath(opt) {
+    return path_1.default.resolve(opt || process.cwd());
+}
+function registerEngineeringCommands(program) {
+    const browse = program.command('browse').description('Playwright browse daemon (local QA / screenshots)');
+    browse
+        .command('start')
+        .option('-p, --port <n>', 'port (default: .cm/config.yaml browse.port or 17395)')
+        .option('-H, --host <h>', 'bind host (default: config or 127.0.0.1)')
+        .option('--token <t>', 'bearer token (or env CM_BROWSE_TOKEN or config browse.token)')
+        .option('--headed', 'headed browser', false)
+        .action((opts) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const root = process.cwd();
+        const cfg = (0, cm_config_1.loadCmConfig)(root);
+        const port = parseInt(String((_c = (_a = opts.port) !== null && _a !== void 0 ? _a : (_b = cfg.browse) === null || _b === void 0 ? void 0 : _b.port) !== null && _c !== void 0 ? _c : 17395), 10);
+        const host = String((_f = (_d = opts.host) !== null && _d !== void 0 ? _d : (_e = cfg.browse) === null || _e === void 0 ? void 0 : _e.host) !== null && _f !== void 0 ? _f : '127.0.0.1');
+        const token = opts.token ||
+            process.env.CM_BROWSE_TOKEN ||
+            ((_g = cfg.browse) === null || _g === void 0 ? void 0 : _g.token) ||
+            'dev-token-change-me';
+        const daemon = new browse_server_1.BrowseDaemon({
+            host,
+            port,
+            token,
+            headless: !opts.headed,
+        });
+        yield daemon.listen();
+        console.log(chalk_1.default.green(`cm-browse listening http://${host}:${port}`));
+        console.log(chalk_1.default.dim(`Authorization: Bearer ${token.slice(0, 8)}…`));
+        console.log(chalk_1.default.dim('POST /session/start, /navigate, /refs/refresh, /click, /fill, GET /screenshot'));
+        process.on('SIGINT', () => __awaiter(this, void 0, void 0, function* () {
+            yield daemon.close();
+            process.exit(0);
+        }));
+    }));
+    const guardian = program.command('guardian').description('Runtime safety: destructive command patterns + path freeze');
+    guardian
+        .command('check')
+        .argument('<cmd...>', 'shell command to check')
+        .action((parts) => {
+        var _a;
+        const cmd = parts.join(' ');
+        const cfg = (0, cm_config_1.loadCmConfig)(process.cwd());
+        const extra = (_a = cfg.guardian) === null || _a === void 0 ? void 0 : _a.whitelist_prefixes;
+        const r = (0, guardian_core_1.checkShellCommand)(cmd, (extra === null || extra === void 0 ? void 0 : extra.length) ? { extraWhitelist: extra } : undefined);
+        if (!r.safe) {
+            console.error(chalk_1.default.red('BLOCKED:'), r.reason);
+            console.error(chalk_1.default.dim('Pattern:'), r.matchedPattern);
+            (0, guardian_core_1.appendGuardianLog)(process.cwd(), `BLOCKED: ${cmd}`);
+            process.exit(1);
+        }
+        console.log(chalk_1.default.green('OK'), chalk_1.default.dim(cmd));
+    });
+    guardian
+        .command('path-check')
+        .requiredOption('--file <f>', 'file path')
+        .option('--roots <r>', 'comma-separated roots (default: config guardian.freeze_roots or src,lib)')
+        .action((opts) => {
+        var _a, _b, _c;
+        const cwd = process.cwd();
+        const cfg = (0, cm_config_1.loadCmConfig)(cwd);
+        const rootsCsv = (_a = opts.roots) !== null && _a !== void 0 ? _a : (((_c = (_b = cfg.guardian) === null || _b === void 0 ? void 0 : _b.freeze_roots) === null || _c === void 0 ? void 0 : _c.length) ? cfg.guardian.freeze_roots.join(',') : 'src,lib');
+        const roots = (0, guardian_core_1.normalizeRoots)(cwd, String(rootsCsv)
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean));
+        const ok = (0, guardian_core_1.isPathUnderRoots)(opts.file, roots);
+        if (!ok) {
+            console.error(chalk_1.default.red('Path outside freeze roots:'), opts.file);
+            (0, guardian_core_1.appendGuardianLog)(cwd, `FREEZE_VIOLATION: ${opts.file}`);
+            process.exit(1);
+        }
+        console.log(chalk_1.default.green('OK'), opts.file);
+    });
+    const sprint = program.command('sprint').description('Opinionated pipeline + .cm/sprint Context Bus');
+    sprint
+        .command('init')
+        .option('--project <dir>')
+        .option('--from <step>', `one of: ${sprint_pipeline_1.SPRINT_STEPS.join(',')}`)
+        .action((opts) => {
+        const root = projectPath(opts.project);
+        const from = opts.from;
+        if (from && !sprint_pipeline_1.SPRINT_STEPS.includes(from)) {
+            console.error(chalk_1.default.red('Invalid --from'));
+            process.exit(1);
+        }
+        const state = (0, sprint_pipeline_1.initSprint)(root, from);
+        console.log(chalk_1.default.green('Sprint initialized'));
+        console.log(chalk_1.default.dim(JSON.stringify(state, null, 2)));
+    });
+    sprint
+        .command('status')
+        .option('--project <dir>')
+        .action((opts) => {
+        const root = projectPath(opts.project);
+        const state = (0, sprint_pipeline_1.readSprintState)(root);
+        if (!state) {
+            console.log(chalk_1.default.yellow('No sprint state. Run: cm sprint init'));
+            return;
+        }
+        const next = state.current_index >= state.pipeline.length
+            ? '(done)'
+            : state.pipeline[state.current_index];
+        console.log(chalk_1.default.cyan('Current step:'), next);
+        if (typeof next === 'string' && next !== '(done)')
+            console.log(chalk_1.default.dim('Skill hint:'), (0, sprint_pipeline_1.skillMappingForStep)(next));
+        console.log(chalk_1.default.dim('Completed:'), state.completed.join(', ') || '(none)');
+        console.log(chalk_1.default.dim('Skipped:'), state.skipped.join(', ') || '(none)');
+    });
+    sprint
+        .command('complete')
+        .argument('<step>', 'step name')
+        .option('--project <dir>')
+        .option('-m, --message <text>', 'artifact markdown body', '')
+        .action((step, opts) => {
+        const root = projectPath(opts.project);
+        if (!sprint_pipeline_1.SPRINT_STEPS.includes(step)) {
+            console.error(chalk_1.default.red('Invalid step'));
+            process.exit(1);
+        }
+        const body = opts.message ||
+            `# ${step}\n\n_Completed via \`cm sprint complete\` — replace with real notes._\n`;
+        try {
+            const state = (0, sprint_pipeline_1.completeSprintStep)(root, step, body);
+            console.log(chalk_1.default.green('Step recorded:', step));
+            console.log(chalk_1.default.dim('Next index:', state.current_index));
+        }
+        catch (e) {
+            console.error(chalk_1.default.red(e.message));
+            process.exit(1);
+        }
+    });
+    sprint
+        .command('skip')
+        .argument('[step]', 'step name (default: current step)')
+        .option('--project <dir>')
+        .action((step, opts) => {
+        const root = projectPath(opts.project);
+        const state = (0, sprint_pipeline_1.readSprintState)(root);
+        if (!state) {
+            console.error(chalk_1.default.red('No sprint state. Run: cm sprint init'));
+            process.exit(1);
+        }
+        if (state.current_index >= state.pipeline.length) {
+            console.error(chalk_1.default.red('Sprint pipeline already finished'));
+            process.exit(1);
+        }
+        const current = state.pipeline[state.current_index];
+        const target = (step || current);
+        if (step && !sprint_pipeline_1.SPRINT_STEPS.includes(target)) {
+            console.error(chalk_1.default.red('Invalid step'));
+            process.exit(1);
+        }
+        try {
+            const next = (0, sprint_pipeline_1.skipSprintStep)(root, target);
+            console.log(chalk_1.default.green('Skipped step:', target));
+            console.log(chalk_1.default.dim('Next index:', next.current_index));
+        }
+        catch (e) {
+            console.error(chalk_1.default.red(e.message));
+            process.exit(1);
+        }
+    });
+    sprint
+        .command('reset')
+        .option('--project <dir>')
+        .option('--no-backup', 'do not copy sprint files to .cm/sprint/backup before clearing')
+        .action((opts) => {
+        const root = projectPath(opts.project);
+        const r = (0, sprint_pipeline_1.resetSprint)(root, { backup: opts.backup !== false });
+        if (!r.ok) {
+            console.log(chalk_1.default.yellow('Nothing to reset (no sprint data under .cm/sprint).'));
+            return;
+        }
+        if (r.backupDir)
+            console.log(chalk_1.default.dim('Backup:'), r.backupDir);
+        console.log(chalk_1.default.green('Sprint data cleared. Run: cm sprint init'));
+    });
+    sprint
+        .command('dry-run')
+        .option('--project <dir>')
+        .action((opts) => {
+        const root = projectPath(opts.project);
+        const d = (0, sprint_pipeline_1.sprintDryRun)(root);
+        console.log(chalk_1.default.cyan('Steps:'), d.steps.join(' → '));
+        d.artifacts.forEach((a) => console.log(chalk_1.default.dim(' -'), a));
+    });
+    program
+        .command('second-opinion')
+        .description('Send unified diff to a secondary model (redacts obvious secrets)')
+        .option('--file <f>', 'file containing diff text')
+        .option('--provider <p>', 'openai | anthropic', 'openai')
+        .action((opts) => __awaiter(this, void 0, void 0, function* () {
+        const provider = String(opts.provider || 'openai').toLowerCase();
+        const raw = opts.file ? fs_1.default.readFileSync(opts.file, 'utf8') : '';
+        const text = raw ? (0, second_opinion_providers_1.redactDiffForReview)(raw) : '';
+        if (!opts.file || !text.trim()) {
+            console.log(chalk_1.default.yellow('Pass --file <diff.txt>. Set OPENAI_API_KEY (openai) or ANTHROPIC_API_KEY (anthropic).'));
+            console.log(chalk_1.default.dim('Diff content is redacted for common secret patterns before sending.'));
+            return;
+        }
+        try {
+            let out;
+            if (provider === 'anthropic')
+                out = yield (0, second_opinion_providers_1.reviewWithAnthropic)(text);
+            else if (provider === 'openai')
+                out = yield (0, second_opinion_providers_1.reviewWithOpenAI)(text);
+            else {
+                console.error(chalk_1.default.red('Unknown --provider (use openai or anthropic)'));
+                process.exit(1);
+            }
+            console.log(out);
+        }
+        catch (e) {
+            console.error(chalk_1.default.red(e.message));
+            process.exit(1);
+        }
+    }));
+    program
+        .command('qa-visual')
+        .description('Hit cm-browse for screenshot + health (requires browse running)')
+        .requiredOption('--url <u>', 'page URL to navigate')
+        .option('--port <n>', 'browse daemon port (default: config browse.port or 17395)')
+        .option('--token <t>', 'or env CM_BROWSE_TOKEN or config browse.token')
+        .action((opts) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const cfg = (0, cm_config_1.loadCmConfig)(process.cwd());
+        const token = opts.token || process.env.CM_BROWSE_TOKEN || ((_a = cfg.browse) === null || _a === void 0 ? void 0 : _a.token) || 'dev-token-change-me';
+        const port = parseInt(String((_d = (_b = opts.port) !== null && _b !== void 0 ? _b : (_c = cfg.browse) === null || _c === void 0 ? void 0 : _c.port) !== null && _d !== void 0 ? _d : 17395), 10);
+        const auth = `Bearer ${token}`;
+        yield browseRequest(port, '/session/start', 'POST', auth, { headless: true });
+        yield browseRequest(port, '/navigate', 'POST', auth, { url: opts.url });
+        yield browseRequest(port, '/refs/refresh', 'POST', auth, {});
+        const png = yield browseBuffer(port, '/screenshot', auth);
+        const out = path_1.default.join(process.cwd(), 'cm-qa-visual.png');
+        fs_1.default.writeFileSync(out, png);
+        console.log(chalk_1.default.green('Screenshot saved'), out);
+    }));
+    program
+        .command('canary')
+        .description('Post-deploy smoke: HTTP fetch + optional browse console; baseline compare')
+        .requiredOption('--url <u>', 'URL to fetch (http/https)')
+        .option('--browse-port <n>', 'if set, GET /console from browse (default: config canary.browse_port)')
+        .option('--token <t>', 'browse token (env CM_BROWSE_TOKEN or config)')
+        .option('--save-baseline', 'write .cm/canary-baseline.json after check')
+        .option('--compare-baseline', 'fail on HTTP regression or 2× latency vs baseline')
+        .action((opts) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const root = process.cwd();
+        const cfg = (0, cm_config_1.loadCmConfig)(root);
+        const u = new URL(opts.url);
+        const { status, latency_ms } = yield httpProbeUrl(u.href);
+        if (status >= 400) {
+            console.error(chalk_1.default.red(`HTTP ${status}`), u.href);
+            process.exit(1);
+        }
+        if (opts.compareBaseline) {
+            const baselinePath = path_1.default.join(root, '.cm', 'canary-baseline.json');
+            if (!fs_1.default.existsSync(baselinePath)) {
+                console.error(chalk_1.default.red('No baseline file. Run once with --save-baseline'));
+                process.exit(1);
+            }
+            const prev = JSON.parse(fs_1.default.readFileSync(baselinePath, 'utf8'));
+            if (prev.http_status !== undefined &&
+                prev.http_status < 400 &&
+                status >= 400) {
+                console.error(chalk_1.default.red('HTTP regression vs baseline'));
+                process.exit(1);
+            }
+            if (typeof prev.latency_ms === 'number' &&
+                prev.latency_ms > 50 &&
+                latency_ms > prev.latency_ms * 2) {
+                console.error(chalk_1.default.red(`Latency regression: ${latency_ms}ms vs baseline ${prev.latency_ms}ms`));
+                process.exit(1);
+            }
+            console.log(chalk_1.default.dim('Baseline compare OK'));
+        }
+        if (opts.saveBaseline) {
+            const baselinePath = path_1.default.join(root, '.cm', 'canary-baseline.json');
+            fs_1.default.mkdirSync(path_1.default.dirname(baselinePath), { recursive: true });
+            fs_1.default.writeFileSync(baselinePath, JSON.stringify({
+                url: opts.url,
+                http_status: status,
+                latency_ms,
+                at: new Date().toISOString(),
+            }, null, 2), 'utf8');
+            console.log(chalk_1.default.dim('Wrote'), baselinePath);
+        }
+        console.log(chalk_1.default.green('HTTP OK'), u.href, chalk_1.default.dim(`${status} ${latency_ms}ms`));
+        const browsePort = (_a = opts.browsePort) !== null && _a !== void 0 ? _a : (((_b = cfg.canary) === null || _b === void 0 ? void 0 : _b.browse_port) != null ? String(cfg.canary.browse_port) : undefined);
+        if (browsePort) {
+            const token = opts.token ||
+                process.env.CM_BROWSE_TOKEN ||
+                ((_c = cfg.canary) === null || _c === void 0 ? void 0 : _c.token) ||
+                ((_d = cfg.browse) === null || _d === void 0 ? void 0 : _d.token) ||
+                'dev-token-change-me';
+            const raw = yield browseRaw(parseInt(browsePort, 10), '/console', `Bearer ${token}`);
+            console.log(chalk_1.default.dim('Browse console (last messages):'), raw.slice(0, 500));
+        }
+    }));
+    const conductor = program.command('conductor').description('Git worktree helpers for parallel sprints');
+    conductor
+        .command('add')
+        .requiredOption('--at <dir>', 'new worktree directory')
+        .requiredOption('--branch <b>', 'branch name')
+        .option('--base <b>', 'start from branch', 'main')
+        .action((opts) => {
+        (0, child_process_1.execSync)(`git worktree add -b ${opts.branch} ${opts.at} ${opts.base}`, {
+            stdio: 'inherit',
+            cwd: process.cwd(),
+        });
+        console.log(chalk_1.default.green('Worktree created'));
+    });
+    conductor.command('list').action(() => {
+        (0, child_process_1.execSync)('git worktree list', { stdio: 'inherit', cwd: process.cwd() });
+    });
+    const retro = program
+        .command('retro')
+        .description('Append operational learning (.cm/operational-learnings.jsonl) or print summary');
+    retro
+        .command('summary')
+        .description('Aggregate JSONL by tool; optional --since filter')
+        .option('--project <dir>')
+        .option('--since <iso>', 'include entries on or after this ISO timestamp')
+        .option('--format <f>', 'json | md', 'md')
+        .action((opts) => {
+        const root = projectPath(opts.project);
+        const j = path_1.default.join(root, '.cm', 'operational-learnings.jsonl');
+        let entries = (0, retro_summary_1.loadRetroEntries)(j);
+        if (opts.since)
+            entries = (0, retro_summary_1.filterSince)(entries, opts.since);
+        const byTool = (0, retro_summary_1.countByTool)(entries);
+        const fmt = (opts.format || 'md').toLowerCase();
+        if (fmt === 'json')
+            console.log((0, retro_summary_1.formatRetroJson)(entries, byTool));
+        else
+            console.log((0, retro_summary_1.formatRetroMarkdown)(entries, byTool));
+    });
+    retro
+        .option('--note <text>', 'append entry')
+        .option('--tool <t>', 'tool label', 'cli')
+        .option('--project <dir>')
+        .option('--summary', 'print last 20 lines (legacy quick view)')
+        .action((opts) => {
+        const root = projectPath(opts.project);
+        const dir = path_1.default.join(root, '.cm');
+        if (!fs_1.default.existsSync(dir))
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        const j = path_1.default.join(dir, 'operational-learnings.jsonl');
+        if (opts.summary) {
+            if (!fs_1.default.existsSync(j)) {
+                console.log(chalk_1.default.yellow('No entries yet'));
+                return;
+            }
+            const lines = fs_1.default.readFileSync(j, 'utf8').trim().split('\n').filter(Boolean).slice(-20);
+            for (const line of lines)
+                console.log(line);
+            return;
+        }
+        if (!opts.note) {
+            console.log(chalk_1.default.yellow('Pass --note "...", --summary, or: cm retro summary'));
+            return;
+        }
+        const rec = {
+            ts: new Date().toISOString(),
+            tool: opts.tool,
+            note: opts.note,
+        };
+        fs_1.default.appendFileSync(j, JSON.stringify(rec) + '\n', 'utf8');
+        console.log(chalk_1.default.green('Recorded'));
+    });
+    program
+        .command('suggest')
+        .description('Proactive skill hints from git status + sprint state')
+        .option('--project <dir>')
+        .action((opts) => {
+        const root = projectPath(opts.project);
+        const list = (0, cm_suggest_1.suggestFromContext)(root);
+        if (list.length === 0) {
+            console.log(chalk_1.default.yellow('No strong signals. Try cm-start or cm-planning for the next step.'));
+            return;
+        }
+        for (const s of list) {
+            console.log(chalk_1.default.cyan(s.skill));
+            console.log(chalk_1.default.dim(`  ${s.reason}`));
+        }
+    });
+}
+function browseRequest(port, pathname, method, auth, body) {
+    return new Promise((resolve, reject) => {
+        const data = Buffer.from(JSON.stringify(body));
+        const req = http_1.default.request({
+            hostname: '127.0.0.1',
+            port,
+            path: pathname,
+            method,
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': data.length,
+                Authorization: auth,
+            },
+        }, (res) => {
+            res.resume();
+            if (res.statusCode && res.statusCode >= 400)
+                reject(new Error(`HTTP ${res.statusCode}`));
+            else
+                resolve();
+        });
+        req.on('error', reject);
+        req.write(data);
+        req.end();
+    });
+}
+function browseBuffer(port, pathname, auth) {
+    return new Promise((resolve, reject) => {
+        http_1.default.get({
+            hostname: '127.0.0.1',
+            port,
+            path: pathname,
+            headers: { Authorization: auth },
+        }, (res) => {
+            const chunks = [];
+            res.on('data', (c) => chunks.push(c));
+            res.on('end', () => {
+                if (res.statusCode && res.statusCode >= 400)
+                    reject(new Error(`HTTP ${res.statusCode}`));
+                else
+                    resolve(Buffer.concat(chunks));
+            });
+        }).on('error', reject);
+    });
+}
+function browseRaw(port, pathname, auth) {
+    return new Promise((resolve, reject) => {
+        http_1.default.get({
+            hostname: '127.0.0.1',
+            port,
+            path: pathname,
+            headers: { Authorization: auth },
+        }, (res) => {
+            let s = '';
+            res.on('data', (c) => (s += c));
+            res.on('end', () => {
+                if (res.statusCode && res.statusCode >= 400)
+                    reject(new Error(`HTTP ${res.statusCode}`));
+                else
+                    resolve(s);
+            });
+        }).on('error', reject);
+    });
+}
+function httpProbeUrl(url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const t0 = performance.now();
+        const res = yield fetch(url, { redirect: 'follow' });
+        yield res.arrayBuffer().catch(() => { });
+        const latency_ms = Math.round(performance.now() - t0);
+        return { status: res.status, latency_ms };
+    });
+}