sanook-cli 0.5.1 → 0.5.2

package/dist/brain-eval.js

@@ -0,0 +1,186 @@
+import { readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { FOLDERS } from './brain.js';
+import { validateFinalGateContent } from './brain-final.js';
+import { checkBrainFolders, checkSearchIndexFreshness, checkVaultStructureMap } from './brain-doctor.js';
+import { inspectBrainContext } from './brain-context.js';
+import { search } from './search/engine.js';
+import { INDEX_PATH } from './search/store.js';
+const STATIC_CASES = ['SB-01', 'SB-02', 'SB-03', 'SB-04', 'SB-05', 'SB-06', 'SB-07', 'SB-08', 'SB-09', 'SB-10'];
+const RETRIEVAL_CASES = [
+    { id: 'RET-01', query: 'memory write protocol merge dont append', expectedPath: 'Shared/Rules/memory-write-protocol.md' },
+    { id: 'RET-02', query: 'context assembly policy small context', expectedPath: 'Shared/Rules/context-assembly-policy.md' },
+    { id: 'RET-03', query: 'quality ledger retrieval hit grounded', expectedPath: 'Evals/quality-ledger.md' },
+];
+async function fileExists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function caseResult(id, title, passed, evidence = [], details = [], partial = false) {
+    const status = passed ? 'pass' : partial ? 'partial' : 'fail';
+    return {
+        id,
+        title,
+        status,
+        score: status === 'pass' ? 1 : status === 'partial' ? 0.5 : 0,
+        maxScore: 1,
+        evidence,
+        details,
+    };
+}
+function summarize(cases, brainPath) {
+    const score = cases.reduce((sum, item) => sum + item.score, 0);
+    const maxScore = cases.reduce((sum, item) => sum + item.maxScore, 0);
+    const percent = maxScore ? (score / maxScore) * 100 : 0;
+    return { ok: cases.every((item) => item.status === 'pass'), brainPath, score, maxScore, percent, cases };
+}
+async function benchmarkFileCase(brainPath) {
+    const path = join(brainPath, 'Evals', 'second-brain-benchmarks.md');
+    const content = await readText(path);
+    if (!content)
+        return caseResult('SB-00', 'Benchmark file exists', false, [path]);
+    const missing = STATIC_CASES.filter((id) => !content.includes(id));
+    return caseResult('SB-00', 'Benchmark file exists and names static cases', missing.length === 0, [path], missing.length ? [`missing case ids: ${missing.join(', ')}`] : [], missing.length > 0 && missing.length < STATIC_CASES.length);
+}
+async function routingCase(brainPath) {
+    const folderCheck = await checkBrainFolders(brainPath);
+    const mapCheck = await checkVaultStructureMap(brainPath);
+    const missingIndexes = [];
+    for (const folder of FOLDERS) {
+        if (!(await fileExists(join(brainPath, folder.dir, '_Index.md'))))
+            missingIndexes.push(`${folder.dir}/_Index.md`);
+    }
+    const pass = folderCheck.status === 'pass' && mapCheck.status === 'pass' && missingIndexes.length === 0;
+    return caseResult('SB-02', 'Routing map and destination indexes are complete', pass, [join(brainPath, 'Vault Structure Map.md')], [...(folderCheck.details ?? []), ...(mapCheck.details ?? []), ...missingIndexes], folderCheck.status === 'pass' || mapCheck.status === 'pass');
+}
+async function requiredFilesCase(brainPath, id, title, relPaths, tokens = []) {
+    const missing = [];
+    const evidence = [];
+    const tokenMisses = [];
+    for (const rel of relPaths) {
+        const path = join(brainPath, rel);
+        const content = await readText(path);
+        if (!content) {
+            missing.push(rel);
+            continue;
+        }
+        evidence.push(path);
+        for (const token of tokens) {
+            if (!content.toLowerCase().includes(token.toLowerCase()))
+                tokenMisses.push(`${rel}: missing "${token}"`);
+        }
+    }
+    const details = [...missing.map((m) => `missing ${m}`), ...tokenMisses];
+    return caseResult(id, title, details.length === 0, evidence, details, evidence.length > 0 && missing.length < relPaths.length);
+}
+async function finalGateCase(brainPath) {
+    const relPaths = ['Templates/final.md', 'Templates/final-lite.md', 'Shared/Tech-Standards/verification-standard.md'];
+    const evidence = [];
+    const details = [];
+    for (const rel of relPaths) {
+        const path = join(brainPath, rel);
+        const content = await readText(path);
+        if (!content) {
+            details.push(`missing ${rel}`);
+            continue;
+        }
+        evidence.push(path);
+        if (!content.includes('If a row has no evidence'))
+            details.push(`${rel}: missing evidence rule`);
+    }
+    for (const rel of ['Templates/final.md', 'Templates/final-lite.md']) {
+        const content = await readText(join(brainPath, rel));
+        if (!content)
+            continue;
+        const validation = validateFinalGateContent(content.replace('note_type: template', 'note_type: final-gate'));
+        const structuralWarnings = validation.warnings.filter((warning) => warning.startsWith('Missing'));
+        details.push(...structuralWarnings.map((warning) => `${rel}: ${warning}`));
+    }
+    return caseResult('SB-FINAL', 'Final gate templates and validator contract exist', details.length === 0, evidence, details, evidence.length > 0);
+}
+async function contextCase(brainPath, indexPath) {
+    const report = await inspectBrainContext({ brainPath, indexPath });
+    const structuralWarnings = report.warnings.filter((warning) => !warning.includes('Search index is missing') && !warning.includes('Search index is older'));
+    return caseResult('SB-09', 'Hot context assembles without missing or oversized sources', report.ok && report.contextChars > 0 && structuralWarnings.length === 0, report.sources.map((source) => source.path), structuralWarnings, report.contextChars > 0);
+}
+async function indexCase(brainPath, indexPath) {
+    const check = await checkSearchIndexFreshness(brainPath, indexPath);
+    return caseResult('SB-IDX', 'Search index exists and is fresh enough', check.status === 'pass', [indexPath], check.status === 'pass' ? [] : [check.message, ...(check.details ?? [])], check.status === 'warn');
+}
+async function retrievalCase(brainPath, item, searchImpl) {
+    const res = await searchImpl(item.query, { mode: 'fts', limit: 5, sources: ['vault'] });
+    const hit = res.hits.find((candidate) => candidate.path === item.expectedPath);
+    return caseResult(item.id, `Retrieval finds ${item.expectedPath}`, !!hit, hit ? [join(brainPath, hit.path ?? item.expectedPath)] : [], hit ? [] : [`query="${item.query}" did not return ${item.expectedPath}`], res.hits.length > 0);
+}
+export async function runBrainEval(options = {}) {
+    const brainPath = options.brainPath;
+    if (!brainPath) {
+        return summarize([
+            caseResult('SB-CONFIG', 'Second-brain path is configured', false, [], ['Run `sanook brain init [path]` first.']),
+        ]);
+    }
+    try {
+        if (!(await stat(brainPath)).isDirectory()) {
+            return summarize([
+                caseResult('SB-CONFIG', 'Second-brain path is a directory', false, [brainPath], ['Configured brainPath is not a directory.']),
+            ], brainPath);
+        }
+    }
+    catch {
+        return summarize([
+            caseResult('SB-CONFIG', 'Second-brain path exists', false, [brainPath], ['Configured brainPath does not exist.']),
+        ], brainPath);
+    }
+    const indexPath = options.indexPath ?? INDEX_PATH;
+    const cases = [
+        await benchmarkFileCase(brainPath),
+        await requiredFilesCase(brainPath, 'SB-01', 'AI context entrypoint exists', ['Shared/AI-Context-Index.md'], ['Vault Structure Map']),
+        await routingCase(brainPath),
+        await requiredFilesCase(brainPath, 'SB-03', 'Memory write protocol is documented', ['Shared/Rules/memory-write-protocol.md'], ['ADD', 'UPDATE', 'DELETE', 'NOOP']),
+        await requiredFilesCase(brainPath, 'SB-04', 'External ingest quarantine/provenance path exists', ['Runbooks/ingest-quarantine.md', 'Shared/Provenance/ingest-log.md']),
+        await requiredFilesCase(brainPath, 'SB-05', 'Coding verification standard exists', ['Shared/Tech-Standards/verification-standard.md']),
+        await requiredFilesCase(brainPath, 'SB-06', 'Owner-facing response examples exist', ['Shared/User-Memory/response-examples.md']),
+        await requiredFilesCase(brainPath, 'SB-07', 'Framework improvement evidence paths exist', ['Evals/quality-ledger.md', 'Research/_Index.md', 'Sessions/_Index.md']),
+        await requiredFilesCase(brainPath, 'SB-08', 'Multi-agent coordination paths exist', ['Shared/Coordination/task-board.md', 'Shared/Coordination/task-board/_Index.md']),
+        await contextCase(brainPath, indexPath),
+        await requiredFilesCase(brainPath, 'SB-10', 'Learning loop ledger and session index exist', ['Evals/quality-ledger.md', 'Sessions/_Index.md']),
+        await finalGateCase(brainPath),
+        await indexCase(brainPath, indexPath),
+    ];
+    if (options.runRetrieval !== false) {
+        const searchImpl = options.searchImpl ?? search;
+        for (const item of RETRIEVAL_CASES)
+            cases.push(await retrievalCase(brainPath, item, searchImpl));
+    }
+    return summarize(cases, brainPath);
+}
+function statusLabel(status) {
+    return status.toUpperCase().padEnd(7);
+}
+export function formatBrainEvalReport(report) {
+    const lines = [
+        'Sanook brain eval',
+        `vault: ${report.brainPath ?? '(not configured)'}`,
+        `score: ${report.score.toFixed(1)}/${report.maxScore} (${report.percent.toFixed(1)}%)`,
+    ];
+    for (const item of report.cases) {
+        lines.push(`[${statusLabel(item.status)}] ${item.id} — ${item.title}`);
+        for (const evidence of item.evidence ?? [])
+            lines.push(`       ${evidence}`);
+        for (const detail of item.details ?? [])
+            lines.push(`       - ${detail}`);
+    }
+    return lines.join('\n');
+}

package/dist/brain-final.js

@@ -0,0 +1,371 @@
+import { execFile } from 'node:child_process';
+import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const TEMPLATE_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', 'second-brain', 'Templates');
+const FINAL_HEADINGS = [
+    '## 1. Objective / DoD Lock',
+    '## 2. Evidence-Backed Checklist',
+    '## 3. Status Matrix',
+    '## 4. Evidence Matrix',
+    '## 5. Residual Risk',
+    '## 6. Change Summary Audit',
+    '## 7. Final Answer Draft',
+    '## 8. Second-Brain Routing / Memory Closeout',
+];
+const STATUS_TOKENS = new Set(['PASS', 'PARTIAL', 'FAIL', 'N/A', 'BLOCKED', 'TODO']);
+const PASS_STATUS = 'PASS';
+export function parseBrainFinalArgs(args) {
+    const positional = [];
+    const parsed = { fromDiff: false, lite: false, force: false };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--from-diff') {
+            parsed.fromDiff = true;
+        }
+        else if (arg === '--lite') {
+            parsed.lite = true;
+        }
+        else if (arg === '--force') {
+            parsed.force = true;
+        }
+        else if (arg === '--task') {
+            const value = args[++i];
+            if (!value?.trim())
+                return { ok: false, message: 'ต้องระบุค่าให้ --task' };
+            parsed.task = value.trim();
+        }
+        else if (arg.startsWith('--task=')) {
+            const value = arg.slice('--task='.length).trim();
+            if (!value)
+                return { ok: false, message: 'ต้องระบุค่าให้ --task' };
+            parsed.task = value;
+        }
+        else if (arg === '--output') {
+            const value = args[++i];
+            if (!value?.trim())
+                return { ok: false, message: 'ต้องระบุค่าให้ --output' };
+            parsed.output = value.trim();
+        }
+        else if (arg.startsWith('--output=')) {
+            const value = arg.slice('--output='.length).trim();
+            if (!value)
+                return { ok: false, message: 'ต้องระบุค่าให้ --output' };
+            parsed.output = value;
+        }
+        else if (arg === '--') {
+            positional.push(...args.slice(i + 1));
+            break;
+        }
+        else if (arg.startsWith('-')) {
+            return { ok: false, message: `ไม่รู้จัก option: ${arg}` };
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    const positionalTask = positional.join(' ').trim();
+    if (parsed.task && positionalTask)
+        return { ok: false, message: 'ระบุ task ได้ครั้งเดียว: ใช้ positional หรือ --task อย่างใดอย่างหนึ่ง' };
+    if (positionalTask)
+        parsed.task = positionalTask;
+    return { ok: true, value: parsed };
+}
+export async function createBrainFinal(options) {
+    const task = (options.task ?? 'current task').trim() || 'current task';
+    const template = options.lite ? 'final-lite.md' : 'final.md';
+    const warnings = [];
+    if (!options.brainPath) {
+        return { ok: false, task, template, fromDiff: !!options.fromDiff, diffFiles: [], indexed: false, warnings: ['No second-brain path is configured.'] };
+    }
+    const brainPath = resolve(options.brainPath);
+    if (!(await pathExistsAsDir(brainPath))) {
+        return {
+            ok: false,
+            brainPath,
+            task,
+            template,
+            fromDiff: !!options.fromDiff,
+            diffFiles: [],
+            indexed: false,
+            warnings: ['Configured second-brain path does not exist or is not a directory.'],
+        };
+    }
+    const today = options.today ?? new Date().toISOString().slice(0, 10);
+    const slug = slugify(task || 'final-gate');
+    const output = outputPath(brainPath, options.output ?? join('Sessions', `${today}-${slug}-final.md`));
+    if (!output.ok) {
+        return { ok: false, brainPath, task, template, fromDiff: !!options.fromDiff, diffFiles: [], indexed: false, warnings: [output.message] };
+    }
+    if ((await fileExists(output.path)) && !options.force) {
+        return {
+            ok: false,
+            brainPath,
+            path: output.path,
+            relPath: vaultRel(brainPath, output.path),
+            task,
+            template,
+            fromDiff: !!options.fromDiff,
+            diffFiles: [],
+            indexed: false,
+            warnings: ['Final gate file already exists. Re-run with --force or choose --output.'],
+        };
+    }
+    const diffFiles = options.fromDiff
+        ? uniqueSorted(options.diffFiles ?? (await (options.diffProvider ?? defaultDiffFiles)()))
+        : [];
+    const raw = await readTemplate(brainPath, template);
+    let content = instantiateTemplate(raw, { today, task, template, fromDiff: !!options.fromDiff, diffFiles });
+    if (template === 'final-lite.md')
+        content = content.replace('note_type: template', 'note_type: final-gate-lite');
+    else
+        content = content.replace('note_type: template', 'note_type: final-gate');
+    await mkdir(dirname(output.path), { recursive: true });
+    await writeFile(output.path, content, 'utf8');
+    const relPath = vaultRel(brainPath, output.path);
+    const indexed = await maybeAppendSessionIndex(brainPath, relPath, task);
+    if (options.fromDiff && diffFiles.length === 0)
+        warnings.push('No git worktree changes were detected for --from-diff.');
+    return { ok: true, brainPath, path: output.path, relPath, task, template, fromDiff: !!options.fromDiff, diffFiles, indexed, warnings };
+}
+export function formatBrainFinalReport(report) {
+    const lines = ['Sanook brain final'];
+    lines.push(`vault: ${report.brainPath ?? '(not configured)'}`);
+    lines.push(`task: ${report.task}`);
+    lines.push(`template: ${report.template}`);
+    if (report.path)
+        lines.push(`created: ${report.path}`);
+    if (report.relPath)
+        lines.push(`link: [[${report.relPath.replace(/\.md$/i, '')}]]`);
+    if (report.fromDiff)
+        lines.push(`from-diff: ${report.diffFiles.length} file(s)`);
+    if (report.indexed)
+        lines.push('sessions-index: updated');
+    for (const warning of report.warnings)
+        lines.push(`warning: ${warning}`);
+    return lines.join('\n');
+}
+export async function listFinalGateFiles(brainPath) {
+    const sessionsDir = join(brainPath, 'Sessions');
+    const entries = await readdir(sessionsDir, { withFileTypes: true }).catch(() => []);
+    const out = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.md') || entry.name === '_Index.md')
+            continue;
+        const relPath = `Sessions/${entry.name}`;
+        const path = join(brainPath, relPath);
+        const content = await readText(path);
+        if (isFinalGateContent(content, entry.name))
+            out.push({ relPath, path, content });
+    }
+    return out.sort((a, b) => a.relPath.localeCompare(b.relPath));
+}
+export function validateFinalGateContent(content) {
+    const warnings = [];
+    for (const heading of FINAL_HEADINGS) {
+        if (!content.includes(heading))
+            warnings.push(`Missing final gate section: ${heading}`);
+    }
+    if (!content.includes('## Final Verdict'))
+        warnings.push('Missing final verdict section.');
+    if (!content.includes('If a row has no evidence'))
+        warnings.push('Missing explicit evidence rule: "If a row has no evidence".');
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        if (!isTableHeader(lines, i))
+            continue;
+        const headers = tableCells(lines[i]).map((cell) => normalizeHeader(cell));
+        const statusIndex = headers.findIndex((header) => header === 'status' || header === 'verdict');
+        const evidenceIndex = headers.findIndex((header) => header === 'evidence' || header === 'important output' || header === 'scope proven');
+        if (statusIndex < 0)
+            continue;
+        for (let j = i + 2; j < lines.length && lines[j].trim().startsWith('|'); j++) {
+            const cells = tableCells(lines[j]);
+            if (!cells.length || isSeparatorRow(cells))
+                continue;
+            const status = normalizeStatus(cells[statusIndex]);
+            if (!status)
+                continue;
+            const rowName = cells[0]?.replace(/`/g, '').trim() || `row ${j + 1}`;
+            if (status === 'TODO')
+                warnings.push(`TODO status remains in final gate row: ${rowName}`);
+            if (status === PASS_STATUS && evidenceIndex >= 0 && isPlaceholderEvidence(cells[evidenceIndex] ?? '')) {
+                warnings.push(`PASS row has no evidence: ${rowName}`);
+            }
+        }
+    }
+    const placeholders = content.match(/<[^>\n]+>/g) ?? [];
+    const meaningfulPlaceholders = placeholders.filter(isTemplatePlaceholder);
+    if (meaningfulPlaceholders.length)
+        warnings.push(`Unfilled placeholder(s) remain: ${uniqueSorted(meaningfulPlaceholders).slice(0, 5).join(', ')}`);
+    return { ok: warnings.length === 0, warnings };
+}
+function instantiateTemplate(raw, options) {
+    const titleTask = options.task;
+    let content = raw
+        .replaceAll('YYYY-MM-DD', options.today)
+        .replaceAll('<task/topic>', titleTask)
+        .replace('tags: [template, final-gate, verification, dod]', 'tags: [final-gate, verification, dod]')
+        .replace('tags: [template, final-gate, verification, lite]', 'tags: [final-gate, verification, lite]')
+        .replace('parent: "[[Templates/_Index]]"', 'parent: "[[Sessions/_Index]]"')
+        .replace('up:: [[Templates/_Index]]', 'up:: [[Sessions/_Index]]')
+        .replace('<paste owner request or goal text here>', options.task);
+    if (options.fromDiff)
+        content = injectDiffEvidence(content, options.diffFiles);
+    return content;
+}
+function injectDiffEvidence(content, diffFiles) {
+    const fileRows = diffFiles.length
+        ? diffFiles.map((file) => `| \`${file}\` | TODO: summarize change | \`git status --short\` / \`git diff -- ${file}\` |`).join('\n')
+        : '| `(no git worktree changes detected)` | N/A | `git status --short` |';
+    const commandRows = diffFiles.length
+        ? '| `git status --short` | TODO | Populated by `--from-diff`; review before marking PASS. | Current worktree changed paths. |'
+        : '| `git status --short` | N/A | No changed paths detected by `--from-diff`. | Worktree scan only. |';
+    return replaceFilesChangedRows(content.replace('| `<command>` | TODO |  |  |', commandRows), fileRows);
+}
+function replaceFilesChangedRows(content, fileRows) {
+    const fullPattern = /(Files changed:\n\n\| File\/path \| Change summary \| Evidence \|\n\|---\|---\|---\|\n)\| `(?:<path>|<file>)` \|  \|  \|/;
+    const litePattern = /(Changed files:\n\n\| File \| Change summary \| Evidence \|\n\|---\|---\|---\|\n)\| `(?:<path>|<file>)` \|  \|  \|/;
+    return content.replace(fullPattern, `$1${fileRows}`).replace(litePattern, `$1${fileRows}`);
+}
+async function readTemplate(brainPath, template) {
+    const vaultTemplate = join(brainPath, 'Templates', template);
+    const fromVault = await readText(vaultTemplate);
+    if (fromVault)
+        return fromVault;
+    return readFile(join(TEMPLATE_ROOT, template), 'utf8');
+}
+async function defaultDiffFiles() {
+    try {
+        const { stdout } = await execFileAsync('git', ['status', '--porcelain=v1'], { cwd: process.cwd(), encoding: 'utf8' });
+        return stdout
+            .split('\n')
+            .map((line) => line.trimEnd())
+            .filter(Boolean)
+            .map(parsePorcelainPath)
+            .filter((path) => !!path);
+    }
+    catch {
+        return [];
+    }
+}
+function parsePorcelainPath(line) {
+    const raw = line.slice(3).trim();
+    if (!raw)
+        return undefined;
+    const renameIndex = raw.lastIndexOf(' -> ');
+    return renameIndex >= 0 ? raw.slice(renameIndex + 4) : raw;
+}
+function outputPath(brainPath, output) {
+    const path = resolve(isAbsolute(output) ? output : join(brainPath, output));
+    const rel = relative(brainPath, path);
+    if (rel.startsWith('..') || isAbsolute(rel))
+        return { ok: false, message: '--output must stay inside the configured second-brain vault.' };
+    return { ok: true, path };
+}
+async function maybeAppendSessionIndex(brainPath, relPath, task) {
+    if (!relPath.startsWith('Sessions/') || relPath.endsWith('/_Index.md'))
+        return false;
+    const indexPath = join(brainPath, 'Sessions', '_Index.md');
+    const content = await readText(indexPath);
+    if (!content)
+        return false;
+    const note = relPath.replace(/\.md$/i, '');
+    const link = `[[${note}]]`;
+    if (content.includes(link))
+        return false;
+    const line = `- ${link} — final gate: ${task}`;
+    const marker = '\nup:: [[Home]]';
+    const next = content.includes(marker) ? content.replace(marker, `\n${line}\n${marker}`) : `${content.trimEnd()}\n${line}\n`;
+    await writeFile(indexPath, next, 'utf8');
+    return true;
+}
+function slugify(value) {
+    const slug = value
+        .normalize('NFKD')
+        .toLowerCase()
+        .replace(/[^\p{Letter}\p{Number}]+/gu, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80)
+        .replace(/-+$/g, '');
+    return slug || 'final-gate';
+}
+function vaultRel(brainPath, path) {
+    return relative(brainPath, path).split(sep).join('/');
+}
+function isFinalGateContent(content, fileName) {
+    return (/^note_type:\s*final-gate/m.test(content) ||
+        /^note_type:\s*final-gate-lite/m.test(content) ||
+        (content.includes('## Final Verdict') && content.includes('## 1. Objective / DoD Lock')) ||
+        /-final\.md$/i.test(fileName));
+}
+function isTableHeader(lines, index) {
+    return lines[index]?.trim().startsWith('|') && isSeparatorRow(tableCells(lines[index + 1] ?? ''));
+}
+function tableCells(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('|'))
+        return [];
+    return trimmed
+        .split('|')
+        .slice(1, -1)
+        .map((cell) => cell.trim());
+}
+function isSeparatorRow(cells) {
+    return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim()));
+}
+function normalizeHeader(value) {
+    return value.replace(/`/g, '').trim().toLowerCase();
+}
+function normalizeStatus(value) {
+    const cleaned = value.replace(/`/g, '').trim().toUpperCase();
+    return STATUS_TOKENS.has(cleaned) ? cleaned : undefined;
+}
+function isPlaceholderEvidence(value) {
+    const cleaned = value
+        .replace(/`/g, '')
+        .replace(/<[^>]+>/g, (item) => (isTemplatePlaceholder(item) ? '' : item))
+        .trim();
+    return !cleaned || cleaned === '-' || cleaned === '—' || /^TODO\b/i.test(cleaned) || cleaned === '|';
+}
+function isTemplatePlaceholder(value) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner || inner.includes('e.g.'))
+        return false;
+    if (/^[a-z][a-z0-9+.-]*:\/\/\S+$/i.test(inner))
+        return false;
+    if (/^mailto:\S+$/i.test(inner))
+        return false;
+    if (/^[^\s@<>]+@[^\s@<>]+\.[^\s@<>]+$/.test(inner))
+        return false;
+    return true;
+}
+async function pathExistsAsDir(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function fileExists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function uniqueSorted(values) {
+    return [...new Set(values.filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}