maxsimcli 4.6.0 → 4.7.1

package/dist/core/verify.js

@@ -1,754 +0,0 @@
-"use strict";
-/**
- * Verify — Verification suite, consistency, and health validation
- *
- * Ported from maxsim/bin/lib/verify.cjs
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cmdVerifySummary = cmdVerifySummary;
-exports.cmdVerifyPlanStructure = cmdVerifyPlanStructure;
-exports.cmdVerifyPhaseCompleteness = cmdVerifyPhaseCompleteness;
-exports.cmdVerifyReferences = cmdVerifyReferences;
-exports.cmdVerifyCommits = cmdVerifyCommits;
-exports.cmdVerifyArtifacts = cmdVerifyArtifacts;
-exports.cmdVerifyKeyLinks = cmdVerifyKeyLinks;
-exports.cmdValidateConsistency = cmdValidateConsistency;
-exports.cmdValidateHealth = cmdValidateHealth;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const core_js_1 = require("./core.js");
-const frontmatter_js_1 = require("./frontmatter.js");
-const types_js_1 = require("./types.js");
-// ─── Verify Summary ──────────────────────────────────────────────────────────
-async function cmdVerifySummary(cwd, summaryPath, checkFileCount) {
-    if (!summaryPath) {
-        return (0, types_js_1.cmdErr)('summary-path required');
-    }
-    const fullPath = node_path_1.default.join(cwd, summaryPath);
-    const checkCount = checkFileCount || 2;
-    if (!node_fs_1.default.existsSync(fullPath)) {
-        const result = {
-            passed: false,
-            checks: {
-                summary_exists: false,
-                files_created: { checked: 0, found: 0, missing: [] },
-                commits_exist: false,
-                self_check: 'not_found',
-            },
-            errors: ['SUMMARY.md not found'],
-        };
-        return (0, types_js_1.cmdOk)(result, 'failed');
-    }
-    const content = node_fs_1.default.readFileSync(fullPath, 'utf-8');
-    const errors = [];
-    // Spot-check files mentioned in summary
-    const mentionedFiles = new Set();
-    const patterns = [
-        /`([^`]+\.[a-zA-Z]+)`/g,
-        /(?:Created|Modified|Added|Updated|Edited):\s*`?([^\s`]+\.[a-zA-Z]+)`?/gi,
-    ];
-    for (const pattern of patterns) {
-        let m;
-        while ((m = pattern.exec(content)) !== null) {
-            const filePath = m[1];
-            if (filePath && !filePath.startsWith('http') && filePath.includes('/')) {
-                mentionedFiles.add(filePath);
-            }
-        }
-    }
-    const filesToCheck = Array.from(mentionedFiles).slice(0, checkCount);
-    const missing = [];
-    for (const file of filesToCheck) {
-        if (!node_fs_1.default.existsSync(node_path_1.default.join(cwd, file))) {
-            missing.push(file);
-        }
-    }
-    // Check commits exist
-    const commitHashPattern = /\b[0-9a-f]{7,40}\b/g;
-    const hashes = content.match(commitHashPattern) || [];
-    let commitsExist = false;
-    if (hashes.length > 0) {
-        for (const hash of hashes.slice(0, 3)) {
-            const result = await (0, core_js_1.execGit)(cwd, ['cat-file', '-t', hash]);
-            if (result.exitCode === 0 && result.stdout === 'commit') {
-                commitsExist = true;
-                break;
-            }
-        }
-    }
-    // Self-check section
-    let selfCheck = 'not_found';
-    const selfCheckPattern = /##\s*(?:Self[- ]?Check|Verification|Quality Check)/i;
-    if (selfCheckPattern.test(content)) {
-        const passPattern = /(?:all\s+)?(?:pass|✓|✅|complete|succeeded)/i;
-        const failPattern = /(?:fail|✗|❌|incomplete|blocked)/i;
-        const checkSection = content.slice(content.search(selfCheckPattern));
-        if (failPattern.test(checkSection)) {
-            selfCheck = 'failed';
-        }
-        else if (passPattern.test(checkSection)) {
-            selfCheck = 'passed';
-        }
-    }
-    if (missing.length > 0)
-        errors.push('Missing files: ' + missing.join(', '));
-    if (!commitsExist && hashes.length > 0)
-        errors.push('Referenced commit hashes not found in git history');
-    if (selfCheck === 'failed')
-        errors.push('Self-check section indicates failure');
-    const checks = {
-        summary_exists: true,
-        files_created: { checked: filesToCheck.length, found: filesToCheck.length - missing.length, missing },
-        commits_exist: commitsExist,
-        self_check: selfCheck,
-    };
-    const passed = missing.length === 0 && selfCheck !== 'failed';
-    const result = { passed, checks, errors };
-    return (0, types_js_1.cmdOk)(result, passed ? 'passed' : 'failed');
-}
-// ─── Verify Plan Structure ───────────────────────────────────────────────────
-function cmdVerifyPlanStructure(cwd, filePath) {
-    if (!filePath) {
-        return (0, types_js_1.cmdErr)('file path required');
-    }
-    const fullPath = node_path_1.default.isAbsolute(filePath) ? filePath : node_path_1.default.join(cwd, filePath);
-    const content = (0, core_js_1.safeReadFile)(fullPath);
-    if (!content) {
-        return (0, types_js_1.cmdOk)({ error: 'File not found', path: filePath });
-    }
-    const fm = (0, frontmatter_js_1.extractFrontmatter)(content);
-    const errors = [];
-    const warnings = [];
-    const required = ['phase', 'plan', 'type', 'wave', 'depends_on', 'files_modified', 'autonomous', 'must_haves'];
-    for (const field of required) {
-        if (fm[field] === undefined)
-            errors.push(`Missing required frontmatter field: ${field}`);
-    }
-    const taskPattern = /<task[^>]*>([\s\S]*?)<\/task>/g;
-    const tasks = [];
-    let taskMatch;
-    while ((taskMatch = taskPattern.exec(content)) !== null) {
-        const taskContent = taskMatch[1];
-        const nameMatch = taskContent.match(/<name>([\s\S]*?)<\/name>/);
-        const taskName = nameMatch ? nameMatch[1].trim() : 'unnamed';
-        const hasFiles = /<files>/.test(taskContent);
-        const hasAction = /<action>/.test(taskContent);
-        const hasVerify = /<verify>/.test(taskContent);
-        const hasDone = /<done>/.test(taskContent);
-        if (!nameMatch)
-            errors.push('Task missing <name> element');
-        if (!hasAction)
-            errors.push(`Task '${taskName}' missing <action>`);
-        if (!hasVerify)
-            warnings.push(`Task '${taskName}' missing <verify>`);
-        if (!hasDone)
-            warnings.push(`Task '${taskName}' missing <done>`);
-        if (!hasFiles)
-            warnings.push(`Task '${taskName}' missing <files>`);
-        tasks.push({ name: taskName, hasFiles, hasAction, hasVerify, hasDone });
-    }
-    if (tasks.length === 0)
-        warnings.push('No <task> elements found');
-    if (fm.wave && parseInt(String(fm.wave)) > 1 && (!fm.depends_on || (Array.isArray(fm.depends_on) && fm.depends_on.length === 0))) {
-        warnings.push('Wave > 1 but depends_on is empty');
-    }
-    const hasCheckpoints = /<task\s+type=["']?checkpoint/.test(content);
-    if (hasCheckpoints && fm.autonomous !== 'false' && fm.autonomous !== false) {
-        errors.push('Has checkpoint tasks but autonomous is not false');
-    }
-    const result = {
-        valid: errors.length === 0,
-        errors,
-        warnings,
-        task_count: tasks.length,
-        tasks,
-        frontmatter_fields: Object.keys(fm),
-    };
-    return (0, types_js_1.cmdOk)(result, errors.length === 0 ? 'valid' : 'invalid');
-}
-// ─── Verify Phase Completeness ───────────────────────────────────────────────
-function cmdVerifyPhaseCompleteness(cwd, phase) {
-    if (!phase) {
-        return (0, types_js_1.cmdErr)('phase required');
-    }
-    const phaseInfo = (0, core_js_1.findPhaseInternal)(cwd, phase);
-    if (!phaseInfo) {
-        return (0, types_js_1.cmdOk)({ error: 'Phase not found', phase });
-    }
-    const errors = [];
-    const warnings = [];
-    const phaseDir = node_path_1.default.join(cwd, phaseInfo.directory);
-    let files;
-    try {
-        files = node_fs_1.default.readdirSync(phaseDir);
-    }
-    catch {
-        return (0, types_js_1.cmdOk)({ error: 'Cannot read phase directory' });
-    }
-    const plans = files.filter(f => (0, core_js_1.isPlanFile)(f));
-    const summaries = files.filter(f => (0, core_js_1.isSummaryFile)(f));
-    const planIds = new Set(plans.map(p => (0, core_js_1.planId)(p)));
-    const summaryIds = new Set(summaries.map(s => (0, core_js_1.summaryId)(s)));
-    const incompletePlans = [...planIds].filter(id => !summaryIds.has(id));
-    if (incompletePlans.length > 0) {
-        errors.push(`Plans without summaries: ${incompletePlans.join(', ')}`);
-    }
-    const orphanSummaries = [...summaryIds].filter(id => !planIds.has(id));
-    if (orphanSummaries.length > 0) {
-        warnings.push(`Summaries without plans: ${orphanSummaries.join(', ')}`);
-    }
-    const result = {
-        complete: errors.length === 0,
-        phase: phaseInfo.phase_number,
-        plan_count: plans.length,
-        summary_count: summaries.length,
-        incomplete_plans: incompletePlans,
-        orphan_summaries: orphanSummaries,
-        errors,
-        warnings,
-    };
-    return (0, types_js_1.cmdOk)(result, errors.length === 0 ? 'complete' : 'incomplete');
-}
-// ─── Verify References ───────────────────────────────────────────────────────
-function cmdVerifyReferences(cwd, filePath) {
-    if (!filePath) {
-        return (0, types_js_1.cmdErr)('file path required');
-    }
-    const fullPath = node_path_1.default.isAbsolute(filePath) ? filePath : node_path_1.default.join(cwd, filePath);
-    const content = (0, core_js_1.safeReadFile)(fullPath);
-    if (!content) {
-        return (0, types_js_1.cmdOk)({ error: 'File not found', path: filePath });
-    }
-    const found = [];
-    const missing = [];
-    const atRefs = content.match(/@([^\s\n,)]+\/[^\s\n,)]+)/g) || [];
-    for (const ref of atRefs) {
-        const cleanRef = ref.slice(1);
-        const resolved = cleanRef.startsWith('~/')
-            ? node_path_1.default.join(process.env.HOME || '', cleanRef.slice(2))
-            : node_path_1.default.join(cwd, cleanRef);
-        if (node_fs_1.default.existsSync(resolved)) {
-            found.push(cleanRef);
-        }
-        else {
-            missing.push(cleanRef);
-        }
-    }
-    const backtickRefs = content.match(/`([^`]+\/[^`]+\.[a-zA-Z]{1,10})`/g) || [];
-    for (const ref of backtickRefs) {
-        const cleanRef = ref.slice(1, -1);
-        if (cleanRef.startsWith('http') || cleanRef.includes('${') || cleanRef.includes('{{'))
-            continue;
-        if (found.includes(cleanRef) || missing.includes(cleanRef))
-            continue;
-        const resolved = node_path_1.default.join(cwd, cleanRef);
-        if (node_fs_1.default.existsSync(resolved)) {
-            found.push(cleanRef);
-        }
-        else {
-            missing.push(cleanRef);
-        }
-    }
-    const result = {
-        valid: missing.length === 0,
-        found: found.length,
-        missing,
-        total: found.length + missing.length,
-    };
-    return (0, types_js_1.cmdOk)(result, missing.length === 0 ? 'valid' : 'invalid');
-}
-// ─── Verify Commits ──────────────────────────────────────────────────────────
-async function cmdVerifyCommits(cwd, hashes) {
-    if (!hashes || hashes.length === 0) {
-        return (0, types_js_1.cmdErr)('At least one commit hash required');
-    }
-    const valid = [];
-    const invalid = [];
-    for (const hash of hashes) {
-        const result = await (0, core_js_1.execGit)(cwd, ['cat-file', '-t', hash]);
-        if (result.exitCode === 0 && result.stdout.trim() === 'commit') {
-            valid.push(hash);
-        }
-        else {
-            invalid.push(hash);
-        }
-    }
-    const commitResult = {
-        all_valid: invalid.length === 0,
-        valid,
-        invalid,
-        total: hashes.length,
-    };
-    return (0, types_js_1.cmdOk)(commitResult, invalid.length === 0 ? 'valid' : 'invalid');
-}
-function cmdVerifyArtifacts(cwd, planFilePath) {
-    if (!planFilePath) {
-        return (0, types_js_1.cmdErr)('plan file path required');
-    }
-    const fullPath = node_path_1.default.isAbsolute(planFilePath) ? planFilePath : node_path_1.default.join(cwd, planFilePath);
-    const content = (0, core_js_1.safeReadFile)(fullPath);
-    if (!content) {
-        return (0, types_js_1.cmdOk)({ error: 'File not found', path: planFilePath });
-    }
-    const artifacts = (0, frontmatter_js_1.parseMustHavesBlock)(content, 'artifacts');
-    if (artifacts.length === 0) {
-        return (0, types_js_1.cmdOk)({ error: 'No must_haves.artifacts found in frontmatter', path: planFilePath });
-    }
-    const results = [];
-    for (const artifact of artifacts) {
-        if (typeof artifact === 'string')
-            continue;
-        const artObj = artifact;
-        const artPath = artObj.path;
-        if (!artPath)
-            continue;
-        const artFullPath = node_path_1.default.join(cwd, artPath);
-        const exists = node_fs_1.default.existsSync(artFullPath);
-        const check = { path: artPath, exists, issues: [], passed: false };
-        if (exists) {
-            const fileContent = (0, core_js_1.safeReadFile)(artFullPath) || '';
-            const lineCount = fileContent.split('\n').length;
-            if (artObj.min_lines && lineCount < artObj.min_lines) {
-                check.issues.push(`Only ${lineCount} lines, need ${artObj.min_lines}`);
-            }
-            if (artObj.contains && !fileContent.includes(artObj.contains)) {
-                check.issues.push(`Missing pattern: ${artObj.contains}`);
-            }
-            if (artObj.exports) {
-                const exportList = Array.isArray(artObj.exports) ? artObj.exports : [artObj.exports];
-                for (const exp of exportList) {
-                    if (!fileContent.includes(exp))
-                        check.issues.push(`Missing export: ${exp}`);
-                }
-            }
-            check.passed = check.issues.length === 0;
-        }
-        else {
-            check.issues.push('File not found');
-        }
-        results.push(check);
-    }
-    const passed = results.filter(r => r.passed).length;
-    const artifactsResult = {
-        all_passed: passed === results.length,
-        passed,
-        total: results.length,
-        artifacts: results,
-    };
-    return (0, types_js_1.cmdOk)(artifactsResult, passed === results.length ? 'valid' : 'invalid');
-}
-function cmdVerifyKeyLinks(cwd, planFilePath) {
-    if (!planFilePath) {
-        return (0, types_js_1.cmdErr)('plan file path required');
-    }
-    const fullPath = node_path_1.default.isAbsolute(planFilePath) ? planFilePath : node_path_1.default.join(cwd, planFilePath);
-    const content = (0, core_js_1.safeReadFile)(fullPath);
-    if (!content) {
-        return (0, types_js_1.cmdOk)({ error: 'File not found', path: planFilePath });
-    }
-    const keyLinks = (0, frontmatter_js_1.parseMustHavesBlock)(content, 'key_links');
-    if (keyLinks.length === 0) {
-        return (0, types_js_1.cmdOk)({ error: 'No must_haves.key_links found in frontmatter', path: planFilePath });
-    }
-    const results = [];
-    for (const link of keyLinks) {
-        if (typeof link === 'string')
-            continue;
-        const linkObj = link;
-        const check = {
-            from: linkObj.from || '',
-            to: linkObj.to || '',
-            via: linkObj.via || '',
-            verified: false,
-            detail: '',
-        };
-        const sourceContent = (0, core_js_1.safeReadFile)(node_path_1.default.join(cwd, linkObj.from || ''));
-        if (!sourceContent) {
-            check.detail = 'Source file not found';
-        }
-        else if (linkObj.pattern) {
-            try {
-                const regex = new RegExp(linkObj.pattern);
-                if (regex.test(sourceContent)) {
-                    check.verified = true;
-                    check.detail = 'Pattern found in source';
-                }
-                else {
-                    const targetContent = (0, core_js_1.safeReadFile)(node_path_1.default.join(cwd, linkObj.to || ''));
-                    if (targetContent && regex.test(targetContent)) {
-                        check.verified = true;
-                        check.detail = 'Pattern found in target';
-                    }
-                    else {
-                        check.detail = `Pattern "${linkObj.pattern}" not found in source or target`;
-                    }
-                }
-            }
-            catch {
-                check.detail = `Invalid regex pattern: ${linkObj.pattern}`;
-            }
-        }
-        else {
-            if (sourceContent.includes(linkObj.to || '')) {
-                check.verified = true;
-                check.detail = 'Target referenced in source';
-            }
-            else {
-                check.detail = 'Target not referenced in source';
-            }
-        }
-        results.push(check);
-    }
-    const verified = results.filter(r => r.verified).length;
-    const linksResult = {
-        all_verified: verified === results.length,
-        verified,
-        total: results.length,
-        links: results,
-    };
-    return (0, types_js_1.cmdOk)(linksResult, verified === results.length ? 'valid' : 'invalid');
-}
-// ─── Validate Consistency ────────────────────────────────────────────────────
-function cmdValidateConsistency(cwd) {
-    const rmPath = (0, core_js_1.roadmapPath)(cwd);
-    const phasesDir = (0, core_js_1.phasesPath)(cwd);
-    const errors = [];
-    const warnings = [];
-    if (!node_fs_1.default.existsSync(rmPath)) {
-        errors.push('ROADMAP.md not found');
-        return (0, types_js_1.cmdOk)({ passed: false, errors, warnings }, 'failed');
-    }
-    const roadmapContent = node_fs_1.default.readFileSync(rmPath, 'utf-8');
-    const roadmapPhases = new Set();
-    const phasePattern = (0, core_js_1.getPhasePattern)();
-    let m;
-    while ((m = phasePattern.exec(roadmapContent)) !== null) {
-        roadmapPhases.add(m[1]);
-    }
-    const diskPhases = new Set();
-    try {
-        const dirs = (0, core_js_1.listSubDirs)(phasesDir);
-        for (const dir of dirs) {
-            const dm = dir.match(/^(\d+[A-Z]?(?:\.\d+)?)/i);
-            if (dm)
-                diskPhases.add(dm[1]);
-        }
-    }
-    catch (e) {
-        /* optional op, ignore */
-        (0, core_js_1.debugLog)(e);
-    }
-    for (const p of roadmapPhases) {
-        if (!diskPhases.has(p) && !diskPhases.has((0, core_js_1.normalizePhaseName)(p))) {
-            warnings.push(`Phase ${p} in ROADMAP.md but no directory on disk`);
-        }
-    }
-    for (const p of diskPhases) {
-        const unpadded = String(parseInt(p, 10));
-        if (!roadmapPhases.has(p) && !roadmapPhases.has(unpadded)) {
-            warnings.push(`Phase ${p} exists on disk but not in ROADMAP.md`);
-        }
-    }
-    const integerPhases = [...diskPhases]
-        .filter(p => !p.includes('.'))
-        .map(p => parseInt(p, 10))
-        .sort((a, b) => a - b);
-    for (let i = 1; i < integerPhases.length; i++) {
-        if (integerPhases[i] !== integerPhases[i - 1] + 1) {
-            warnings.push(`Gap in phase numbering: ${integerPhases[i - 1]} → ${integerPhases[i]}`);
-        }
-    }
-    try {
-        const dirs = (0, core_js_1.listSubDirs)(phasesDir, true);
-        for (const dir of dirs) {
-            const phaseFiles = node_fs_1.default.readdirSync(node_path_1.default.join(phasesDir, dir));
-            const plans = phaseFiles.filter(f => (0, core_js_1.isPlanFile)(f)).sort();
-            const planNums = plans.map(p => {
-                const pm = p.match(/-(\d{2})-PLAN\.md$/);
-                return pm ? parseInt(pm[1], 10) : null;
-            }).filter((n) => n !== null);
-            for (let i = 1; i < planNums.length; i++) {
-                if (planNums[i] !== planNums[i - 1] + 1) {
-                    warnings.push(`Gap in plan numbering in ${dir}: plan ${planNums[i - 1]} → ${planNums[i]}`);
-                }
-            }
-            const summaries = phaseFiles.filter(f => (0, core_js_1.isSummaryFile)(f));
-            const planIdsSet = new Set(plans.map(p => (0, core_js_1.planId)(p)));
-            const summaryIdsSet = new Set(summaries.map(s => (0, core_js_1.summaryId)(s)));
-            for (const sid of summaryIdsSet) {
-                if (!planIdsSet.has(sid)) {
-                    warnings.push(`Summary ${sid}-SUMMARY.md in ${dir} has no matching PLAN.md`);
-                }
-            }
-        }
-    }
-    catch (e) {
-        /* optional op, ignore */
-        (0, core_js_1.debugLog)(e);
-    }
-    try {
-        const dirs = (0, core_js_1.listSubDirs)(phasesDir);
-        for (const dir of dirs) {
-            const phaseFiles = node_fs_1.default.readdirSync(node_path_1.default.join(phasesDir, dir));
-            const plans = phaseFiles.filter(f => (0, core_js_1.isPlanFile)(f));
-            for (const plan of plans) {
-                const content = node_fs_1.default.readFileSync(node_path_1.default.join(phasesDir, dir, plan), 'utf-8');
-                const fm = (0, frontmatter_js_1.extractFrontmatter)(content);
-                if (!fm.wave) {
-                    warnings.push(`${dir}/${plan}: missing 'wave' in frontmatter`);
-                }
-            }
-        }
-    }
-    catch (e) {
-        /* optional op, ignore */
-        (0, core_js_1.debugLog)(e);
-    }
-    const passed = errors.length === 0;
-    const result = { passed, errors, warnings, warning_count: warnings.length };
-    return (0, types_js_1.cmdOk)(result, passed ? 'passed' : 'failed');
-}
-// ─── Validate Health ─────────────────────────────────────────────────────────
-function cmdValidateHealth(cwd, options) {
-    const planningDir = (0, core_js_1.planningPath)(cwd);
-    const projectPath = (0, core_js_1.planningPath)(cwd, 'PROJECT.md');
-    const rmPath = (0, core_js_1.roadmapPath)(cwd);
-    const stPath = (0, core_js_1.statePath)(cwd);
-    const cfgPath = (0, core_js_1.configPath)(cwd);
-    const phasesDir = (0, core_js_1.phasesPath)(cwd);
-    const errors = [];
-    const warnings = [];
-    const info = [];
-    const repairs = [];
-    const addIssue = (severity, code, message, fix, repairable = false) => {
-        const issue = { code, message, fix, repairable };
-        if (severity === 'error')
-            errors.push(issue);
-        else if (severity === 'warning')
-            warnings.push(issue);
-        else
-            info.push(issue);
-    };
-    // Check 1: .planning/ exists
-    if (!node_fs_1.default.existsSync(planningDir)) {
-        addIssue('error', 'E001', '.planning/ directory not found', 'Run /maxsim:new-project to initialize');
-        return (0, types_js_1.cmdOk)({
-            status: 'broken',
-            errors,
-            warnings,
-            info,
-            repairable_count: 0,
-        });
-    }
-    // Check 2: PROJECT.md
-    if (!node_fs_1.default.existsSync(projectPath)) {
-        addIssue('error', 'E002', 'PROJECT.md not found', 'Run /maxsim:new-project to create');
-    }
-    else {
-        const content = node_fs_1.default.readFileSync(projectPath, 'utf-8');
-        const requiredSections = ['## What This Is', '## Core Value', '## Requirements'];
-        for (const section of requiredSections) {
-            if (!content.includes(section)) {
-                addIssue('warning', 'W001', `PROJECT.md missing section: ${section}`, 'Add section manually');
-            }
-        }
-    }
-    // Check 3: ROADMAP.md
-    if (!node_fs_1.default.existsSync(rmPath)) {
-        addIssue('error', 'E003', 'ROADMAP.md not found', 'Run /maxsim:new-milestone to create roadmap');
-    }
-    // Check 4: STATE.md
-    if (!node_fs_1.default.existsSync(stPath)) {
-        addIssue('error', 'E004', 'STATE.md not found', 'Run /maxsim:health --repair to regenerate', true);
-        repairs.push('regenerateState');
-    }
-    else {
-        const stateContent = node_fs_1.default.readFileSync(stPath, 'utf-8');
-        const phaseRefs = [...stateContent.matchAll(/[Pp]hase\s+(\d+(?:\.\d+)?)/g)].map(m => m[1]);
-        const diskPhases = new Set();
-        try {
-            for (const dir of (0, core_js_1.listSubDirs)(phasesDir)) {
-                const dm = dir.match(/^(\d+(?:\.\d+)?)/);
-                if (dm)
-                    diskPhases.add(dm[1]);
-            }
-        }
-        catch (e) {
-            /* optional op, ignore */
-            (0, core_js_1.debugLog)(e);
-        }
-        for (const ref of phaseRefs) {
-            const normalizedRef = String(parseInt(ref, 10)).padStart(2, '0');
-            if (!diskPhases.has(ref) && !diskPhases.has(normalizedRef) && !diskPhases.has(String(parseInt(ref, 10)))) {
-                if (diskPhases.size > 0) {
-                    addIssue('warning', 'W002', `STATE.md references phase ${ref}, but only phases ${[...diskPhases].sort().join(', ')} exist`, 'Run /maxsim:health --repair to regenerate STATE.md', true);
-                    if (!repairs.includes('regenerateState'))
-                        repairs.push('regenerateState');
-                }
-            }
-        }
-    }
-    // Check 5: config.json
-    if (!node_fs_1.default.existsSync(cfgPath)) {
-        addIssue('warning', 'W003', 'config.json not found', 'Run /maxsim:health --repair to create with defaults', true);
-        repairs.push('createConfig');
-    }
-    else {
-        try {
-            const rawContent = node_fs_1.default.readFileSync(cfgPath, 'utf-8');
-            const parsed = JSON.parse(rawContent);
-            const validProfiles = ['quality', 'balanced', 'budget', 'tokenburner'];
-            if (parsed.model_profile && !validProfiles.includes(parsed.model_profile)) {
-                addIssue('warning', 'W004', `config.json: invalid model_profile "${parsed.model_profile}"`, `Valid values: ${validProfiles.join(', ')}`);
-            }
-        }
-        catch (thrown) {
-            const parseErr = thrown;
-            addIssue('error', 'E005', `config.json: JSON parse error - ${parseErr.message}`, 'Run /maxsim:health --repair to reset to defaults', true);
-            repairs.push('resetConfig');
-        }
-    }
-    // Check 6: Phase directory naming
-    try {
-        for (const dirName of (0, core_js_1.listSubDirs)(phasesDir)) {
-            if (!dirName.match(/^\d{2}(?:\.\d+)?-[\w-]+$/)) {
-                addIssue('warning', 'W005', `Phase directory "${dirName}" doesn't follow NN-name format`, 'Rename to match pattern (e.g., 01-setup)');
-            }
-        }
-    }
-    catch (e) {
-        /* optional op, ignore */
-        (0, core_js_1.debugLog)(e);
-    }
-    // Check 7: Orphaned plans
-    try {
-        const orphanDirs = (0, core_js_1.listSubDirs)(phasesDir);
-        for (const dirName of orphanDirs) {
-            const phaseFiles = node_fs_1.default.readdirSync(node_path_1.default.join(phasesDir, dirName));
-            const plans = phaseFiles.filter(f => (0, core_js_1.isPlanFile)(f));
-            const summaries = phaseFiles.filter(f => (0, core_js_1.isSummaryFile)(f));
-            const summaryBases = new Set(summaries.map(s => (0, core_js_1.summaryId)(s)));
-            for (const plan of plans) {
-                const planBase = (0, core_js_1.planId)(plan);
-                if (!summaryBases.has(planBase)) {
-                    addIssue('info', 'I001', `${dirName}/${plan} has no SUMMARY.md`, 'May be in progress');
-                }
-            }
-        }
-    }
-    catch (e) {
-        /* optional op, ignore */
-        (0, core_js_1.debugLog)(e);
-    }
-    // Check 8: Roadmap consistency
-    if (node_fs_1.default.existsSync(rmPath)) {
-        const roadmapContent = node_fs_1.default.readFileSync(rmPath, 'utf-8');
-        const roadmapPhases = new Set();
-        const phasePattern = (0, core_js_1.getPhasePattern)();
-        let m;
-        while ((m = phasePattern.exec(roadmapContent)) !== null) {
-            roadmapPhases.add(m[1]);
-        }
-        const diskPhases = new Set();
-        try {
-            for (const dir of (0, core_js_1.listSubDirs)(phasesDir)) {
-                const dm = dir.match(/^(\d+[A-Z]?(?:\.\d+)?)/i);
-                if (dm)
-                    diskPhases.add(dm[1]);
-            }
-        }
-        catch (e) {
-            /* optional op, ignore */
-            (0, core_js_1.debugLog)(e);
-        }
-        for (const p of roadmapPhases) {
-            const padded = String(parseInt(p, 10)).padStart(2, '0');
-            if (!diskPhases.has(p) && !diskPhases.has(padded)) {
-                addIssue('warning', 'W006', `Phase ${p} in ROADMAP.md but no directory on disk`, 'Create phase directory or remove from roadmap');
-            }
-        }
-        for (const p of diskPhases) {
-            const unpadded = String(parseInt(p, 10));
-            if (!roadmapPhases.has(p) && !roadmapPhases.has(unpadded)) {
-                addIssue('warning', 'W007', `Phase ${p} exists on disk but not in ROADMAP.md`, 'Add to roadmap or remove directory');
-            }
-        }
-    }
-    // Perform repairs if requested
-    const repairActions = [];
-    if (options.repair && repairs.length > 0) {
-        for (const repair of repairs) {
-            try {
-                switch (repair) {
-                    case 'createConfig':
-                    case 'resetConfig': {
-                        const defaults = {
-                            model_profile: 'balanced',
-                            commit_docs: true,
-                            search_gitignored: false,
-                            branching_strategy: 'none',
-                            research: true,
-                            plan_checker: true,
-                            verifier: true,
-                            parallelization: true,
-                        };
-                        node_fs_1.default.writeFileSync(cfgPath, JSON.stringify(defaults, null, 2), 'utf-8');
-                        repairActions.push({ action: repair, success: true, path: 'config.json' });
-                        break;
-                    }
-                    case 'regenerateState': {
-                        if (node_fs_1.default.existsSync(stPath)) {
-                            const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-                            const backupPath = `${stPath}.bak-${timestamp}`;
-                            node_fs_1.default.copyFileSync(stPath, backupPath);
-                            repairActions.push({ action: 'backupState', success: true, path: backupPath });
-                        }
-                        const milestone = (0, core_js_1.getMilestoneInfo)(cwd);
-                        let stateContent = `# Session State\n\n`;
-                        stateContent += `## Project Reference\n\n`;
-                        stateContent += `See: .planning/PROJECT.md\n\n`;
-                        stateContent += `## Position\n\n`;
-                        stateContent += `**Milestone:** ${milestone.version} ${milestone.name}\n`;
-                        stateContent += `**Current phase:** (determining...)\n`;
-                        stateContent += `**Status:** Resuming\n\n`;
-                        stateContent += `## Session Log\n\n`;
-                        stateContent += `- ${(0, core_js_1.todayISO)()}: STATE.md regenerated by /maxsim:health --repair\n`;
-                        node_fs_1.default.writeFileSync(stPath, stateContent, 'utf-8');
-                        repairActions.push({ action: repair, success: true, path: 'STATE.md' });
-                        break;
-                    }
-                }
-            }
-            catch (thrown) {
-                const repairErr = thrown;
-                repairActions.push({ action: repair, success: false, error: repairErr.message });
-            }
-        }
-    }
-    // Determine overall status
-    let status;
-    if (errors.length > 0) {
-        status = 'broken';
-    }
-    else if (warnings.length > 0) {
-        status = 'degraded';
-    }
-    else {
-        status = 'healthy';
-    }
-    const repairableCount = errors.filter(e => e.repairable).length +
-        warnings.filter(w => w.repairable).length;
-    const result = {
-        status,
-        errors,
-        warnings,
-        info,
-        repairable_count: repairableCount,
-        repairs_performed: repairActions.length > 0 ? repairActions : undefined,
-    };
-    return (0, types_js_1.cmdOk)(result);
-}
-//# sourceMappingURL=verify.js.map