codymaster 4.6.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/sprint-pipeline.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * Opinionated sprint pipeline + Context Bus files under `.cm/sprint/`.
+ * Complements root `context-bus.json` with step artifacts (ADR 002).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPRINT_STEPS = void 0;
+exports.readSprintState = readSprintState;
+exports.writeSprintState = writeSprintState;
+exports.initSprint = initSprint;
+exports.completeSprintStep = completeSprintStep;
+exports.skipSprintStep = skipSprintStep;
+exports.resetSprint = resetSprint;
+exports.sprintDryRun = sprintDryRun;
+exports.sprintArtifactPreviewFromDisk = sprintArtifactPreviewFromDisk;
+exports.skillMappingForStep = skillMappingForStep;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.SPRINT_STEPS = [
+    'brainstorm',
+    'plan',
+    'design',
+    'tdd',
+    'build',
+    'review',
+    'qa',
+    'security',
+    'ship',
+    'monitor',
+    'retro',
+];
+function sprintDir(projectPath) {
+    return path_1.default.join(projectPath, '.cm', 'sprint');
+}
+function statePath(projectPath) {
+    return path_1.default.join(sprintDir(projectPath), 'state.json');
+}
+function ensureSprintDir(projectPath) {
+    const d = sprintDir(projectPath);
+    const art = path_1.default.join(d, 'artifacts');
+    if (!fs_1.default.existsSync(art))
+        fs_1.default.mkdirSync(art, { recursive: true });
+}
+function normalizeSprintState(raw) {
+    var _a;
+    return Object.assign(Object.assign({}, raw), { version: raw.version === 2 ? 2 : 1, skipped: (_a = raw.skipped) !== null && _a !== void 0 ? _a : [] });
+}
+function readSprintState(projectPath) {
+    const p = statePath(projectPath);
+    if (!fs_1.default.existsSync(p))
+        return null;
+    try {
+        const raw = JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+        return normalizeSprintState(raw);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function writeSprintState(projectPath, state) {
+    ensureSprintDir(projectPath);
+    fs_1.default.writeFileSync(statePath(projectPath), JSON.stringify(state, null, 2), 'utf8');
+}
+function initSprint(projectPath, fromStep) {
+    ensureSprintDir(projectPath);
+    const now = new Date().toISOString();
+    let pipeline = [...exports.SPRINT_STEPS];
+    let startIdx = 0;
+    if (fromStep) {
+        const i = pipeline.indexOf(fromStep);
+        if (i >= 0)
+            startIdx = i;
+    }
+    const state = {
+        version: 2,
+        pipeline,
+        current_index: startIdx,
+        completed: [],
+        skipped: [],
+        started_at: now,
+        updated_at: now,
+        artifacts_dir: path_1.default.join(sprintDir(projectPath), 'artifacts'),
+    };
+    writeSprintState(projectPath, state);
+    appendEvent(projectPath, { type: 'init', from: fromStep !== null && fromStep !== void 0 ? fromStep : null, at: now });
+    return state;
+}
+function completeSprintStep(projectPath, step, artifactBody) {
+    let state = readSprintState(projectPath);
+    if (!state)
+        state = initSprint(projectPath);
+    if (state.current_index >= state.pipeline.length) {
+        throw new Error('Sprint pipeline already finished');
+    }
+    const expected = state.pipeline[state.current_index];
+    if (expected !== step) {
+        throw new Error(`Expected step "${expected}", got "${step}"`);
+    }
+    const artFile = path_1.default.join(state.artifacts_dir, `${step}.md`);
+    fs_1.default.writeFileSync(artFile, artifactBody, 'utf8');
+    state.completed.push(step);
+    state.current_index = Math.min(state.current_index + 1, state.pipeline.length);
+    state.updated_at = new Date().toISOString();
+    state.version = 2;
+    writeSprintState(projectPath, state);
+    appendEvent(projectPath, { type: 'complete', step, at: state.updated_at });
+    return state;
+}
+const SKIP_STUB = (step, at) => `# ${step}\n\n_Skipped via \`cm sprint skip\` at ${at}._\n`;
+function skipSprintStep(projectPath, step) {
+    let state = readSprintState(projectPath);
+    if (!state)
+        state = initSprint(projectPath);
+    if (state.current_index >= state.pipeline.length) {
+        throw new Error('Sprint pipeline already finished');
+    }
+    const expected = state.pipeline[state.current_index];
+    if (expected !== step) {
+        throw new Error(`Expected step "${expected}", got "${step}"`);
+    }
+    const at = new Date().toISOString();
+    const artFile = path_1.default.join(state.artifacts_dir, `${step}.md`);
+    fs_1.default.writeFileSync(artFile, SKIP_STUB(step, at), 'utf8');
+    state.skipped.push(step);
+    state.current_index = Math.min(state.current_index + 1, state.pipeline.length);
+    state.updated_at = at;
+    state.version = 2;
+    writeSprintState(projectPath, state);
+    appendEvent(projectPath, { type: 'skip', step, at });
+    return state;
+}
+function backupDirName() {
+    return new Date().toISOString().replace(/:/g, '-');
+}
+/** Remove sprint state; optional backup under `.cm/sprint/backup/<timestamp>/`. */
+function resetSprint(projectPath, options) {
+    const backup = (options === null || options === void 0 ? void 0 : options.backup) !== false;
+    const sd = sprintDir(projectPath);
+    const st = statePath(projectPath);
+    const ev = eventsPath(projectPath);
+    const art = path_1.default.join(sd, 'artifacts');
+    const hasState = fs_1.default.existsSync(st);
+    let hasEvents = false;
+    if (fs_1.default.existsSync(ev)) {
+        try {
+            hasEvents = fs_1.default.statSync(ev).size > 0;
+        }
+        catch (_a) {
+            hasEvents = false;
+        }
+    }
+    let hasArtifacts = false;
+    if (fs_1.default.existsSync(art)) {
+        try {
+            hasArtifacts = fs_1.default.readdirSync(art).length > 0;
+        }
+        catch (_b) {
+            hasArtifacts = false;
+        }
+    }
+    if (!hasState && !hasEvents && !hasArtifacts) {
+        return { ok: false, reason: 'no_sprint_data' };
+    }
+    let backupPath;
+    if (backup) {
+        const stamp = backupDirName();
+        backupPath = path_1.default.join(sd, 'backup', stamp);
+        fs_1.default.mkdirSync(backupPath, { recursive: true });
+        if (hasState)
+            fs_1.default.copyFileSync(st, path_1.default.join(backupPath, 'state.json'));
+        if (fs_1.default.existsSync(ev))
+            fs_1.default.copyFileSync(ev, path_1.default.join(backupPath, 'events.jsonl'));
+        if (fs_1.default.existsSync(art)) {
+            const destArt = path_1.default.join(backupPath, 'artifacts');
+            fs_1.default.cpSync(art, destArt, { recursive: true });
+        }
+    }
+    fs_1.default.rmSync(st, { force: true });
+    fs_1.default.rmSync(ev, { force: true });
+    fs_1.default.rmSync(art, { recursive: true, force: true });
+    fs_1.default.mkdirSync(art, { recursive: true });
+    return { ok: true, backupDir: backupPath };
+}
+function sprintDryRun(projectPath) {
+    var _a;
+    const state = (_a = readSprintState(projectPath)) !== null && _a !== void 0 ? _a : initSprint(projectPath);
+    return sprintArtifactPreview(state);
+}
+/** Read-only preview without creating files (for MCP / status). */
+function sprintArtifactPreviewFromDisk(projectPath) {
+    const state = readSprintState(projectPath);
+    if (!state) {
+        const base = path_1.default.join(projectPath, '.cm', 'sprint', 'artifacts');
+        const artifacts = exports.SPRINT_STEPS.map((s) => path_1.default.join(base, `${s}.md`));
+        return { steps: [...exports.SPRINT_STEPS], artifacts };
+    }
+    return sprintArtifactPreview(state);
+}
+function sprintArtifactPreview(state) {
+    const artifacts = state.pipeline.map((s) => path_1.default.join(state.artifacts_dir, `${s}.md`));
+    return { steps: [...state.pipeline], artifacts };
+}
+function eventsPath(projectPath) {
+    return path_1.default.join(sprintDir(projectPath), 'events.jsonl');
+}
+function appendEvent(projectPath, rec) {
+    ensureSprintDir(projectPath);
+    fs_1.default.appendFileSync(eventsPath(projectPath), JSON.stringify(rec) + '\n', 'utf8');
+}
+function skillMappingForStep(step) {
+    const map = {
+        brainstorm: 'cm-brainstorm-idea',
+        plan: 'cm-planning',
+        design: 'cm-ui-preview / cm-design-system',
+        tdd: 'cm-tdd',
+        build: 'cm-execution',
+        review: 'cm-code-review',
+        qa: 'cm-quality-gate / cm-test-gate',
+        security: 'cm-secret-shield / cm-security-gate',
+        ship: 'cm-safe-deploy',
+        monitor: 'cm-canary (post-deploy)',
+        retro: 'cm-retro',
+    };
+    return map[step];
+}