sanook-cli 0.5.1 → 0.5.5

package/dist/brain-final.js

@@ -0,0 +1,377 @@
+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';
+import { inlineValue, takeValue } from './cli-option-values.js';
+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' || arg.startsWith('--task=')) {
+            const next = arg === '--task' ? takeValue(args, i) : undefined;
+            const value = next ? next.value : inlineValue('--task', arg);
+            if (next)
+                i = next.nextIndex;
+            if (!value?.trim())
+                return { ok: false, message: 'ต้องระบุค่าให้ --task' };
+            if (parsed.task)
+                return { ok: false, message: 'ระบุ task ได้ครั้งเดียว: ใช้ --task เพียงครั้งเดียว' };
+            parsed.task = value.trim();
+        }
+        else if (arg === '--output') {
+            const next = takeValue(args, i);
+            const value = next.value;
+            i = next.nextIndex;
+            if (!value?.trim())
+                return { ok: false, message: 'ต้องระบุค่าให้ --output' };
+            if (parsed.output !== undefined)
+                return { ok: false, message: 'ระบุ output ได้ครั้งเดียว: ใช้ --output เพียงครั้งเดียว' };
+            parsed.output = value.trim();
+        }
+        else if (arg.startsWith('--output=')) {
+            const value = arg.slice('--output='.length).trim();
+            if (!value)
+                return { ok: false, message: 'ต้องระบุค่าให้ --output' };
+            if (parsed.output !== undefined)
+                return { ok: false, message: 'ระบุ output ได้ครั้งเดียว: ใช้ --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));
+}

package/dist/brain-metrics.js

@@ -0,0 +1,277 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { checkSearchIndexFreshness } from './brain-doctor.js';
+import { runBrainEval } from './brain-eval.js';
+import { INDEX_PATH, sanitizeManifest } from './search/store.js';
+const DAY_MS = 24 * 60 * 60 * 1000;
+const SKIP_DIRS = new Set(['.git', '.obsidian', 'node_modules', 'Shared/Context7-Docs']);
+const ARCHIVE_EXEMPT_PREFIXES = ['Shared/Core-Facts/', 'Shared/Archive/'];
+function sectionBullets(content, heading) {
+    const lines = content.split('\n');
+    const start = lines.findIndex((line) => line.trim().toLowerCase() === `## ${heading.toLowerCase()}`);
+    if (start < 0)
+        return [];
+    const out = [];
+    for (const line of lines.slice(start + 1)) {
+        if (/^#{1,6}\s+/.test(line.trim()))
+            break;
+        const trimmed = line.trim();
+        if (trimmed.startsWith('- ') && !trimmed.includes('_('))
+            out.push(trimmed);
+    }
+    return out;
+}
+function parseFrontmatterField(content, field) {
+    const match = content.match(new RegExp(`^${field}:\\s*(.+)$`, 'm'));
+    return match?.[1]?.trim().replace(/^["']|["']$/g, '');
+}
+function parseIsoDate(value) {
+    if (!value)
+        return undefined;
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) ? ms : undefined;
+}
+function topFolder(relPath) {
+    const parts = relPath.split('/');
+    return parts.length > 1 ? parts[0] : relPath;
+}
+async function listMarkdown(root) {
+    const out = [];
+    async function walk(abs, rel) {
+        let entries;
+        try {
+            entries = await readdir(abs, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (entry.name.startsWith('.') || SKIP_DIRS.has(entry.name) || SKIP_DIRS.has(childRel))
+                    continue;
+                await walk(join(abs, entry.name), childRel);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                out.push(childRel);
+            }
+        }
+    }
+    await walk(root, '');
+    return out.sort();
+}
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+async function mtimeMs(path) {
+    try {
+        return (await stat(path)).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+async function readManifest(indexPath) {
+    try {
+        const raw = JSON.parse(await readFile(indexPath, 'utf8'));
+        return sanitizeManifest(raw.manifest);
+    }
+    catch {
+        return null;
+    }
+}
+async function collectCounts(brainPath) {
+    const markdown = await listMarkdown(brainPath);
+    const byTopFolder = {};
+    for (const rel of markdown) {
+        const folder = topFolder(rel);
+        byTopFolder[folder] = (byTopFolder[folder] ?? 0) + 1;
+    }
+    const inboxPath = join(brainPath, 'Shared', 'Memory-Inbox', 'memory-inbox.md');
+    const inbox = await readText(inboxPath);
+    const inboxCandidates = sectionBullets(inbox, 'New Candidates').length;
+    const inboxNeedsMerge = sectionBullets(inbox, 'Needs Merge').length;
+    let sessionNotes = 0;
+    try {
+        sessionNotes = (await readdir(join(brainPath, 'Sessions'), { withFileTypes: true })).filter((e) => e.isFile() && e.name.endsWith('.md') && e.name !== '_Index.md').length;
+    }
+    catch {
+        sessionNotes = 0;
+    }
+    let contextPacks = 0;
+    try {
+        contextPacks = (await readdir(join(brainPath, 'Shared', 'Context-Packs'), { withFileTypes: true })).filter((e) => e.isFile() && e.name.endsWith('.md') && e.name !== '_Index.md').length;
+    }
+    catch {
+        contextPacks = 0;
+    }
+    const archivedNotes = markdown.filter((rel) => rel.startsWith('Shared/Archive/')).length;
+    return {
+        markdownTotal: markdown.length,
+        byTopFolder,
+        inboxCandidates,
+        inboxNeedsMerge,
+        sessionNotes,
+        contextPacks,
+        archivedNotes,
+    };
+}
+async function collectStaleNotes(brainPath, nowMs, touchGraceDays) {
+    const out = [];
+    for (const rel of await listMarkdown(brainPath)) {
+        if (ARCHIVE_EXEMPT_PREFIXES.some((prefix) => rel.startsWith(prefix)))
+            continue;
+        const path = join(brainPath, rel);
+        const content = await readText(path);
+        const staleAfter = parseFrontmatterField(content, 'stale_after');
+        const staleMs = parseIsoDate(staleAfter);
+        if (staleMs === undefined || staleMs > nowMs)
+            continue;
+        const touchMs = await mtimeMs(path);
+        const daysPastStale = Math.floor((nowMs - staleMs) / DAY_MS);
+        const daysSinceTouch = Math.floor((nowMs - touchMs) / DAY_MS);
+        if (daysSinceTouch < touchGraceDays)
+            continue;
+        out.push({ relPath: rel, staleAfter: staleAfter, daysPastStale, daysSinceTouch });
+    }
+    return out.sort((a, b) => b.daysPastStale - a.daysPastStale);
+}
+async function collectRetrievalCoverage(brainPath, indexPath, evalReport) {
+    let sessionTotal = 0;
+    let sessionIndexed = 0;
+    const sessionMissing = [];
+    try {
+        const sessions = (await readdir(join(brainPath, 'Sessions'), { withFileTypes: true }))
+            .filter((e) => e.isFile() && e.name.endsWith('.md') && e.name !== '_Index.md')
+            .map((e) => `Sessions/${e.name}`)
+            .sort();
+        sessionTotal = sessions.length;
+        const manifest = await readManifest(indexPath);
+        if (manifest) {
+            for (const rel of sessions) {
+                if (manifest[rel])
+                    sessionIndexed++;
+                else
+                    sessionMissing.push(rel);
+            }
+        }
+    }
+    catch {
+        sessionTotal = 0;
+    }
+    return {
+        sessionIndexed,
+        sessionTotal,
+        sessionMissing,
+        evalPercent: evalReport?.percent ?? 0,
+        evalOk: evalReport?.ok ?? false,
+        evalScore: evalReport?.score ?? 0,
+        evalMaxScore: evalReport?.maxScore ?? 0,
+    };
+}
+export async function collectBrainMetrics(options = {}) {
+    const brainPath = options.brainPath;
+    const emptyCounts = {
+        markdownTotal: 0,
+        byTopFolder: {},
+        inboxCandidates: 0,
+        inboxNeedsMerge: 0,
+        sessionNotes: 0,
+        contextPacks: 0,
+        archivedNotes: 0,
+    };
+    if (!brainPath) {
+        return {
+            ok: false,
+            counts: emptyCounts,
+            staleNotes: [],
+            indexFreshness: { status: 'fail', message: 'No second-brain path is configured.' },
+            retrieval: { sessionIndexed: 0, sessionTotal: 0, sessionMissing: [], evalPercent: 0, evalOk: false, evalScore: 0, evalMaxScore: 0 },
+        };
+    }
+    try {
+        if (!(await stat(brainPath)).isDirectory()) {
+            return {
+                ok: false,
+                brainPath,
+                counts: emptyCounts,
+                staleNotes: [],
+                indexFreshness: { status: 'fail', message: 'Configured second-brain path is not a directory.' },
+                retrieval: { sessionIndexed: 0, sessionTotal: 0, sessionMissing: [], evalPercent: 0, evalOk: false, evalScore: 0, evalMaxScore: 0 },
+            };
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            brainPath,
+            counts: emptyCounts,
+            staleNotes: [],
+            indexFreshness: { status: 'fail', message: 'Configured second-brain path does not exist.' },
+            retrieval: { sessionIndexed: 0, sessionTotal: 0, sessionMissing: [], evalPercent: 0, evalOk: false, evalScore: 0, evalMaxScore: 0 },
+        };
+    }
+    const nowMs = options.nowMs ?? Date.now();
+    const indexPath = options.indexPath ?? INDEX_PATH;
+    const counts = await collectCounts(brainPath);
+    const staleNotes = await collectStaleNotes(brainPath, nowMs, options.staleTouchGraceDays ?? 14);
+    const indexCheck = await checkSearchIndexFreshness(brainPath, indexPath);
+    const evalReport = options.runRetrievalEval === false ? undefined : await runBrainEval({ brainPath, indexPath, runRetrieval: true });
+    const retrieval = await collectRetrievalCoverage(brainPath, indexPath, evalReport);
+    const indexFreshness = {
+        status: indexCheck.status,
+        message: indexCheck.message,
+    };
+    for (const detail of indexCheck.details ?? []) {
+        const m = detail.match(/^(\w+)_mtime_ms=(\d+)/);
+        if (!m)
+            continue;
+        const value = Number(m[2]);
+        if (m[1] === 'index')
+            indexFreshness.indexMtimeMs = value;
+        if (m[1] === 'vault_latest')
+            indexFreshness.vaultLatestMtimeMs = value;
+    }
+    const ok = indexCheck.status !== 'fail' &&
+        staleNotes.length === 0 &&
+        (retrieval.sessionTotal === 0 || retrieval.sessionMissing.length === 0) &&
+        (evalReport === undefined || evalReport.ok);
+    return { ok, brainPath, counts, staleNotes, indexFreshness, retrieval };
+}
+export function formatBrainMetricsReport(report) {
+    const lines = ['Sanook brain metrics', `vault: ${report.brainPath ?? '(not configured)'}`];
+    lines.push('counts:');
+    lines.push(`  markdown: ${report.counts.markdownTotal}`);
+    lines.push(`  inbox candidates: ${report.counts.inboxCandidates} · needs merge: ${report.counts.inboxNeedsMerge}`);
+    lines.push(`  sessions: ${report.counts.sessionNotes} · context packs: ${report.counts.contextPacks} · archived: ${report.counts.archivedNotes}`);
+    const folders = Object.entries(report.counts.byTopFolder).sort((a, b) => b[1] - a[1]).slice(0, 8);
+    if (folders.length) {
+        lines.push('  top folders:');
+        for (const [folder, count] of folders)
+            lines.push(`    ${folder}: ${count}`);
+    }
+    lines.push(`index freshness: [${report.indexFreshness.status.toUpperCase()}] ${report.indexFreshness.message}`);
+    lines.push(`retrieval coverage: sessions indexed ${report.retrieval.sessionIndexed}/${report.retrieval.sessionTotal}` +
+        (report.retrieval.evalMaxScore ? ` · eval ${report.retrieval.evalScore}/${report.retrieval.evalMaxScore} (${report.retrieval.evalPercent.toFixed(1)}%)` : ''));
+    if (report.retrieval.sessionMissing.length) {
+        lines.push('  missing from index:');
+        for (const rel of report.retrieval.sessionMissing.slice(0, 10))
+            lines.push(`    - ${rel}`);
+    }
+    if (report.staleNotes.length) {
+        lines.push(`stale notes (${report.staleNotes.length}):`);
+        for (const note of report.staleNotes.slice(0, 15)) {
+            lines.push(`  - ${note.relPath} (stale_after=${note.staleAfter}, +${note.daysPastStale}d, untouched ${note.daysSinceTouch}d)`);
+        }
+    }
+    else {
+        lines.push('stale notes: none flagged');
+    }
+    lines.push(`summary: ${report.ok ? 'healthy' : 'needs attention'}`);
+    return lines.join('\n');
+}