sanook-cli 0.5.1 → 0.5.5

package/dist/brain-consolidate.js

@@ -0,0 +1,335 @@
+import { mkdir, readdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { persistenceEnabled } from './brand.js';
+import { normalize, consolidate, loadStore, saveStore } from './memory-store.js';
+import { search } from './search/engine.js';
+const ARCHIVE_EXEMPT_PREFIXES = ['Shared/Core-Facts/', 'Shared/Archive/'];
+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' },
+];
+export function parseBrainConsolidateArgs(args) {
+    let apply = false;
+    let archive = false;
+    let memory = false;
+    let runRetrieval = true;
+    for (const a of args) {
+        if (a === '--apply')
+            apply = true;
+        else if (a === '--archive')
+            archive = true;
+        else if (a === '--memory')
+            memory = true;
+        else if (a === '--no-retrieval')
+            runRetrieval = false;
+        else
+            return { ok: false, message: `ไม่รู้จัก option: ${a}` };
+    }
+    if (archive && !apply)
+        return { ok: false, message: '--archive ต้องใช้ร่วมกับ --apply (destructive move ถามก่อน — default เป็น dry-run)' };
+    return { ok: true, value: { apply, archive, memory, runRetrieval } };
+}
+function step(id, title, findings, message, fail = false, applied) {
+    const status = fail ? 'fail' : findings.length ? 'warn' : 'pass';
+    return { id, title, status, message, findings, applied };
+}
+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 parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+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('.') || entry.name === '.git' || entry.name === '.obsidian' || entry.name === 'node_modules')
+                    continue;
+                await walk(join(abs, entry.name), childRel);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                out.push(childRel);
+            }
+        }
+    }
+    await walk(root, '');
+    return out;
+}
+async function routeInboxStep(brainPath, apply) {
+    const path = join(brainPath, 'Shared', 'Memory-Inbox', 'memory-inbox.md');
+    const content = await readText(path);
+    if (!content) {
+        return step('consolidate.inbox-route', 'Route Memory-Inbox', [{ message: 'Memory-Inbox file is missing.', path }], 'Memory-Inbox is missing.', true);
+    }
+    const candidates = sectionBullets(content, 'New Candidates');
+    const needsMerge = sectionBullets(content, 'Needs Merge');
+    const findings = [];
+    const applied = [];
+    if (needsMerge.length) {
+        findings.push({
+            message: `${needsMerge.length} item(s) waiting in Needs Merge — promote to durable or discard.`,
+            path,
+            details: needsMerge.slice(0, 15),
+        });
+    }
+    const seen = new Map();
+    const duplicates = [];
+    for (const candidate of candidates) {
+        const key = normalize(candidate.replace(/^-\s*/, '').replace(/\s+/g, ' ')).trim();
+        if (!key)
+            continue;
+        if (seen.has(key))
+            duplicates.push(candidate);
+        else
+            seen.set(key, candidate);
+    }
+    if (duplicates.length) {
+        findings.push({ message: `${duplicates.length} duplicate candidate(s) in New Candidates.`, path, details: duplicates.slice(0, 15) });
+        if (apply) {
+            let next = content;
+            for (const dup of duplicates)
+                next = next.replace(`${dup}\n`, '');
+            if (next !== content) {
+                await writeFile(path, next);
+                applied.push(`removed ${duplicates.length} exact duplicate inbox candidate(s)`);
+            }
+        }
+    }
+    if (candidates.length && !needsMerge.length && !duplicates.length) {
+        findings.push({
+            message: `${candidates.length} candidate(s) ready for routing (ADD/UPDATE/DELETE/NOOP).`,
+            path,
+            details: candidates.slice(0, 10),
+        });
+    }
+    return step('consolidate.inbox-route', 'Route Memory-Inbox', findings, candidates.length ? `${candidates.length} inbox candidate(s) reviewed.` : 'Memory-Inbox has no active candidates.', false, applied.length ? applied : undefined);
+}
+async function dedupMergeStep(brainPath) {
+    const path = join(brainPath, 'Shared', 'Memory-Inbox', 'memory-inbox.md');
+    const content = await readText(path);
+    const candidates = [...sectionBullets(content, 'New Candidates'), ...sectionBullets(content, 'Needs Merge')];
+    const findings = [];
+    const buckets = new Map();
+    for (const candidate of candidates) {
+        const key = normalize(candidate.replace(/^-\s*/, '').replace(/\s+/g, ' ')).trim();
+        if (!key)
+            continue;
+        const bucket = buckets.get(key) ?? [];
+        bucket.push(candidate);
+        buckets.set(key, bucket);
+    }
+    const overlaps = [...buckets.entries()].filter(([, items]) => items.length > 1);
+    if (overlaps.length) {
+        findings.push({
+            message: `${overlaps.length} overlapping inbox group(s) need merge.`,
+            path,
+            details: overlaps.slice(0, 10).map(([key, items]) => `${key} (${items.length}x)`),
+        });
+    }
+    return step('consolidate.dedup-merge', 'Dedup + merge inbox', findings, 'Inbox overlap scan complete.');
+}
+async function staleArchiveStep(brainPath, nowMs, apply, archive) {
+    const findings = [];
+    const applied = [];
+    const candidates = [];
+    for (const rel of await listMarkdown(brainPath)) {
+        if (ARCHIVE_EXEMPT_PREFIXES.some((prefix) => rel.startsWith(prefix)))
+            continue;
+        const abs = join(brainPath, rel);
+        const content = await readText(abs);
+        const staleAfter = parseFrontmatterField(content, 'stale_after');
+        const staleMs = parseIsoDate(staleAfter);
+        if (staleMs === undefined || staleMs > nowMs)
+            continue;
+        candidates.push(rel);
+        findings.push({ message: `Stale candidate: stale_after=${staleAfter}`, path: abs });
+    }
+    if (archive && apply) {
+        await mkdir(join(brainPath, 'Shared', 'Archive'), { recursive: true });
+        for (const rel of candidates) {
+            const src = join(brainPath, rel);
+            const dest = join(brainPath, 'Shared', 'Archive', rel.split('/').pop());
+            await rename(src, dest);
+            applied.push(`archived ${rel} → Shared/Archive/${rel.split('/').pop()}`);
+        }
+    }
+    else if (candidates.length) {
+        findings.unshift({
+            message: `${candidates.length} note(s) past stale_after — dry-run only; rerun with --apply --archive to move into Shared/Archive.`,
+        });
+    }
+    return step('consolidate.stale-archive', 'Stale → Archive', findings, candidates.length ? `${candidates.length} stale note(s) flagged.` : 'No stale notes flagged.', false, applied.length ? applied : undefined);
+}
+async function patternPromoteStep(brainPath) {
+    const inboxPath = join(brainPath, 'Shared', 'Memory-Inbox', 'memory-inbox.md');
+    const candidates = sectionBullets(await readText(inboxPath), 'New Candidates');
+    const findings = [];
+    const markdown = await listMarkdown(brainPath);
+    const corpusParts = [];
+    for (const rel of markdown.slice(0, 200)) {
+        const text = await readText(join(brainPath, rel));
+        if (text)
+            corpusParts.push(normalize(text));
+    }
+    const corpus = corpusParts.join('\n');
+    for (const candidate of candidates) {
+        const phrase = normalize(candidate.replace(/^-\s*/, '').replace(/\s+/g, ' ')).trim();
+        if (phrase.length < 12)
+            continue;
+        const tokens = phrase.split(/\s+/).filter((t) => t.length > 3).slice(0, 4);
+        if (tokens.length < 2)
+            continue;
+        const hits = tokens.filter((token) => corpus.includes(token)).length;
+        if (hits >= 3 || (tokens.length >= 2 && hits === tokens.length && corpus.includes(phrase.slice(0, 20)))) {
+            findings.push({
+                message: `Possible recurring pattern (≥3 signals): "${phrase.slice(0, 80)}"`,
+                path: inboxPath,
+                details: ['Consider promoting to Playbooks/ or Distillations/ after review.'],
+            });
+        }
+    }
+    return step('consolidate.pattern-promote', 'Pattern → promote', findings, findings.length ? `${findings.length} pattern candidate(s) found.` : 'No recurring patterns detected in inbox.');
+}
+async function retrievalCheckStep(runRetrieval, searchImpl) {
+    if (!runRetrieval) {
+        return { id: 'consolidate.retrieval-check', title: 'Retrieval check', status: 'skipped', message: 'Skipped (--no-retrieval).', findings: [] };
+    }
+    const findings = [];
+    for (const item of RETRIEVAL_CASES) {
+        const res = await searchImpl(item.query);
+        const hit = res.hits.find((candidate) => candidate.path === item.expectedPath);
+        if (!hit) {
+            findings.push({
+                message: `${item.id} miss: query did not return ${item.expectedPath}`,
+                details: [`query="${item.query}"`, ...res.hits.slice(0, 3).map((h) => `got: ${h.path ?? h.snippet.slice(0, 60)}`)],
+            });
+        }
+    }
+    return step('consolidate.retrieval-check', 'Retrieval check', findings, findings.length ? `${findings.length} retrieval miss(es).` : 'Retrieval eval cases passed.', false);
+}
+async function memoryConsolidateStep(apply, memory, nowMs) {
+    if (!memory) {
+        return { id: 'consolidate.auto-memory', title: 'Auto-memory consolidate', status: 'skipped', message: 'Skipped (pass --memory to consolidate ~/.sanook memory store).', findings: [] };
+    }
+    if (!persistenceEnabled()) {
+        return step('consolidate.auto-memory', 'Auto-memory consolidate', [{ message: 'Persistence is disabled (SANOOK_DISABLE_PERSISTENCE).' }], 'Auto-memory consolidate skipped.', false);
+    }
+    const store = await loadStore();
+    const { store: next, report } = consolidate(store, nowMs);
+    const findings = [];
+    if (report.archived.length)
+        findings.push({ message: `Would archive ${report.archived.length} auto-memory fact(s).`, details: report.archived.slice(0, 10) });
+    if (report.merged.length)
+        findings.push({ message: `Merged ${report.merged.length} overlapping auto-memory fact(s).`, details: report.merged.slice(0, 10) });
+    if (report.needsReview.length)
+        findings.push({ message: `${report.needsReview.length} auto-memory fact(s) need review.`, details: report.needsReview.slice(0, 10) });
+    const applied = [];
+    if (apply) {
+        await saveStore(next);
+        applied.push('saved consolidated auto-memory store');
+    }
+    return step('consolidate.auto-memory', 'Auto-memory consolidate', findings, apply ? 'Auto-memory store consolidated.' : 'Auto-memory consolidate dry-run (pass --apply --memory to save).', false, applied.length ? applied : undefined);
+}
+export async function runBrainConsolidate(options = {}) {
+    const brainPath = options.brainPath;
+    const apply = options.apply ?? false;
+    const dryRun = !apply;
+    if (!brainPath) {
+        return {
+            ok: false,
+            dryRun,
+            steps: [step('consolidate.configured', 'Second-brain configured', [{ message: 'No second-brain path is configured.' }], 'Run `sanook brain init [path]` first.', true)],
+        };
+    }
+    try {
+        if (!(await stat(brainPath)).isDirectory()) {
+            return {
+                ok: false,
+                brainPath,
+                dryRun,
+                steps: [step('consolidate.path', 'Second-brain path', [{ message: 'Configured path is not a directory.', path: brainPath }], 'Configured brainPath is not usable.', true)],
+            };
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            brainPath,
+            dryRun,
+            steps: [step('consolidate.path', 'Second-brain path', [{ message: 'Configured path does not exist.', path: brainPath }], 'Configured brainPath is not usable.', true)],
+        };
+    }
+    const nowMs = options.nowMs ?? Date.now();
+    const searchImpl = options.searchImpl ??
+        ((query) => search(query, { mode: 'fts', limit: 5, sources: ['vault'] }));
+    const steps = [
+        await routeInboxStep(brainPath, apply),
+        await dedupMergeStep(brainPath),
+        await staleArchiveStep(brainPath, nowMs, apply, options.archive ?? false),
+        await patternPromoteStep(brainPath),
+        await retrievalCheckStep(options.runRetrieval !== false, searchImpl),
+        await memoryConsolidateStep(apply, options.memory ?? false, nowMs),
+    ];
+    const ok = !steps.some((s) => s.status === 'fail');
+    return { ok, brainPath, dryRun, steps };
+}
+function statusLabel(status) {
+    return status.toUpperCase().padEnd(7);
+}
+export function formatBrainConsolidateReport(report) {
+    const lines = [
+        'Sanook brain consolidate',
+        `vault: ${report.brainPath ?? '(not configured)'}`,
+        `mode: ${report.dryRun ? 'dry-run (pass --apply for safe fixes; --apply --archive for stale moves)' : 'apply'}`,
+    ];
+    for (const s of report.steps) {
+        lines.push(`[${statusLabel(s.status)}] ${s.id} — ${s.message}`);
+        for (const finding of s.findings) {
+            lines.push(`       - ${finding.message}`);
+            if (finding.path)
+                lines.push(`         ${finding.path}`);
+            for (const detail of finding.details ?? [])
+                lines.push(`         · ${detail}`);
+        }
+        for (const action of s.applied ?? [])
+            lines.push(`       ✓ ${action}`);
+    }
+    return lines.join('\n');
+}

package/dist/brain-context.js

@@ -0,0 +1,262 @@
+import { stat } from 'node:fs/promises';
+import { resolveVaultProject } from './project-registry.js';
+import { inlineValue, takeValue } from './cli-option-values.js';
+import { buildBrainContextParts, renderBrainContext, } from './memory.js';
+import { checkSearchIndexFreshness } from './brain-doctor.js';
+import { search } from './search/engine.js';
+import { SEARCH_SOURCES } from './search/index-core.js';
+import { INDEX_PATH } from './search/store.js';
+const SEARCH_MODES = ['auto', 'fts', 'semantic', 'hybrid'];
+const DEFAULT_CONTEXT_WARNING_CHARS = 6500;
+const DEFAULT_TASK_SOURCES = ['vault', 'session', 'skill'];
+function isSearchMode(value) {
+    return SEARCH_MODES.includes(value);
+}
+function isSearchSource(value) {
+    return SEARCH_SOURCES.includes(value);
+}
+function parsePositiveInteger(raw) {
+    if (!raw || !/^[1-9]\d*$/.test(raw))
+        return undefined;
+    const n = Number(raw);
+    return Number.isSafeInteger(n) ? n : undefined;
+}
+function inlineSourceValue(value) {
+    return inlineValue('--source', value) ?? inlineValue('--sources', value);
+}
+export function parseBrainContextArgs(args) {
+    const taskParts = [];
+    let task;
+    let project;
+    let mode = 'auto';
+    let modeSet = false;
+    let limit = 5;
+    let limitSet = false;
+    let sources;
+    let showContent = true;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--') {
+            taskParts.push(...args.slice(i + 1));
+            break;
+        }
+        else if (a === '--task' || a.startsWith('--task=')) {
+            const next = a === '--task' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineValue('--task', a);
+            if (next)
+                i = next.nextIndex;
+            if (!raw)
+                return { ok: false, message: '--task ต้องระบุข้อความ task' };
+            if (task !== undefined)
+                return { ok: false, message: 'ระบุ task ได้ครั้งเดียว: ใช้ --task เพียงครั้งเดียว' };
+            task = raw.trim();
+            if (!task)
+                return { ok: false, message: '--task ต้องระบุข้อความ task' };
+        }
+        else if (a === '--project' || a.startsWith('--project=')) {
+            const next = a === '--project' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineValue('--project', a);
+            if (next)
+                i = next.nextIndex;
+            if (!raw?.trim())
+                return { ok: false, message: 'ต้องระบุค่าให้ --project' };
+            if (project !== undefined)
+                return { ok: false, message: 'ระบุ project ได้ครั้งเดียว' };
+            project = raw.trim();
+        }
+        else if (a === '--mode' || a.startsWith('--mode=')) {
+            const next = a === '--mode' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineValue('--mode', a);
+            if (next)
+                i = next.nextIndex;
+            if (!raw)
+                return { ok: false, message: `--mode ต้องระบุค่าเป็น ${SEARCH_MODES.join('|')}` };
+            if (!isSearchMode(raw))
+                return { ok: false, message: `--mode ต้องเป็น ${SEARCH_MODES.join('|')}` };
+            if (modeSet)
+                return { ok: false, message: 'ใช้ --mode เพียงครั้งเดียว' };
+            mode = raw;
+            modeSet = true;
+        }
+        else if (a === '--limit' || a.startsWith('--limit=')) {
+            const next = a === '--limit' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineValue('--limit', a);
+            if (next)
+                i = next.nextIndex;
+            const n = parsePositiveInteger(raw);
+            if (n === undefined)
+                return { ok: false, message: '--limit ต้องเป็น integer บวก เช่น 5' };
+            if (limitSet)
+                return { ok: false, message: 'ใช้ --limit เพียงครั้งเดียว' };
+            limit = n;
+            limitSet = true;
+        }
+        else if (a === '--source' || a === '--sources' || a.startsWith('--source=') || a.startsWith('--sources=')) {
+            const next = a === '--source' || a === '--sources' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineSourceValue(a);
+            if (next)
+                i = next.nextIndex;
+            const requested = (raw ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+            if (!requested.length)
+                return { ok: false, message: `--source ต้องระบุค่าเป็น ${SEARCH_SOURCES.join(',')}` };
+            const bad = requested.filter((s) => !isSearchSource(s));
+            if (bad.length)
+                return { ok: false, message: `--source ต้องเป็น ${SEARCH_SOURCES.join(',')}` };
+            sources = [...new Set([...(sources ?? []), ...requested])];
+        }
+        else if (a === '--no-content' || a === '--summary') {
+            showContent = false;
+        }
+        else if (a === '--content') {
+            showContent = true;
+        }
+        else {
+            taskParts.push(a);
+        }
+    }
+    const positionalTask = taskParts.join(' ').trim();
+    if (task !== undefined && positionalTask)
+        return { ok: false, message: 'ระบุ task ได้ครั้งเดียว: ใช้ positional หรือ --task อย่างใดอย่างหนึ่ง' };
+    const finalTask = (task ?? positionalTask).trim();
+    return { ok: true, value: { task: finalTask || undefined, project, mode, limit, sources, showContent } };
+}
+export async function inspectBrainContext(options = {}) {
+    const brainPath = options.brainPath;
+    const warnings = [];
+    if (!brainPath) {
+        return {
+            ok: false,
+            context: '',
+            contextChars: 0,
+            sources: [],
+            warnings: ['No second-brain path is configured. Run `sanook brain init [path]` first.'],
+        };
+    }
+    try {
+        if (!(await stat(brainPath)).isDirectory()) {
+            return {
+                ok: false,
+                brainPath,
+                context: '',
+                contextChars: 0,
+                sources: [],
+                warnings: ['Configured second-brain path is not a directory.'],
+            };
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            brainPath,
+            context: '',
+            contextChars: 0,
+            sources: [],
+            warnings: ['Configured second-brain path does not exist.'],
+        };
+    }
+    const parts = await buildBrainContextParts(brainPath, {
+        taskQuery: options.task,
+        cwd: options.cwd,
+        projectSlug: options.projectSlug,
+    });
+    const context = renderBrainContext(brainPath, parts);
+    const activeProject = await resolveVaultProject({
+        brainPath,
+        cwd: options.cwd,
+        slug: options.projectSlug,
+    });
+    const sourceReports = parts.map((part) => ({
+        id: part.id,
+        label: part.label,
+        relPath: part.relPath,
+        path: part.path,
+        status: part.status,
+        chars: part.chars,
+        maxChars: part.maxChars,
+    }));
+    for (const part of sourceReports) {
+        if (part.status === 'missing')
+            warnings.push(`Missing context source: ${part.relPath}`);
+    }
+    if (!context)
+        warnings.push('Brain context is empty; expected at least one hot context source to contain content.');
+    const maxContextChars = options.maxContextChars ?? DEFAULT_CONTEXT_WARNING_CHARS;
+    if (context.length > maxContextChars) {
+        warnings.push(`Brain context is ${context.length} chars, above the ${maxContextChars} char warning threshold.`);
+    }
+    const indexCheck = await checkSearchIndexFreshness(brainPath, options.indexPath ?? INDEX_PATH, options.indexFreshnessToleranceMs);
+    if (indexCheck.status !== 'pass')
+        warnings.push(indexCheck.message);
+    const taskQuery = options.task?.trim();
+    let taskReport;
+    if (taskQuery) {
+        const taskSources = options.sources?.length ? options.sources : [...DEFAULT_TASK_SOURCES];
+        const res = await (options.searchImpl ?? search)(taskQuery, {
+            mode: options.mode ?? 'auto',
+            limit: options.limit ?? 5,
+            sources: taskSources,
+        });
+        taskReport = {
+            query: taskQuery,
+            mode: res.mode,
+            degraded: res.degraded,
+            total: res.total,
+            hits: res.hits,
+            sources: taskSources,
+        };
+    }
+    return {
+        ok: true,
+        brainPath,
+        projectSlug: activeProject?.slug,
+        projectRepo: activeProject?.repoPath,
+        context,
+        contextChars: context.length,
+        sources: sourceReports,
+        warnings,
+        task: taskReport,
+    };
+}
+function statusLabel(status) {
+    return status.toUpperCase().padEnd(7);
+}
+export function formatBrainContextReport(report, showContent = true) {
+    const lines = ['Sanook brain context'];
+    lines.push(`vault: ${report.brainPath ?? '(not configured)'}`);
+    if (report.projectSlug) {
+        lines.push(`project: ${report.projectSlug}${report.projectRepo ? ` (${report.projectRepo})` : ''}`);
+    }
+    lines.push(`context: ${report.contextChars} chars`);
+    if (report.sources.length) {
+        lines.push('sources:');
+        for (const source of report.sources) {
+            lines.push(`  [${statusLabel(source.status)}] ${source.relPath} (${source.chars} chars, cap ${source.maxChars})`);
+        }
+    }
+    if (report.warnings.length) {
+        lines.push('warnings:');
+        for (const warning of report.warnings)
+            lines.push(`  - ${warning}`);
+    }
+    if (showContent) {
+        lines.push('--- context ---');
+        lines.push(report.context || '(empty)');
+    }
+    if (report.task) {
+        lines.push(`--- task retrieval: "${report.task.query}" ---`);
+        lines.push(`mode=${report.task.mode}${report.task.degraded ? ` degraded=${report.task.degraded}` : ''} ` +
+            `sources=${report.task.sources.join(',')} hits=${report.task.hits.length}/${report.task.total}`);
+        if (!report.task.hits.length) {
+            lines.push('(no task hits; run `sanook index` if the vault changed recently)');
+        }
+        else {
+            for (const hit of report.task.hits) {
+                const title = hit.title.trim();
+                const body = title ? `${title} — ${hit.snippet}` : hit.snippet;
+                const where = hit.path ? ` (${hit.path})` : '';
+                lines.push(`[${hit.source}] ${body}${where}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}