codymaster 4.1.0

package/dist/judge.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateTaskState = evaluateTaskState;
+exports.evaluateAllTasks = evaluateAllTasks;
+exports.suggestAgentsForSkill = suggestAgentsForSkill;
+exports.suggestAgentsForTask = suggestAgentsForTask;
+exports.getSkillDomain = getSkillDomain;
+exports.suggestTransitions = suggestTransitions;
+exports.suggestChain = suggestChain;
+const skill_chain_1 = require("./skill-chain");
+// ─── Judge Configuration ────────────────────────────────────────────────────
+const STUCK_THRESHOLD_MS = 10 * 60 * 1000; // 10 minutes
+const MAX_FAIL_COUNT = 3;
+// ─── Skill → Domain Mapping ────────────────────────────────────────────────
+const SKILL_DOMAIN = {
+    'cm-tdd': 'engineering',
+    'cm-debugging': 'engineering',
+    'cm-quality-gate': 'engineering',
+    'cm-test-gate': 'engineering',
+    'cm-code-review': 'engineering',
+    'cm-safe-deploy': 'operations',
+    'cm-identity-guard': 'operations',
+    'cm-git-worktrees': 'operations',
+    'cm-terminal': 'operations',
+    'cm-planning': 'product',
+    'cm-ux-master': 'product',
+    'cm-dockit': 'product',
+    'cm-project-bootstrap': 'product',
+    'cm-content-factory': 'growth',
+    'cm-ads-tracker': 'growth',
+    'cro-methodology': 'growth',
+    'booking-calendar': 'growth',
+    'cm-execution': 'orchestration',
+    'cm-continuity': 'orchestration',
+    'cm-skill-mastery': 'orchestration',
+    'cm-safe-i18n': 'orchestration',
+};
+// ─── Agent Affinity ─────────────────────────────────────────────────────────
+const AGENT_AFFINITY = {
+    engineering: ['claude-code', 'cursor', 'antigravity'],
+    operations: ['claude-code', 'antigravity', 'cursor'],
+    product: ['antigravity', 'claude-code', 'cursor'],
+    growth: ['antigravity', 'claude-code', 'cursor'],
+    orchestration: ['antigravity', 'claude-code', 'cursor'],
+    specialized: ['antigravity', 'claude-code', 'cursor'],
+    debugging: ['claude-code', 'cursor', 'antigravity'],
+    review: ['antigravity', 'claude-code'],
+    documentation: ['antigravity', 'claude-code'],
+    design: ['cursor', 'antigravity'],
+};
+// ─── Agent Display ──────────────────────────────────────────────────────────
+const AGENT_DISPLAY = {
+    'antigravity': 'Google Antigravity',
+    'claude-code': 'Claude Code',
+    'cursor': 'Cursor',
+    'gemini-cli': 'Gemini CLI',
+    'windsurf': 'Windsurf',
+    'cline': 'Cline / RooCode',
+    'copilot': 'GitHub Copilot',
+};
+// ─── Judge Agent ────────────────────────────────────────────────────────────
+/**
+ * Evaluate the current state of a task and decide what action to take.
+ * Returns a JudgeDecision with one of: CONTINUE, COMPLETE, ESCALATE, PIVOT.
+ *
+ * Inspired by Loki Mode's Judge Agent Protocol.
+ */
+function evaluateTaskState(task, allTasks, learnings = []) {
+    // ─── COMPLETE: Task is already done ────────────────────────────────────
+    if (task.column === 'done') {
+        return {
+            action: 'COMPLETE',
+            reason: 'Task has been marked as done.',
+            confidence: 1.0,
+            badge: '🏁',
+        };
+    }
+    // ─── ESCALATE: Task stuck for too long ─────────────────────────────────
+    const updatedAt = new Date(task.updatedAt).getTime();
+    const elapsed = Date.now() - updatedAt;
+    if (task.column === 'in-progress' && elapsed > STUCK_THRESHOLD_MS) {
+        const minutesStuck = Math.round(elapsed / 60000);
+        return {
+            action: 'ESCALATE',
+            reason: `Task stuck in progress for ${minutesStuck} minutes without updates.`,
+            confidence: 0.85,
+            badge: '⚠️',
+        };
+    }
+    // ─── PIVOT: Too many failures → change approach ────────────────────────
+    const taskLearnings = learnings.filter(l => l.taskId === task.id);
+    if (taskLearnings.length >= MAX_FAIL_COUNT) {
+        const suggestedSkill = suggestAlternativeSkill(task.skill);
+        return {
+            action: 'PIVOT',
+            reason: `Task has failed ${taskLearnings.length} times. Consider changing approach.`,
+            confidence: 0.75,
+            suggestedNextSkill: suggestedSkill,
+            badge: '🔄',
+        };
+    }
+    // ─── ESCALATE: Dispatch failed previously ──────────────────────────────
+    if (task.dispatchStatus === 'failed' && task.dispatchError) {
+        return {
+            action: 'ESCALATE',
+            reason: `Dispatch failed: ${task.dispatchError}`,
+            confidence: 0.9,
+            badge: '⚠️',
+        };
+    }
+    // ─── COMPLETE: All related tasks in same project are done ──────────────
+    const projectTasks = allTasks.filter(t => t.projectId === task.projectId);
+    const allOthersDone = projectTasks
+        .filter(t => t.id !== task.id)
+        .every(t => t.column === 'done');
+    if (task.column === 'review' && allOthersDone) {
+        return {
+            action: 'COMPLETE',
+            reason: 'This is the last task in the project. Ready to finalize.',
+            confidence: 0.8,
+            badge: '🏁',
+        };
+    }
+    // ─── CONTINUE: Normal progress ─────────────────────────────────────────
+    // Check if task has a chain — suggest advancing
+    if (task.chainId && task.column === 'review') {
+        return {
+            action: 'CHAIN_NEXT',
+            reason: `Task is part of chain "${task.chainId}". Ready to advance to next step.`,
+            confidence: 0.8,
+            badge: '⛓️',
+        };
+    }
+    return {
+        action: 'CONTINUE',
+        reason: 'Task is progressing normally.',
+        confidence: 0.7,
+        badge: '🟢',
+    };
+}
+/**
+ * Evaluate all in-progress/review tasks and return decisions for each.
+ */
+function evaluateAllTasks(tasks, learnings = []) {
+    const decisions = new Map();
+    const activeTasks = tasks.filter(t => t.column === 'in-progress' || t.column === 'review');
+    for (const task of activeTasks) {
+        decisions.set(task.id, evaluateTaskState(task, tasks, learnings));
+    }
+    return decisions;
+}
+// ─── Dynamic Agent Selection ────────────────────────────────────────────────
+/**
+ * Suggest the best agents for a given skill, ordered by affinity.
+ */
+function suggestAgentsForSkill(skill) {
+    const domain = SKILL_DOMAIN[skill] || 'specialized';
+    const agents = AGENT_AFFINITY[domain] || AGENT_AFFINITY.engineering;
+    return agents;
+}
+/**
+ * Suggest the best agents for a task based on its skill.
+ * Returns formatted display names.
+ */
+function suggestAgentsForTask(task) {
+    const skill = task.skill || '';
+    const domain = SKILL_DOMAIN[skill] || guessdomainFromTitle(task.title);
+    const agents = AGENT_AFFINITY[domain] || AGENT_AFFINITY.engineering;
+    return agents.map((id, index) => ({
+        id,
+        name: AGENT_DISPLAY[id] || id,
+        affinity: index === 0 ? 'best' : index === 1 ? 'good' : 'acceptable',
+    }));
+}
+/**
+ * Get the domain of a skill.
+ */
+function getSkillDomain(skill) {
+    return SKILL_DOMAIN[skill] || 'specialized';
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function suggestAlternativeSkill(currentSkill) {
+    const alternatives = {
+        'cm-tdd': 'cm-debugging',
+        'cm-debugging': 'cm-tdd',
+        'cm-execution': 'cm-planning',
+        'cm-safe-deploy': 'cm-quality-gate',
+        'cm-quality-gate': 'cm-debugging',
+    };
+    return alternatives[currentSkill];
+}
+function guessdomainFromTitle(title) {
+    const fTitle = title.toLowerCase();
+    if (/test|bug|fix|error|debug/.test(fTitle))
+        return 'engineering';
+    if (/deploy|ci|cd|release|docker/.test(fTitle))
+        return 'operations';
+    if (/design|ui|ux|plan|feature/.test(fTitle))
+        return 'product';
+    if (/content|marketing|seo|ads|tracking/.test(fTitle))
+        return 'growth';
+    if (/i18n|translate|review|docs/.test(fTitle))
+        return 'orchestration';
+    return 'engineering'; // default
+}
+/**
+ * Suggest transitions for stuck tasks based on heuristics:
+ * - in-progress > 60 min + dispatched → suggest "review"
+ * - in-progress > 120 min → suggest "review" even without dispatch
+ * - review > 30 min → suggest "done"
+ */
+function suggestTransitions(tasks) {
+    const now = Date.now();
+    const suggestions = [];
+    for (const task of tasks) {
+        const elapsed = now - new Date(task.updatedAt).getTime();
+        const minutes = Math.round(elapsed / 60000);
+        if (task.column === 'in-progress') {
+            if (task.dispatchStatus === 'dispatched' && elapsed > 60 * 60 * 1000) {
+                suggestions.push({
+                    taskId: task.id, from: 'in-progress', to: 'review',
+                    reason: `Dispatched ${minutes}m ago, likely completed. Move to review?`,
+                    confidence: 0.7, stuckMinutes: minutes,
+                });
+            }
+            else if (elapsed > 120 * 60 * 1000) {
+                suggestions.push({
+                    taskId: task.id, from: 'in-progress', to: 'review',
+                    reason: `Stuck for ${minutes}m. Consider moving to review or back to backlog.`,
+                    confidence: 0.6, stuckMinutes: minutes,
+                });
+            }
+        }
+        if (task.column === 'review' && elapsed > 30 * 60 * 1000) {
+            suggestions.push({
+                taskId: task.id, from: 'review', to: 'done',
+                reason: `In review for ${minutes}m. Ready to mark as done?`,
+                confidence: 0.5, stuckMinutes: minutes,
+            });
+        }
+    }
+    return suggestions.sort((a, b) => b.stuckMinutes - a.stuckMinutes);
+}
+// ─── Chain Suggestions ───────────────────────────────────────────────────
+// TRIZ #10: Preliminary Action — analyze task before dispatch
+/**
+ * Suggest the best chain for a task based on its title.
+ * Returns the matching chain definition or undefined.
+ */
+function suggestChain(taskTitle) {
+    return (0, skill_chain_1.matchChain)(taskTitle);
+}

package/dist/parallel-dispatch.js

@@ -0,0 +1,359 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeDependencies = analyzeDependencies;
+exports.buildDependencyGraph = buildDependencyGraph;
+exports.preFlightCheck = preFlightCheck;
+exports.detectConflicts = detectConflicts;
+exports.adaptBatchSize = adaptBatchSize;
+exports.dispatchParallelBatch = dispatchParallelBatch;
+exports.initConflictLedger = initConflictLedger;
+exports.readConflictLedger = readConflictLedger;
+exports.registerExpectedFiles = registerExpectedFiles;
+exports.reportModifiedFiles = reportModifiedFiles;
+exports.clearConflictLedger = clearConflictLedger;
+exports.readParallelHistory = readParallelHistory;
+exports.recordParallelSession = recordParallelSession;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const agent_dispatch_1 = require("./agent-dispatch");
+const continuity_1 = require("./continuity");
+// ─── Constants ──────────────────────────────────────────────────────────────
+const PARALLEL_HISTORY_FILE = 'parallel-history.json';
+const PARALLEL_LEDGER_FILE = 'parallel-ledger.json';
+const DEFAULT_BATCH_SIZE = 2;
+const MIN_BATCH_SIZE = 1;
+const MAX_BATCH_SIZE = 5;
+const CLEAN_RUNS_TO_SCALE_UP = 3;
+const DEFAULT_QUALITY_CONTRACT = {
+    mustPassSyntax: true,
+    mustPassTests: true,
+    mustSelfReview: true,
+    maxModifiedFiles: 10,
+    timeoutMs: 300000, // 5 minutes
+};
+// ─── TRIZ #1: Segmentation — Dependency Analysis ───────────────────────────
+/**
+ * Analyzes task descriptions to extract file paths that each task will modify.
+ * Uses pattern matching on common file path formats.
+ *
+ * TRIZ Principle #1 (Segmentation): Divide the system into independent parts.
+ */
+function analyzeDependencies(tasks) {
+    var _a;
+    const depMap = new Map();
+    // Common file path patterns in task descriptions
+    const filePatterns = [
+        // Explicit file paths: src/foo/bar.ts, ./components/Button.tsx
+        /(?:^|\s|[`"'(])([a-zA-Z0-9_./-]+\.[a-zA-Z]{1,10})(?:\s|[`"')]|$)/g,
+        // Backtick-quoted paths: `src/index.ts`
+        /`([a-zA-Z0-9_./-]+\.[a-zA-Z]{1,10})`/g,
+    ];
+    // File extensions we care about
+    const codeExtensions = new Set([
+        'ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs',
+        'json', 'yaml', 'yml', 'toml',
+        'css', 'scss', 'less',
+        'html', 'vue', 'svelte', 'astro',
+        'md', 'mdx',
+    ]);
+    for (const task of tasks) {
+        const searchText = `${task.title}\n${task.description}`;
+        const files = new Set();
+        for (const pattern of filePatterns) {
+            // Reset lastIndex for global regex
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(searchText)) !== null) {
+                const filePath = match[1];
+                const ext = ((_a = filePath.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+                if (codeExtensions.has(ext) && !filePath.startsWith('http')) {
+                    // Normalize path separators
+                    files.add(filePath.replace(/\\/g, '/'));
+                }
+            }
+        }
+        depMap.set(task.id, Array.from(files));
+    }
+    return depMap;
+}
+// ─── TRIZ #1: Segmentation — Build Dependency Graph ────────────────────────
+/**
+ * Groups tasks into independent batches where no two tasks in the same batch
+ * modify the same file. Uses greedy graph coloring for optimal grouping.
+ *
+ * TRIZ Principle #1 (Segmentation): Only truly independent tasks in same batch.
+ */
+function buildDependencyGraph(tasks, depMap, batchSize = DEFAULT_BATCH_SIZE) {
+    // Build adjacency: two tasks conflict if they share any affected file
+    const conflicts = new Map();
+    for (const task of tasks) {
+        conflicts.set(task.id, new Set());
+    }
+    for (let i = 0; i < tasks.length; i++) {
+        const filesA = new Set(depMap.get(tasks[i].id) || []);
+        for (let j = i + 1; j < tasks.length; j++) {
+            const filesB = depMap.get(tasks[j].id) || [];
+            const overlap = filesB.some(f => filesA.has(f));
+            if (overlap) {
+                conflicts.get(tasks[i].id).add(tasks[j].id);
+                conflicts.get(tasks[j].id).add(tasks[i].id);
+            }
+        }
+    }
+    // Greedy graph coloring → assign each task to a batch
+    const batchAssignment = new Map();
+    let maxBatch = 0;
+    // Sort tasks by number of conflicts (most constrained first)
+    const sortedTasks = [...tasks].sort((a, b) => {
+        var _a, _b;
+        const conflictsA = ((_a = conflicts.get(a.id)) === null || _a === void 0 ? void 0 : _a.size) || 0;
+        const conflictsB = ((_b = conflicts.get(b.id)) === null || _b === void 0 ? void 0 : _b.size) || 0;
+        return conflictsB - conflictsA;
+    });
+    for (const task of sortedTasks) {
+        const taskConflicts = conflicts.get(task.id);
+        // Find used batch numbers among conflicting tasks
+        const usedBatches = new Set();
+        for (const conflictId of taskConflicts) {
+            const batch = batchAssignment.get(conflictId);
+            if (batch !== undefined)
+                usedBatches.add(batch);
+        }
+        // Assign to first available batch
+        let assigned = 0;
+        while (usedBatches.has(assigned))
+            assigned++;
+        batchAssignment.set(task.id, assigned);
+        maxBatch = Math.max(maxBatch, assigned);
+    }
+    // Group into batches, respecting batchSize limit
+    const rawBatches = Array.from({ length: maxBatch + 1 }, () => []);
+    for (const task of tasks) {
+        const batchNum = batchAssignment.get(task.id) || 0;
+        rawBatches[batchNum].push(task);
+    }
+    // Split large batches by batchSize limit
+    const finalBatches = [];
+    let batchCounter = 0;
+    for (const rawBatch of rawBatches) {
+        for (let i = 0; i < rawBatch.length; i += batchSize) {
+            const slice = rawBatch.slice(i, i + batchSize);
+            const batchId = `batch-${batchCounter++}`;
+            const parallelTasks = slice.map(task => (Object.assign(Object.assign({}, task), { affectedFiles: depMap.get(task.id) || [], batchId, qualityContract: Object.assign({}, DEFAULT_QUALITY_CONTRACT) })));
+            finalBatches.push(parallelTasks);
+        }
+    }
+    return {
+        batches: finalBatches,
+        totalTasks: tasks.length,
+        batchSize,
+        independentGroups: maxBatch + 1,
+    };
+}
+// ─── TRIZ #10: Prior Action — Pre-flight Check ─────────────────────────────
+/**
+ * Checks for potential conflicts BEFORE dispatching a batch.
+ * Reads the current conflict ledger and ensures no overlap with running agents.
+ *
+ * TRIZ Principle #10 (Prior Action): Place objects before they are needed.
+ */
+function preFlightCheck(batch, projectPath) {
+    const ledger = readConflictLedger(projectPath);
+    const detectedConflicts = [];
+    // Check against already-running agents
+    for (const task of batch) {
+        for (const [existingTaskId, existingFiles] of Object.entries(ledger.entries)) {
+            const overlap = task.affectedFiles.filter(f => existingFiles.includes(f));
+            if (overlap.length > 0) {
+                detectedConflicts.push({
+                    taskA: existingTaskId,
+                    taskB: task.id,
+                    overlappingFiles: overlap,
+                    detectedAt: new Date().toISOString(),
+                });
+            }
+        }
+    }
+    return {
+        safe: detectedConflicts.length === 0,
+        conflicts: detectedConflicts,
+    };
+}
+// ─── TRIZ #18: Feedback — Conflict Detection ───────────────────────────────
+/**
+ * Detects conflicts in the conflict ledger after agents report their modified files.
+ *
+ * TRIZ Principle #18 (Mechanical Vibration / Feedback):
+ * If an action is insufficient, use periodic/feedback-driven correction.
+ */
+function detectConflicts(ledger) {
+    const conflicts = [];
+    const entries = Object.entries(ledger.entries);
+    for (let i = 0; i < entries.length; i++) {
+        const [taskIdA, filesA] = entries[i];
+        const setA = new Set(filesA);
+        for (let j = i + 1; j < entries.length; j++) {
+            const [taskIdB, filesB] = entries[j];
+            const overlap = filesB.filter(f => setA.has(f));
+            if (overlap.length > 0) {
+                conflicts.push({
+                    taskA: taskIdA,
+                    taskB: taskIdB,
+                    overlappingFiles: overlap,
+                    detectedAt: new Date().toISOString(),
+                });
+            }
+        }
+    }
+    return conflicts;
+}
+// ─── TRIZ #15: Dynamicity — Adaptive Batch Sizing ──────────────────────────
+/**
+ * Adapts batch size based on conflict history.
+ * - 3 clean runs → increase batch size by 1 (max 5)
+ * - Any conflict → decrease by 1 (min 1)
+ *
+ * TRIZ Principle #15 (Dynamicity): Allow characteristics to change
+ * to be optimal at each stage.
+ */
+function adaptBatchSize(history) {
+    const sessions = history.sessions;
+    if (sessions.length === 0)
+        return DEFAULT_BATCH_SIZE;
+    const lastSession = sessions[sessions.length - 1];
+    // If last session had conflicts → decrease
+    if (lastSession.conflictCount > 0) {
+        return Math.max(MIN_BATCH_SIZE, lastSession.batchSize - 1);
+    }
+    // Count consecutive clean sessions
+    let cleanCount = 0;
+    for (let i = sessions.length - 1; i >= 0; i--) {
+        if (sessions[i].conflictCount === 0) {
+            cleanCount++;
+        }
+        else {
+            break;
+        }
+    }
+    // 3+ clean → scale up
+    if (cleanCount >= CLEAN_RUNS_TO_SCALE_UP) {
+        return Math.min(MAX_BATCH_SIZE, lastSession.batchSize + 1);
+    }
+    return lastSession.batchSize;
+}
+// ─── Dispatch Parallel Batch ────────────────────────────────────────────────
+/**
+ * Dispatches a batch of independent tasks in parallel.
+ * Each task gets its own .agent-tasks file with parallel context.
+ */
+function dispatchParallelBatch(batch, project, force = false) {
+    var _a;
+    const batchId = ((_a = batch[0]) === null || _a === void 0 ? void 0 : _a.batchId) || `batch-${crypto_1.default.randomUUID().substring(0, 8)}`;
+    const dispatched = [];
+    const failed = [];
+    // TRIZ #10: Pre-flight check
+    const preflight = preFlightCheck(batch, project.path);
+    if (!preflight.safe) {
+        return {
+            success: false,
+            batchId,
+            dispatched: [],
+            failed: batch.map(t => t.id),
+            conflicts: preflight.conflicts,
+            error: `Pre-flight check failed: ${preflight.conflicts.length} potential conflict(s) detected`,
+        };
+    }
+    // Initialize conflict ledger for this batch
+    initConflictLedger(project.path, batchId);
+    // Dispatch each task
+    for (const task of batch) {
+        // Register expected files in the ledger BEFORE dispatch
+        registerExpectedFiles(project.path, task.id, task.affectedFiles);
+        const result = (0, agent_dispatch_1.dispatchTaskToAgent)(task, project, force);
+        if (result.success) {
+            dispatched.push(task.id);
+        }
+        else {
+            failed.push(task.id);
+        }
+    }
+    return {
+        success: failed.length === 0,
+        batchId,
+        dispatched,
+        failed,
+        conflicts: [],
+    };
+}
+// ─── Conflict Ledger Persistence ────────────────────────────────────────────
+function getLedgerPath(projectPath) {
+    return path_1.default.join((0, continuity_1.getCmDir)(projectPath), PARALLEL_LEDGER_FILE);
+}
+function initConflictLedger(projectPath, sessionId) {
+    (0, continuity_1.ensureCmDir)(projectPath);
+    const ledger = {
+        sessionId,
+        startedAt: new Date().toISOString(),
+        entries: {},
+        conflicts: [],
+    };
+    fs_1.default.writeFileSync(getLedgerPath(projectPath), JSON.stringify(ledger, null, 2));
+}
+function readConflictLedger(projectPath) {
+    const ledgerPath = getLedgerPath(projectPath);
+    try {
+        if (fs_1.default.existsSync(ledgerPath)) {
+            return JSON.parse(fs_1.default.readFileSync(ledgerPath, 'utf-8'));
+        }
+    }
+    catch ( /* empty */_a) { /* empty */ }
+    return { sessionId: '', startedAt: '', entries: {}, conflicts: [] };
+}
+function registerExpectedFiles(projectPath, taskId, files) {
+    const ledger = readConflictLedger(projectPath);
+    ledger.entries[taskId] = files;
+    fs_1.default.writeFileSync(getLedgerPath(projectPath), JSON.stringify(ledger, null, 2));
+}
+function reportModifiedFiles(projectPath, taskId, actualFiles) {
+    const ledger = readConflictLedger(projectPath);
+    ledger.entries[taskId] = actualFiles;
+    // Detect conflicts after update
+    const conflicts = detectConflicts(ledger);
+    ledger.conflicts = conflicts;
+    fs_1.default.writeFileSync(getLedgerPath(projectPath), JSON.stringify(ledger, null, 2));
+    return conflicts;
+}
+function clearConflictLedger(projectPath) {
+    const ledgerPath = getLedgerPath(projectPath);
+    if (fs_1.default.existsSync(ledgerPath)) {
+        fs_1.default.unlinkSync(ledgerPath);
+    }
+}
+// ─── Parallel History Persistence ───────────────────────────────────────────
+function getHistoryPath(projectPath) {
+    return path_1.default.join((0, continuity_1.getCmDir)(projectPath), PARALLEL_HISTORY_FILE);
+}
+function readParallelHistory(projectPath) {
+    const historyPath = getHistoryPath(projectPath);
+    try {
+        if (fs_1.default.existsSync(historyPath)) {
+            return JSON.parse(fs_1.default.readFileSync(historyPath, 'utf-8'));
+        }
+    }
+    catch ( /* empty */_a) { /* empty */ }
+    return { sessions: [] };
+}
+function recordParallelSession(projectPath, session) {
+    (0, continuity_1.ensureCmDir)(projectPath);
+    const history = readParallelHistory(projectPath);
+    history.sessions.push(session);
+    // Keep max 50 sessions
+    if (history.sessions.length > 50) {
+        history.sessions = history.sessions.slice(-50);
+    }
+    fs_1.default.writeFileSync(getHistoryPath(projectPath), JSON.stringify(history, null, 2));
+}