codymaster 4.8.0 → 5.2.0

package/dist/skill-execution-cache.js

@@ -0,0 +1,254 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillExecutionCache = void 0;
+exports.formatCacheStats = formatCacheStats;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const path_1 = __importDefault(require("path"));
+// ─── Schema ─────────────────────────────────────────────────────────────────
+const CACHE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS skill_cache (
+  id               INTEGER PRIMARY KEY AUTOINCREMENT,
+  task_pattern     TEXT NOT NULL,
+  skill_chain_json TEXT NOT NULL,
+  effectiveness    REAL NOT NULL DEFAULT 0,
+  token_used       INTEGER NOT NULL DEFAULT 0,
+  hit_count        INTEGER NOT NULL DEFAULT 0,
+  last_hit         TEXT NOT NULL,
+  created_at       TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_skill_cache_pattern ON skill_cache(task_pattern);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS skill_cache_fts USING fts5(
+  task_pattern,
+  content=skill_cache, content_rowid=rowid
+);
+
+CREATE TRIGGER IF NOT EXISTS skill_cache_ai AFTER INSERT ON skill_cache BEGIN
+  INSERT INTO skill_cache_fts(rowid, task_pattern)
+  VALUES (new.rowid, new.task_pattern);
+END;
+
+CREATE TRIGGER IF NOT EXISTS skill_cache_ad AFTER DELETE ON skill_cache BEGIN
+  INSERT INTO skill_cache_fts(skill_cache_fts, rowid, task_pattern)
+  VALUES('delete', old.rowid, old.task_pattern);
+END;
+`;
+// ─── DB Cache (share connection with context-db) ─────────────────────────────
+const dbCache = new Map();
+function getDb(dbPath) {
+    if (dbCache.has(dbPath))
+        return dbCache.get(dbPath);
+    const db = new better_sqlite3_1.default(dbPath);
+    db.pragma('journal_mode = WAL');
+    dbCache.set(dbPath, db);
+    return db;
+}
+// ─── Skill Execution Cache ───────────────────────────────────────────────────
+// TRIZ #35 Parameter Changes — reuse successful execution patterns
+/**
+ * SkillExecutionCache — OpenSpace-inspired warm cache for skill chains.
+ *
+ * When a task succeeds with a specific skill chain, we cache the pattern.
+ * For similar future tasks, skip BM25 ranking entirely and reuse the chain.
+ *
+ * Token savings: ~2000 tokens/task (skip ranking + LLM selection).
+ */
+class SkillExecutionCache {
+    constructor(projectPath) {
+        this.dbPath = path_1.default.join(projectPath, '.cm', 'context.db');
+    }
+    /**
+     * Initialize cache tables. Call once before use.
+     */
+    initialize() {
+        const db = getDb(this.dbPath);
+        db.exec(CACHE_SCHEMA);
+    }
+    /**
+     * Cache a successful task execution pattern.
+     * Only caches executions with effectiveness >= 0.7.
+     */
+    cacheExecution(taskPattern, skillChain, effectiveness, tokenUsed) {
+        if (effectiveness < 0.7)
+            return; // Only cache good executions
+        if (!taskPattern.trim() || skillChain.length === 0)
+            return;
+        const db = getDb(this.dbPath);
+        const now = new Date().toISOString();
+        // Check if similar pattern already exists
+        const existing = this.findExactMatch(taskPattern);
+        if (existing) {
+            // Update existing entry if new execution is better
+            if (effectiveness >= existing.effectiveness) {
+                db.prepare(`
+          UPDATE skill_cache SET
+            skill_chain_json = ?,
+            effectiveness = ?,
+            token_used = ?,
+            hit_count = hit_count + 1,
+            last_hit = ?
+          WHERE task_pattern = ?
+        `).run(JSON.stringify(skillChain), effectiveness, tokenUsed, now, taskPattern);
+            }
+            else {
+                // Just increment hit count
+                db.prepare(`
+          UPDATE skill_cache SET hit_count = hit_count + 1, last_hit = ? WHERE task_pattern = ?
+        `).run(now, taskPattern);
+            }
+            return;
+        }
+        db.prepare(`
+      INSERT INTO skill_cache
+        (task_pattern, skill_chain_json, effectiveness, token_used, hit_count, last_hit, created_at)
+      VALUES (?, ?, ?, ?, 1, ?, ?)
+    `).run(taskPattern, JSON.stringify(skillChain), effectiveness, tokenUsed, now, now);
+    }
+    /**
+     * Find a cached chain for a task description using BM25 similarity.
+     * Returns null if no suitable match (effectiveness >= 0.7).
+     */
+    findCachedChain(taskDescription) {
+        const db = getDb(this.dbPath);
+        const query = this.normalizeForSearch(taskDescription);
+        if (!query)
+            return null;
+        try {
+            const row = db.prepare(`
+        SELECT skill_cache.* FROM skill_cache
+        JOIN skill_cache_fts ON skill_cache.rowid = skill_cache_fts.rowid
+        WHERE skill_cache_fts MATCH ?
+          AND skill_cache.effectiveness >= 0.7
+        ORDER BY bm25(skill_cache_fts) * skill_cache.effectiveness * (1.0 + skill_cache.hit_count * 0.1)
+        LIMIT 1
+      `).get(query);
+            if (!row)
+                return null;
+            return this.rowToCachedChain(row);
+        }
+        catch (_a) {
+            // FTS5 query might fail with special characters
+            return null;
+        }
+    }
+    /**
+     * Record a cache hit (increment counter, update timestamp).
+     */
+    recordHit(taskPattern) {
+        const db = getDb(this.dbPath);
+        db.prepare(`
+      UPDATE skill_cache SET hit_count = hit_count + 1, last_hit = ? WHERE task_pattern = ?
+    `).run(new Date().toISOString(), taskPattern);
+    }
+    /**
+     * Get cache statistics.
+     */
+    getStats() {
+        const db = getDb(this.dbPath);
+        try {
+            const stats = db.prepare(`
+        SELECT
+          COUNT(*) as total_entries,
+          COALESCE(SUM(hit_count), 0) as total_hits,
+          COALESCE(AVG(effectiveness), 0) as avg_effectiveness,
+          COALESCE(SUM(hit_count * token_used), 0) as estimated_tokens_saved
+        FROM skill_cache
+      `).get();
+            return {
+                totalEntries: stats.total_entries,
+                totalHits: stats.total_hits,
+                avgEffectiveness: Math.round(stats.avg_effectiveness * 100) / 100,
+                estimatedTokensSaved: stats.estimated_tokens_saved,
+            };
+        }
+        catch (_a) {
+            return { totalEntries: 0, totalHits: 0, avgEffectiveness: 0, estimatedTokensSaved: 0 };
+        }
+    }
+    /**
+     * List all cached chains.
+     */
+    listCachedChains(limit = 20) {
+        const db = getDb(this.dbPath);
+        try {
+            const rows = db.prepare('SELECT * FROM skill_cache ORDER BY hit_count DESC, effectiveness DESC LIMIT ?').all(limit);
+            return rows.map(r => this.rowToCachedChain(r));
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    /**
+     * Clear all cached chains.
+     */
+    clearCache() {
+        const db = getDb(this.dbPath);
+        const info = db.prepare('DELETE FROM skill_cache').run();
+        return info.changes;
+    }
+    /**
+     * Close the database connection.
+     */
+    close() {
+        const db = dbCache.get(this.dbPath);
+        if (db) {
+            try {
+                db.close();
+            }
+            catch ( /* already closed */_a) { /* already closed */ }
+            dbCache.delete(this.dbPath);
+        }
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    findExactMatch(taskPattern) {
+        const db = getDb(this.dbPath);
+        const row = db.prepare('SELECT * FROM skill_cache WHERE task_pattern = ? LIMIT 1').get(taskPattern);
+        return row ? this.rowToCachedChain(row) : null;
+    }
+    /**
+     * Normalize a task description for FTS5 search.
+     * Removes special characters that break FTS5 MATCH syntax.
+     */
+    normalizeForSearch(text) {
+        return text
+            .replace(/[^\w\s]/g, ' ') // Remove special chars
+            .replace(/\s+/g, ' ') // Collapse whitespace
+            .trim()
+            .split(' ')
+            .filter(w => w.length > 2) // Drop short words
+            .slice(0, 10) // Limit query length
+            .join(' ');
+    }
+    rowToCachedChain(row) {
+        let chain = [];
+        try {
+            chain = JSON.parse(String(row.skill_chain_json || '[]'));
+        }
+        catch ( /* empty */_a) { /* empty */ }
+        return {
+            taskPattern: String(row.task_pattern || ''),
+            skillChain: chain,
+            effectiveness: Number(row.effectiveness || 0),
+            tokenUsed: Number(row.token_used || 0),
+            hitCount: Number(row.hit_count || 0),
+            lastHit: String(row.last_hit || ''),
+        };
+    }
+}
+exports.SkillExecutionCache = SkillExecutionCache;
+// ─── Display Helpers ─────────────────────────────────────────────────────────
+function formatCacheStats(stats) {
+    const lines = [
+        `📦 Skill Execution Cache`,
+        `─`.repeat(50),
+        `Cached patterns:     ${stats.totalEntries}`,
+        `Total cache hits:    ${stats.totalHits}`,
+        `Avg effectiveness:   ${(stats.avgEffectiveness * 100).toFixed(1)}%`,
+        `Est. tokens saved:   ~${stats.estimatedTokensSaved.toLocaleString()}`,
+    ];
+    return lines.join('\n');
+}

package/dist/smart-brain-router.js

@@ -0,0 +1,184 @@
+"use strict";
+// ─── Smart Brain Router ─────────────────────────────────────────────────────
+// Task-type classifier + brain tier selector for CodyMaster's 5-Tier Brain.
+// TRIZ #1 Segmentation — load only the brain tiers needed for each task type.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyTask = classifyTask;
+exports.routeTask = routeTask;
+exports.estimateSavings = estimateSavings;
+exports.formatBrainPlan = formatBrainPlan;
+// ─── Tier Costs (average token estimates) ────────────────────────────────────
+const TIER_COSTS = {
+    1: { label: 'Sensory', avgTokens: 0, latencyMs: 0 },
+    2: { label: 'Working', avgTokens: 400, latencyMs: 0 },
+    3: { label: 'Long-term', avgTokens: 650, latencyMs: 50 },
+    4: { label: 'Semantic', avgTokens: 1500, latencyMs: 2000 },
+    5: { label: 'Structural', avgTokens: 3000, latencyMs: 5000 },
+};
+// ─── Task Classifier ────────────────────────────────────────────────────────
+// TRIZ #1 Segmentation — classify to load only what's needed
+/**
+ * Lightweight task classifier — keyword based, no LLM call.
+ * Cost: ~0 tokens, <1ms.
+ */
+function classifyTask(description) {
+    const lower = description.toLowerCase();
+    // Order matters: more specific patterns first
+    if (lower.match(/\b(resume|continue|what was|pick up|carry on|tiếp tục|đang làm gì)\b/)) {
+        return 'resume_session';
+    }
+    if (lower.match(/\b(deploy|ship|release|publish|push to prod|triển khai|xuất bản)\b/)) {
+        return 'deployment';
+    }
+    if (lower.match(/\b(blog|article|content|write about|documentation|bài viết|nội dung|tài liệu)\b/)) {
+        return 'content_creation';
+    }
+    if (lower.match(/\b(fix|bug|error|crash|broken|debug|sửa|lỗi|hỏng)\b/)) {
+        return 'code_change';
+    }
+    if (lower.match(/\b(build|create|implement|add|feature|system|xây|tạo|thêm|tính năng)\b/)) {
+        return 'complex_feature';
+    }
+    // Short descriptive queries are likely simple questions
+    if (lower.match(/\b(what|how|why|explain|status|where|show|list)\b/) && lower.length < 120) {
+        return 'simple_question';
+    }
+    return 'code_change'; // Safe default
+}
+// ─── Brain Router ────────────────────────────────────────────────────────────
+/**
+ * Smart Brain Router — selects minimal brain layers needed for a task.
+ *
+ * Problem solved:
+ *   Without routing, every task loads all 5 tiers = ~5550 tokens + 7s latency.
+ *   With routing, simple tasks use ~0-400 tokens, complex tasks scale progressively.
+ *
+ * Estimated savings: ~60-80% token reduction on brain context loading.
+ */
+function routeTask(taskDescription) {
+    const taskType = classifyTask(taskDescription);
+    switch (taskType) {
+        case 'simple_question':
+            return {
+                taskType,
+                tiers: [1],
+                totalBudget: 200,
+                progressiveLoad: false,
+                rationale: 'Simple question — Tier 1 (Sensory) only. No memory or code context needed.',
+            };
+        case 'resume_session':
+            return {
+                taskType,
+                tiers: [1, 2],
+                totalBudget: 500,
+                progressiveLoad: false,
+                rationale: 'Session resume — Tier 1 + Tier 2 (CONTINUITY.md) to recall working state.',
+            };
+        case 'code_change':
+            return {
+                taskType,
+                tiers: [1, 2, 3, 5],
+                tier3Scope: extractScope(taskDescription),
+                tier5Filter: extractFilePaths(taskDescription),
+                totalBudget: 3000,
+                progressiveLoad: false,
+                rationale: 'Code change — Tiers 1+2+3+5. Learnings scoped, CodeGraph for affected files.',
+            };
+        case 'deployment':
+            return {
+                taskType,
+                tiers: [1, 2, 3],
+                tier3Scope: 'deploy',
+                totalBudget: 1500,
+                progressiveLoad: false,
+                rationale: 'Deployment — Tiers 1+2+3. Scoped learnings for deploy patterns.',
+            };
+        case 'content_creation':
+            return {
+                taskType,
+                tiers: [1, 3, 4],
+                totalBudget: 2000,
+                progressiveLoad: false,
+                rationale: 'Content creation — Tiers 1+3+4. Semantic search for related content.',
+            };
+        case 'complex_feature':
+            return {
+                taskType,
+                tiers: [1, 2, 3, 4, 5],
+                totalBudget: 5000,
+                progressiveLoad: true,
+                rationale: 'Complex feature — All tiers, progressive loading. Start L0, upgrade on demand.',
+            };
+    }
+}
+// ─── Scope Extraction ────────────────────────────────────────────────────────
+/**
+ * Extract a module scope from the task description for Tier 3 scoping.
+ * Returns undefined if no clear scope detected.
+ */
+function extractScope(description) {
+    const lower = description.toLowerCase();
+    // Priority 1: Look for common scope keywords (most reliable)
+    const scopes = ['auth', 'api', 'deploy', 'test', 'build', 'db', 'ui', 'cli', 'i18n', 'security'];
+    const found = scopes.find(s => lower.includes(s));
+    if (found)
+        return found;
+    // Priority 2: Look for explicit "module: xxx" or "component: xxx" patterns
+    const moduleMatch = lower.match(/(?:module|component|service|package)[:\s]+(\w[\w-]*)/);
+    if (moduleMatch)
+        return moduleMatch[1];
+    return undefined;
+}
+/**
+ * Extract file paths mentioned in the task for Tier 5 filtering.
+ */
+function extractFilePaths(description) {
+    const matches = description.match(/[\w./-]+\.(ts|js|tsx|jsx|py|go|rs|md|json|yaml|yml)/g);
+    return matches && matches.length > 0 ? matches : undefined;
+}
+// ─── Token Savings Estimator ─────────────────────────────────────────────────
+/**
+ * Estimate token savings from smart routing vs loading all tiers.
+ */
+function estimateSavings(plan) {
+    const allTiersTokens = Object.values(TIER_COSTS).reduce((sum, t) => sum + t.avgTokens, 0);
+    const planTokens = plan.tiers.reduce((sum, tier) => sum + TIER_COSTS[tier].avgTokens, 0);
+    return {
+        withoutRouting: allTiersTokens,
+        withRouting: planTokens,
+        saved: allTiersTokens - planTokens,
+        percentage: Math.round(((allTiersTokens - planTokens) / allTiersTokens) * 100),
+    };
+}
+// ─── Display Helpers ─────────────────────────────────────────────────────────
+/**
+ * Format a BrainLoadPlan for CLI display.
+ */
+function formatBrainPlan(plan) {
+    const savings = estimateSavings(plan);
+    const tierLabels = plan.tiers.map(t => `  ${t}. ${TIER_COSTS[t].label} (~${TIER_COSTS[t].avgTokens} tokens)`);
+    const lines = [
+        `🧠 Brain Load Plan`,
+        `─`.repeat(50),
+        `Task type:   ${plan.taskType}`,
+        `Progressive: ${plan.progressiveLoad ? 'Yes' : 'No'}`,
+        `Budget:      ${plan.totalBudget.toLocaleString()} tokens`,
+        ``,
+        `Active tiers:`,
+        ...tierLabels,
+        ``,
+        `Token savings:`,
+        `  All tiers:   ~${savings.withoutRouting.toLocaleString()} tokens`,
+        `  This plan:   ~${savings.withRouting.toLocaleString()} tokens`,
+        `  Saved:       ~${savings.saved.toLocaleString()} tokens (${savings.percentage}%)`,
+        ``,
+        `Rationale: ${plan.rationale}`,
+    ];
+    if (plan.tier3Scope) {
+        lines.push(`Tier 3 scope: ${plan.tier3Scope}`);
+    }
+    if (plan.tier5Filter) {
+        lines.push(`Tier 5 filter: ${plan.tier5Filter.join(', ')}`);
+    }
+    return lines.join('\n');
+}

package/dist/storage-backend.js

@@ -1,11 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VikingBackend = exports.SqliteBackend = void 0;
+exports.SqliteBackend = void 0;
 exports.getBackend = getBackend;
 const context_db_1 = require("./context-db");
-const viking_backend_1 = require("./backends/viking-backend");
-Object.defineProperty(exports, "VikingBackend", { enumerable: true, get: function () { return viking_backend_1.VikingBackend; } });
-const viking_http_client_1 = require("./backends/viking-http-client");
 const cm_config_1 = require("./cm-config");
 // ─── SqliteBackend ────────────────────────────────────────────────────────────
 /**
@@ -33,6 +30,10 @@ class SqliteBackend {
     }
     writeSkillOutput(o) { (0, context_db_1.writeSkillOutput)(this.dbPath, o); }
     getSkillOutputs(sessionId) { return (0, context_db_1.getSkillOutputs)(this.dbPath, sessionId); }
+    recordExecutionAnalysis(a) { (0, context_db_1.recordExecutionAnalysis)(this.dbPath, a); }
+    getExecutionAnalyses(limit = 20) { return (0, context_db_1.getExecutionAnalyses)(this.dbPath, limit); }
+    getSkillMetric(skill) { return (0, context_db_1.getSkillMetric)(this.dbPath, skill); }
+    listSkillMetrics(limit = 50) { return (0, context_db_1.listSkillMetrics)(this.dbPath, limit); }
 }
 exports.SqliteBackend = SqliteBackend;
 // ─── Factory ─────────────────────────────────────────────────────────────────
@@ -40,7 +41,7 @@ exports.SqliteBackend = SqliteBackend;
  * Returns the configured StorageBackend for the given project.
  *
  * Reads `.cm/config.yaml → storage.backend` via `loadCmConfig` (default: `sqlite`).
- * For `viking` backend, reads `storage.viking.*` for connection config.
+ * Legacy `storage.backend: viking` configs are warned and routed back to sqlite.
  *
  * Usage:
  *   const backend = getBackend('/path/to/project');
@@ -48,13 +49,14 @@ exports.SqliteBackend = SqliteBackend;
  *   const results = backend.queryLearnings('i18n locale');
  */
 function getBackend(projectPath) {
-    var _a, _b, _c;
+    var _a, _b;
     const cfg = (0, cm_config_1.loadCmConfig)(projectPath);
     const engine = ((_b = (_a = cfg.storage) === null || _a === void 0 ? void 0 : _a.backend) !== null && _b !== void 0 ? _b : 'sqlite').toLowerCase();
     switch (engine) {
         case 'viking': {
-            const vikingConfig = Object.assign(Object.assign({}, viking_http_client_1.DEFAULT_VIKING_CONFIG), (_c = cfg.storage) === null || _c === void 0 ? void 0 : _c.viking);
-            return new viking_backend_1.VikingBackend(vikingConfig);
+            console.warn('[CodyMaster] storage.backend: viking has been removed. ' +
+                'Falling back to sqlite for the supported default path.');
+            return new SqliteBackend(projectPath);
         }
         case 'sqlite':
         default:

package/dist/token-budget.js

@@ -8,6 +8,10 @@ exports.loadBudget = loadBudget;
 exports.checkBudget = checkBudget;
 exports.estimateTokens = estimateTokens;
 exports.generateBudgetReport = generateBudgetReport;
+exports.getDefaultTierBudgets = getDefaultTierBudgets;
+exports.checkTierBudget = checkTierBudget;
+exports.generateTierReport = generateTierReport;
+exports.formatSavingsReport = formatSavingsReport;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 // ─── Constants ──────────────────────────────────────────────────────────────
@@ -106,3 +110,87 @@ function generateBudgetReport(budget) {
     lines.push(`${'TOTAL'.padEnd(25)} ${sum.toLocaleString().padStart(10)} ${(((sum / total) * 100).toFixed(2) + '%').padStart(10)}`);
     return lines.join('\n');
 }
+// ─── Per-Tier Budgets (Smart Brain Router integration) ───────────────────────
+/**
+ * Default per-tier token budgets for the 5-Tier Brain architecture.
+ * Used by SmartBrainRouter to enforce tier-level spending limits.
+ */
+function getDefaultTierBudgets() {
+    return [
+        { tier: 1, label: 'Sensory', soft: 0, hard: 0 }, // Always on, zero cost
+        { tier: 2, label: 'Working', soft: 500, hard: 1000 }, // CONTINUITY.md
+        { tier: 3, label: 'Long-term', soft: 500, hard: 3000 }, // Learnings/decisions
+        { tier: 4, label: 'Semantic', soft: 0, hard: 2000 }, // qmd vector search
+        { tier: 5, label: 'Structural', soft: 0, hard: 4000 }, // CodeGraph AST
+    ];
+}
+/**
+ * Check if a tier's token usage is within budget.
+ */
+function checkTierBudget(tierBudgets, tier, tokenCount, enforcement = 'soft') {
+    const budget = tierBudgets.find(tb => tb.tier === tier);
+    if (!budget) {
+        return { allowed: false, remaining: 0, suggestion: `Unknown tier ${tier}` };
+    }
+    const limit = enforcement === 'hard' ? budget.hard : budget.soft;
+    if (limit === 0) {
+        // Tier is disabled by default (soft=0), but allowed up to hard limit
+        if (tokenCount <= budget.hard) {
+            return { allowed: true, remaining: budget.hard - tokenCount };
+        }
+        return {
+            allowed: false,
+            remaining: budget.hard - tokenCount,
+            suggestion: `Tier ${tier} (${budget.label}) exceeds hard limit of ${budget.hard} tokens.`,
+        };
+    }
+    const remaining = limit - tokenCount;
+    if (remaining >= 0) {
+        return { allowed: true, remaining };
+    }
+    return {
+        allowed: enforcement !== 'hard',
+        remaining,
+        suggestion: `Tier ${tier} (${budget.label}) over by ~${Math.abs(remaining)} tokens. Consider L0 loading.`,
+    };
+}
+/**
+ * Generate a tier-level budget report.
+ */
+function generateTierReport(tierBudgets) {
+    const lines = [
+        `Brain Tier Budget Report`,
+        '─'.repeat(60),
+        `${'Tier'.padEnd(6)} ${'Label'.padEnd(12)} ${'Soft'.padStart(8)} ${'Hard'.padStart(8)} ${'Status'.padStart(10)}`,
+        '─'.repeat(60),
+    ];
+    for (const tb of tierBudgets) {
+        const status = tb.soft === 0 ? 'off/demand' : 'active';
+        lines.push(`${String(tb.tier).padEnd(6)} ${tb.label.padEnd(12)} ${tb.soft.toLocaleString().padStart(8)} ${tb.hard.toLocaleString().padStart(8)} ${status.padStart(10)}`);
+    }
+    const totalSoft = tierBudgets.reduce((s, tb) => s + tb.soft, 0);
+    const totalHard = tierBudgets.reduce((s, tb) => s + tb.hard, 0);
+    lines.push('─'.repeat(60));
+    lines.push(`${'TOTAL'.padEnd(18)} ${totalSoft.toLocaleString().padStart(8)} ${totalHard.toLocaleString().padStart(8)}`);
+    return lines.join('\n');
+}
+/**
+ * Format token savings report for CLI display.
+ */
+function formatSavingsReport(savings) {
+    const lines = [
+        `💰 Token Savings Report`,
+        '─'.repeat(50),
+        `Brain routing:       ~${savings.brainRoutingSaved.toLocaleString()} tokens saved`,
+        `Cache hits:          ~${savings.cacheHitsSaved.toLocaleString()} tokens saved`,
+        `Progressive loading: ~${savings.progressiveLoadSaved.toLocaleString()} tokens saved`,
+        '─'.repeat(50),
+        `Total saved:         ~${savings.totalSaved.toLocaleString()} tokens`,
+        `Tasks this session:  ${savings.sessionTasks}`,
+    ];
+    if (savings.sessionTasks > 0) {
+        const avgSaved = Math.round(savings.totalSaved / savings.sessionTasks);
+        lines.push(`Avg saved per task:  ~${avgSaved.toLocaleString()} tokens`);
+    }
+    return lines.join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codymaster",
-  "version": "4.8.0",
+  "version": "5.2.0",
   "description": "68+ Skills. Ship 10x faster. AI-powered coding skill kit for Claude, Cursor, Gemini & more.",
   "main": "dist/index.js",
   "repository": {
@@ -60,8 +60,7 @@
     "commands/",
     "public/",
     "README.md",
-    "CHANGELOG.md",
-    "install.sh"
+    "CHANGELOG.md"
   ],
   "publishConfig": {
     "access": "public"