codymaster 4.6.0 → 5.2.0

package/dist/advisory-handoff.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAdvisoryHandoff = buildAdvisoryHandoff;
+exports.formatAdvisoryHandoffMarkdown = formatAdvisoryHandoffMarkdown;
+const execution_analyzer_1 = require("./execution-analyzer");
+function resolveAnalysis(backend, options) {
+    var _a;
+    const analyses = backend.getExecutionAnalyses((_a = options.searchLimit) !== null && _a !== void 0 ? _a : 50);
+    if (analyses.length === 0) {
+        throw new Error('No execution analyses recorded yet.');
+    }
+    if (!options.analysisId)
+        return analyses[0];
+    const match = analyses.find((analysis) => analysis.id.startsWith(options.analysisId));
+    if (!match) {
+        throw new Error(`No advisory analysis found for id prefix: ${options.analysisId}`);
+    }
+    return match;
+}
+function resolveSkillName(analysis, explicitSkill) {
+    var _a;
+    if (explicitSkill)
+        return explicitSkill;
+    return (_a = analysis.skill_judgments.find((judgment) => judgment.selected || judgment.applied)) === null || _a === void 0 ? void 0 : _a.skill;
+}
+function buildNextStep(consumer, action, skill) {
+    const subject = skill !== null && skill !== void 0 ? skill : 'the affected skill';
+    if (consumer === 'cm-skill-health') {
+        return `Run cm-skill-health on ${subject} and confirm whether ${action} is still the truthful recovery path.`;
+    }
+    return `Run cm-skill-evolution in ${action} mode for ${subject} using this advisory evidence as the starting note.`;
+}
+function buildAdvisoryHandoff(backend, options) {
+    var _a, _b;
+    const analysis = resolveAnalysis(backend, options);
+    const skillName = resolveSkillName(analysis, options.skill);
+    const judgment = skillName
+        ? analysis.skill_judgments.find((item) => item.skill === skillName)
+        : undefined;
+    const metric = skillName ? backend.getSkillMetric(skillName) : null;
+    const action = (_a = analysis.recommended_action) !== null && _a !== void 0 ? _a : 'NONE';
+    return {
+        version: 1,
+        generated_at: new Date().toISOString(),
+        consumer: options.consumer,
+        recommendation: {
+            action,
+            confidence: analysis.confidence,
+        },
+        source: {
+            analysis_id: analysis.id,
+            task_title: analysis.task_title,
+            task_status: analysis.status,
+            source_task_type: analysis.source_task_type,
+            created_at: analysis.created_at,
+        },
+        skill: {
+            name: skillName,
+            judgment,
+            metric: metric ? Object.assign(Object.assign({}, metric), { quality_weight: (0, execution_analyzer_1.qualityWeight)(metric) }) : null,
+        },
+        evidence: {
+            summary: analysis.summary,
+            selected_skills: (_b = analysis.selected_skills) !== null && _b !== void 0 ? _b : [],
+            target_skills: analysis.skill_judgments
+                .filter((item) => item.selected || item.applied)
+                .map((item) => item.skill),
+        },
+        next_step: buildNextStep(options.consumer, action, skillName),
+    };
+}
+function formatAdvisoryHandoffMarkdown(handoff) {
+    var _a, _b, _c;
+    return [
+        '## Advisory Handoff',
+        `- Consumer: ${handoff.consumer}`,
+        `- Skill: ${(_a = handoff.skill.name) !== null && _a !== void 0 ? _a : '-'}`,
+        `- Recovery path: ${handoff.recommendation.action}`,
+        `- Confidence: ${(_c = (_b = handoff.recommendation.confidence) === null || _b === void 0 ? void 0 : _b.toFixed(2)) !== null && _c !== void 0 ? _c : '-'}`,
+        `- Source analysis: ${handoff.source.analysis_id}`,
+        `- Task: ${handoff.source.task_title}`,
+        `- Status: ${handoff.source.task_status}`,
+        `- Evidence: ${handoff.evidence.summary}`,
+        `- Selected skills: ${handoff.evidence.selected_skills.join(', ') || '-'}`,
+        `- Target skills: ${handoff.evidence.target_skills.join(', ') || '-'}`,
+        `- Quality weight: ${handoff.skill.metric ? handoff.skill.metric.quality_weight.toFixed(2) : '-'}`,
+        `- Next step: ${handoff.next_step}`,
+    ].join('\n');
+}

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/browse-server.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * Local HTTP browse daemon (Playwright + Express). Bearer auth.
+ * Refs: POST /refs/refresh tags interactive elements with data-cm-ref.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.BrowseDaemon = void 0;
+const express_1 = __importDefault(require("express"));
+function createRing(max) {
+    const buf = [];
+    return {
+        push(item) {
+            buf.push(item);
+            while (buf.length > max)
+                buf.shift();
+        },
+        snapshot: () => [...buf],
+    };
+}
+class BrowseDaemon {
+    constructor(opts) {
+        this.opts = opts;
+        this.app = (0, express_1.default)();
+        this.httpServer = null;
+        this.browser = null;
+        this.context = null;
+        this.page = null;
+        this.consoleBuf = createRing(200);
+        this.networkBuf = createRing(200);
+        this.refMap = {};
+        this.app.use(express_1.default.json({ limit: '2mb' }));
+        this.app.use(this.authMiddleware.bind(this));
+        this.routes();
+    }
+    authMiddleware(req, res, next) {
+        if (req.path === '/health')
+            return next();
+        const h = req.headers.authorization || '';
+        const want = `Bearer ${this.opts.token}`;
+        if (h !== want) {
+            res.status(401).json({ error: 'unauthorized' });
+            return;
+        }
+        next();
+    }
+    routes() {
+        this.app.get('/health', (_req, res) => {
+            res.json({ ok: true, hasPage: !!this.page });
+        });
+        this.app.post('/session/start', (req, res) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            try {
+                const headless = (_c = (_b = (_a = req.body) === null || _a === void 0 ? void 0 : _a.headless) !== null && _b !== void 0 ? _b : this.opts.headless) !== null && _c !== void 0 ? _c : true;
+                const pw = yield Promise.resolve().then(() => __importStar(require('playwright')));
+                this.browser = yield pw.chromium.launch({ headless });
+                this.context = yield this.browser.newContext();
+                this.page = yield this.context.newPage();
+                this.page.on('console', (msg) => {
+                    this.consoleBuf.push({
+                        type: msg.type(),
+                        text: msg.text(),
+                        ts: new Date().toISOString(),
+                    });
+                });
+                this.context.on('response', (response) => {
+                    try {
+                        this.networkBuf.push({
+                            url: response.url(),
+                            method: response.request().method(),
+                            status: response.status(),
+                            ts: new Date().toISOString(),
+                        });
+                    }
+                    catch (_a) {
+                        /* ignore */
+                    }
+                });
+                res.json({ ok: true });
+            }
+            catch (e) {
+                res.status(500).json({ error: e.message });
+            }
+        }));
+        this.app.post('/navigate', (req, res) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const url = (_a = req.body) === null || _a === void 0 ? void 0 : _a.url;
+                if (!url || !this.page) {
+                    res.status(400).json({ error: 'url required and session must be started' });
+                    return;
+                }
+                yield this.page.goto(url, { waitUntil: 'domcontentloaded', timeout: 60000 });
+                res.json({ ok: true, url: this.page.url() });
+            }
+            catch (e) {
+                res.status(500).json({ error: e.message });
+            }
+        }));
+        this.app.post('/refs/refresh', (_req, res) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.page) {
+                    res.status(400).json({ error: 'no session' });
+                    return;
+                }
+                const mapping = yield this.page.evaluate(() => {
+                    const sel = 'a[href],button,input,textarea,select,[role="button"],[onclick]';
+                    const nodes = Array.from(document.querySelectorAll(sel));
+                    const out = {};
+                    nodes.forEach((el, i) => {
+                        const id = `e${i + 1}`;
+                        el.setAttribute('data-cm-ref', id);
+                        const tag = el.tagName.toLowerCase();
+                        const txt = (el.textContent || '').trim().slice(0, 80);
+                        out[id] = `${tag}${txt ? `: ${txt}` : ''}`;
+                    });
+                    return out;
+                });
+                this.refMap = mapping;
+                res.json({ ok: true, refs: mapping });
+            }
+            catch (e) {
+                res.status(500).json({ error: e.message });
+            }
+        }));
+        this.app.post('/click', (req, res) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const ref = (_b = (_a = req.body) === null || _a === void 0 ? void 0 : _a.ref) === null || _b === void 0 ? void 0 : _b.replace(/^@/, '');
+                if (!ref || !this.page) {
+                    res.status(400).json({ error: 'ref required' });
+                    return;
+                }
+                yield this.page.click(`[data-cm-ref="${ref}"]`, { timeout: 15000 });
+                res.json({ ok: true });
+            }
+            catch (e) {
+                res.status(500).json({ error: e.message });
+            }
+        }));
+        this.app.post('/fill', (req, res) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            try {
+                const ref = (_b = (_a = req.body) === null || _a === void 0 ? void 0 : _a.ref) === null || _b === void 0 ? void 0 : _b.replace(/^@/, '');
+                const value = (_c = req.body) === null || _c === void 0 ? void 0 : _c.value;
+                if (!ref || value === undefined || !this.page) {
+                    res.status(400).json({ error: 'ref and value required' });
+                    return;
+                }
+                yield this.page.fill(`[data-cm-ref="${ref}"]`, value, { timeout: 15000 });
+                res.json({ ok: true });
+            }
+            catch (e) {
+                res.status(500).json({ error: e.message });
+            }
+        }));
+        this.app.get('/screenshot', (_req, res) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.page) {
+                    res.status(400).json({ error: 'no session' });
+                    return;
+                }
+                const buf = yield this.page.screenshot({ type: 'png' });
+                res.setHeader('Content-Type', 'image/png');
+                res.send(buf);
+            }
+            catch (e) {
+                res.status(500).json({ error: e.message });
+            }
+        }));
+        this.app.get('/console', (_req, res) => {
+            res.json({ entries: this.consoleBuf.snapshot() });
+        });
+        this.app.get('/network', (_req, res) => {
+            res.json({ entries: this.networkBuf.snapshot() });
+        });
+    }
+    listen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const host = this.opts.host || '127.0.0.1';
+            const port = (_a = this.opts.port) !== null && _a !== void 0 ? _a : 17395;
+            return new Promise((resolve, reject) => {
+                this.httpServer = this.app.listen(port, host, () => resolve());
+                this.httpServer.on('error', reject);
+            });
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.page)
+                yield this.page.close().catch(() => { });
+            if (this.context)
+                yield this.context.close().catch(() => { });
+            if (this.browser)
+                yield this.browser.close().catch(() => { });
+            this.page = null;
+            this.context = null;
+            this.browser = null;
+            if (this.httpServer) {
+                yield new Promise((r) => this.httpServer.close(() => r()));
+                this.httpServer = null;
+            }
+        });
+    }
+}
+exports.BrowseDaemon = BrowseDaemon;

package/dist/cli/command-registry.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAllCommands = registerAllCommands;
+const agent_1 = require("./commands/agent");
+const dashboard_1 = require("./commands/dashboard");
+const project_1 = require("./commands/project");
+const skill_chain_1 = require("./commands/skill-chain");
+const system_1 = require("./commands/system");
+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.
+ */
+function registerAllCommands(program) {
+    (0, agent_1.registerAgentCommands)(program);
+    (0, dashboard_1.registerDashboardCommands)(program);
+    (0, project_1.registerProjectCommands)(program);
+    (0, skill_chain_1.registerSkillChainCommands)(program);
+    (0, system_1.registerSystemCommands)(program);
+    (0, task_1.registerTaskCommands)(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/agent.js

@@ -0,0 +1,120 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAgentCommands = registerAgentCommands;
+const continuity_1 = require("../../continuity");
+const box_1 = require("../../ui/box");
+const theme_1 = require("../../ui/theme");
+const cli_utils_1 = require("../../utils/cli-utils");
+function registerAgentCommands(program) {
+    program
+        .command('agent [cmd] [args...]')
+        .alias('a')
+        .description('Agent management (status|memory|brain|learn)')
+        .action((cmd, args) => {
+        switch (cmd) {
+            case 'status':
+            case 'st':
+                agentStatus();
+                break;
+            case 'memory':
+            case 'mem':
+                agentMemory();
+                break;
+            case 'brain':
+            case 'br':
+                agentBrain();
+                break;
+            case 'learn':
+                agentLearn(args.join(' '));
+                break;
+            default: agentStatus();
+        }
+    });
+    program
+        .command('brain')
+        .alias('br')
+        .description('Show AI brain/working memory')
+        .action(() => agentBrain());
+}
+function agentStatus() {
+    const summary = (0, continuity_1.getContinuityStatus)(process.cwd());
+    if (!summary.initialized) {
+        console.log((0, box_1.renderResult)('warning', 'No active CodyMaster brain initialized in this directory.', [
+            (0, theme_1.dim)('Run `cm init` to start.')
+        ]));
+        return;
+    }
+    console.log((0, box_1.renderCommandHeader)('Agent Status: Hamster v4.6', '🐹'));
+    console.log((0, theme_1.brand)('  🧠 Memory Index:'));
+    console.log((0, theme_1.dim)(`    Iterations: ${summary.iteration}`));
+    console.log((0, theme_1.dim)(`    Current Goal: ${summary.activeGoal}`));
+    console.log((0, theme_1.dim)(`    Current Phase: ${summary.phase}`));
+    console.log((0, theme_1.dim)(`    Tasks Completed: ${summary.completedCount}`));
+    console.log((0, theme_1.dim)(`    Active Blockers: ${summary.blockerCount}`));
+    console.log(`\n  ${(0, theme_1.brand)('📊 Activity Summary:')}`);
+    console.log((0, theme_1.dim)(`    Learnings: ${summary.learningCount}`));
+    console.log((0, theme_1.dim)(`    Decisions: ${summary.decisionCount}`));
+    console.log();
+}
+function agentMemory() {
+    const learnings = (0, continuity_1.getLearnings)(process.cwd()).slice(0, 5);
+    if (learnings.length === 0) {
+        console.log((0, box_1.renderResult)('info', 'No memories stored yet.'));
+        return;
+    }
+    console.log((0, box_1.renderCommandHeader)('Agent Memory (Latest)', '🧠'));
+    learnings.forEach((l) => {
+        console.log(`  ${(0, theme_1.success)('●')} ${(0, theme_1.brand)(l.whatFailed)}`);
+        console.log((0, theme_1.dim)(`    ${l.howToPrevent} (${(0, cli_utils_1.formatTimeAgoCli)(l.timestamp)})`));
+    });
+    console.log();
+}
+function agentBrain() {
+    const state = (0, continuity_1.readContinuityState)(process.cwd());
+    if (!state) {
+        console.log((0, box_1.renderResult)('warning', 'Brain not initialized.'));
+        return;
+    }
+    console.log((0, box_1.renderCommandHeader)(`Agent Brain: ${state.project}`, '🧠'));
+    console.log((0, theme_1.brand)(`  Goal: ${state.activeGoal}`));
+    console.log((0, theme_1.dim)(`  Phase: ${state.currentPhase} (Iter ${state.currentIteration})`));
+    console.log(`\n  ${(0, theme_1.brand)('Next Actions:')}`);
+    state.nextActions.slice(0, 5).forEach((act, idx) => {
+        console.log(`    ${idx + 1}. ${act}`);
+    });
+    if (state.activeBlockers.length > 0) {
+        console.log(`\n  ${(0, theme_1.warning)('Blockers:')}`);
+        state.activeBlockers.forEach((b) => console.log(`    ⚠️ ${b}`));
+    }
+    console.log();
+}
+function agentLearn(content) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (!content) {
+            console.log((0, box_1.renderResult)('error', 'Please provide a learning to record.'));
+            return;
+        }
+        const state = (0, continuity_1.readContinuityState)(process.cwd());
+        const learning = {
+            whatFailed: content,
+            whyFailed: 'Manual entry',
+            howToPrevent: 'Recorded via CLI',
+            timestamp: new Date().toISOString(),
+            agent: 'CLI User',
+            taskId: ((_a = state === null || state === void 0 ? void 0 : state.currentTask) === null || _a === void 0 ? void 0 : _a.id) || 'manual',
+            module: 'system'
+        };
+        (0, continuity_1.addLearning)(process.cwd(), learning);
+        console.log((0, box_1.renderResult)('success', 'Learning recorded in brain.'));
+    });
+}

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}`));
+    }));
+}