@rarusoft/dendrite-wiki 0.1.0-alpha.0

package/dist/contradicts-shipped-memory.js

@@ -0,0 +1,232 @@
+// Each pattern targets a specific negation grammar. The first capturing group, when
+// present, holds the "what's missing" noun phrase — that's what we score against memories.
+// When a pattern has no capturing group (heading-style "No X"), the object is the words
+// that follow the match up to the end of the line/sentence.
+const NEGATION_PATTERNS = [
+    { regex: /\bdoes\s+not\s+(?:yet\s+|currently\s+)?have\b([^.!?\n]{3,160})/i, objectFromCapture: true },
+    { regex: /\bdoes\s+not\s+(?:yet\s+|currently\s+)?(?:support|include|implement|provide|ship|offer)\b([^.!?\n]{3,160})/i, objectFromCapture: true },
+    { regex: /\bis\s+not\s+(?:yet\s+|currently\s+)?(?:built|shipped|implemented|present|available|done)\b([^.!?\n]{0,120})/i, objectFromCapture: true },
+    { regex: /\bhas\s+not\s+been\s+(?:yet\s+)?(?:built|shipped|implemented|delivered)\b([^.!?\n]{0,120})/i, objectFromCapture: true },
+    { regex: /\bis\s+missing\b([^.!?\n]{3,160})/i, objectFromCapture: true },
+    { regex: /\bstill\s+needs?\s+(?:another\s+layer|to\s+be\s+built)\b([^.!?\n]{0,160})/i, objectFromCapture: true },
+    { regex: /\bintentionally\s+dropped\b([^.!?\n]{0,160})/i, objectFromCapture: true },
+    // Heading-style negation: "No Shared Free-Form Memory Store", "No Subconscious Background Organizer".
+    // Anchored to the start of a heading line because mid-sentence "no X" is too noisy.
+    { regex: /^#{2,6}\s+No\s+([A-Z][^\n]{3,120})$/m, objectFromCapture: true }
+];
+const AFFIRMATIVE_KEYWORDS = [
+    'shipped',
+    'landed',
+    'implemented',
+    'now supports',
+    'now has',
+    'now includes',
+    'now provides',
+    'now offers',
+    'now applies',
+    'now ranks',
+    'now runs',
+    'is implemented',
+    'is shipped',
+    'is available',
+    'is now',
+    'complete',
+    'completed',
+    'mostly done',
+    'done',
+    'in progress',
+    'partly shipped'
+];
+const STOP_TOKENS = new Set([
+    'that',
+    'this',
+    'kind',
+    'sort',
+    'type',
+    'thing',
+    'with',
+    'into',
+    'have',
+    'been',
+    'still',
+    'some',
+    'sort',
+    'will',
+    'must',
+    'should',
+    'around',
+    'maintain',
+    'expected',
+    'project',
+    'projects',
+    'system',
+    'systems'
+]);
+const MIN_OBJECT_TOKENS = 2;
+const MIN_OBJECT_OVERLAP = 2;
+const MAX_AFFIRMING_SNIPPETS_PER_SIGNAL = 3;
+const MAX_CONTRADICTING_MEMORIES_PER_SIGNAL = 5;
+/**
+ * Scan a wiki page for prose that contradicts shipped memories. Returns one signal per
+ * affected section (the H2/H3 the negation lives under). Empty array means no contradiction
+ * was found — that's the healthy state.
+ */
+export function detectContradictsShippedMemory(pageContent, memories, projectLogContent = '') {
+    if (extractOptOutDirective(pageContent)) {
+        return [];
+    }
+    const sections = extractPageSections(pageContent);
+    if (sections.length === 0) {
+        return [];
+    }
+    const affirmingMemories = memories
+        .filter((record) => record.status === 'active' || record.status === 'superseded')
+        .map((record) => ({
+        record,
+        haystack: `${record.summary} ${record.text}`.toLowerCase(),
+        affirmative: hasAffirmativeKeyword(`${record.summary} ${record.text}`)
+    }))
+        .filter((entry) => entry.affirmative);
+    // Project-log entries are weaker evidence (one bullet line vs a memory's full body),
+    // so we only use them to BOOST confidence — never as the sole contradiction source.
+    const logBlobLower = projectLogContent.toLowerCase();
+    const logHasAffirmativeContext = hasAffirmativeKeyword(projectLogContent);
+    const signals = [];
+    for (const section of sections) {
+        const probe = `${section.heading}. ${section.body}`;
+        const negation = findFirstNegation(section.heading, section.body, probe);
+        if (!negation) {
+            continue;
+        }
+        const objectTokens = extractObjectTokens(negation.objectText);
+        if (objectTokens.length < MIN_OBJECT_TOKENS) {
+            continue;
+        }
+        const contradicting = [];
+        const snippets = [];
+        for (const entry of affirmingMemories) {
+            const overlap = countTokenOverlap(objectTokens, entry.haystack);
+            if (overlap >= MIN_OBJECT_OVERLAP) {
+                contradicting.push(entry.record.id);
+                if (snippets.length < MAX_AFFIRMING_SNIPPETS_PER_SIGNAL) {
+                    snippets.push(truncate(entry.record.summary, 140));
+                }
+            }
+            if (contradicting.length >= MAX_CONTRADICTING_MEMORIES_PER_SIGNAL) {
+                break;
+            }
+        }
+        // Project-log corroboration: if the log itself contains affirmative phrasing AND
+        // mentions enough object tokens, that counts as one extra contradicting voice and
+        // raises the signal's confidence — but never replaces a memory match.
+        if (contradicting.length > 0 &&
+            logHasAffirmativeContext &&
+            countTokenOverlap(objectTokens, logBlobLower) >= MIN_OBJECT_OVERLAP &&
+            snippets.length < MAX_AFFIRMING_SNIPPETS_PER_SIGNAL) {
+            snippets.push('project-log corroborates this feature has shipped');
+        }
+        if (contradicting.length === 0) {
+            continue;
+        }
+        signals.push({
+            sectionHeading: section.heading,
+            matchedNegation: negation.matchedText.trim(),
+            objectTokens,
+            contradictingMemoryIds: contradicting,
+            affirmingSnippets: snippets
+        });
+    }
+    return signals;
+}
+export function buildContradictsShippedMemoryMessage(signal) {
+    const memoryWord = signal.contradictingMemoryIds.length === 1 ? 'memory' : 'memories';
+    const snippet = signal.affirmingSnippets[0] ?? '';
+    const snippetSuffix = snippet ? ` (e.g., "${snippet}")` : '';
+    return `Section "${signal.sectionHeading}" asserts "${signal.matchedNegation}", but ${signal.contradictingMemoryIds.length} shipped ${memoryWord} ${signal.contradictingMemoryIds.length === 1 ? 'says' : 'say'} otherwise${snippetSuffix}. Rewrite or remove the negation, or add \`contradicts-shipped-memory: ignore\` to the page frontmatter if the assertion is intentional.`;
+}
+function extractPageSections(pageContent) {
+    const withoutFrontmatter = stripFrontmatter(pageContent);
+    const lines = withoutFrontmatter.split(/\r?\n/);
+    const sections = [];
+    let currentHeading = '';
+    let currentBody = [];
+    const pushSection = () => {
+        if (currentHeading || currentBody.length > 0) {
+            sections.push({ heading: currentHeading, body: currentBody.join('\n').trim() });
+        }
+    };
+    for (const line of lines) {
+        const headingMatch = line.match(/^(#{1,6})\s+(.+?)\s*$/);
+        if (headingMatch) {
+            pushSection();
+            currentHeading = headingMatch[2].trim();
+            currentBody = [line];
+            continue;
+        }
+        currentBody.push(line);
+    }
+    pushSection();
+    return sections;
+}
+function stripFrontmatter(content) {
+    return content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '');
+}
+function extractOptOutDirective(pageContent) {
+    const match = pageContent.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return false;
+    return /^\s*contradicts-shipped-memory\s*:\s*ignore\s*$/m.test(match[1]);
+}
+function findFirstNegation(heading, body, probe) {
+    // Try heading first — heading-style negations ("No Shared Memory Store") are higher-precision.
+    for (const pattern of NEGATION_PATTERNS) {
+        // The heading-anchored pattern needs the literal heading line, not the joined probe.
+        if (pattern.regex.source.startsWith('^')) {
+            const headingLine = `## ${heading}`;
+            const match = headingLine.match(pattern.regex);
+            if (match) {
+                return {
+                    matchedText: match[0],
+                    objectText: pattern.objectFromCapture ? match[1] ?? '' : match[0]
+                };
+            }
+            continue;
+        }
+        const match = probe.match(pattern.regex);
+        if (match) {
+            return {
+                matchedText: match[0],
+                objectText: pattern.objectFromCapture ? match[1] ?? '' : match[0]
+            };
+        }
+    }
+    // Suppress unused-parameter lint — body is read indirectly via the probe param.
+    void body;
+    return undefined;
+}
+function extractObjectTokens(objectText) {
+    return Array.from(new Set(objectText
+        .toLowerCase()
+        .replace(/[`*_]+/g, '')
+        .split(/[^a-z0-9-]+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 5 && !STOP_TOKENS.has(token))));
+}
+function countTokenOverlap(objectTokens, haystackLower) {
+    let overlap = 0;
+    for (const token of objectTokens) {
+        if (haystackLower.includes(token)) {
+            overlap += 1;
+        }
+    }
+    return overlap;
+}
+function hasAffirmativeKeyword(text) {
+    const lower = text.toLowerCase();
+    return AFFIRMATIVE_KEYWORDS.some((keyword) => lower.includes(keyword));
+}
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max - 1).trimEnd()}…`;
+}

package/dist/diff-context.js

@@ -0,0 +1,142 @@
+/**
+ * Diff-driven context aggregation for PR and local-diff reviews.
+ *
+ * Aggregates the wiki pages, project-local memories, and skills relevant to a set of
+ * changed files — the same recall pipeline `wiki_context` uses for the in-editor agent,
+ * but driven by file paths from a diff instead of an interactive task. Output is markdown
+ * suitable for a GitHub PR comment, a local terminal review, or piping into a chat
+ * application.
+ *
+ * Driven by the CLI's `context-for-diff` subcommand (a list of paths via the `--files`
+ * flag, or piped newline-delimited via stdin from `git diff --name-only main...HEAD`).
+ * The intended consumer is the future GitHub Action
+ * (`dendrite-wiki/context-action`) that auto-comments PRs with relevant project memory
+ * when a developer is reviewing a change — exposing the recall moat at exactly the moment
+ * a human reviewer cares most.
+ */
+import { buildWikiContext } from './store.js';
+import { recallProjectMemories } from '@rarusoft/dendrite-memory';
+import { recallProjectSkills } from '@rarusoft/dendrite-memory';
+const defaultMaxPagesPerFile = 3;
+const defaultMaxMemoriesPerFile = 3;
+const defaultMaxSkillsPerFile = 2;
+export async function buildDiffContext(options) {
+    const files = uniqueFiles(options.files);
+    if (files.length === 0) {
+        return { files: [], pageCount: 0, memoryCount: 0, skillCount: 0 };
+    }
+    const query = (options.query ?? '').trim() || `Review changes to ${files.join(', ')}`;
+    const maxPages = Math.max(1, options.maxPagesPerFile ?? defaultMaxPagesPerFile);
+    const maxMemories = Math.max(1, options.maxMemoriesPerFile ?? defaultMaxMemoriesPerFile);
+    const maxSkills = Math.max(1, options.maxSkillsPerFile ?? defaultMaxSkillsPerFile);
+    const seenPageSlugs = new Set();
+    const seenMemoryIds = new Set();
+    const seenSkillIds = new Set();
+    const entries = [];
+    for (const file of files) {
+        const [contextResult, memories, skills] = await Promise.all([
+            // wiki_context with the file in relatedFiles biases ranking towards memory and page
+            // matches that already cite the file.
+            buildWikiContext(query, {
+                maxPages,
+                relatedFiles: [file],
+                languages: options.languages,
+                frameworks: options.frameworks,
+                includeLint: false,
+                maxSkills
+            }),
+            recallProjectMemories(query, { relatedFiles: [file], maxItems: maxMemories }),
+            recallProjectSkills({ query, relatedFiles: [file], languages: options.languages, frameworks: options.frameworks, maxItems: maxSkills })
+        ]);
+        const pages = contextResult.pages.filter((page) => {
+            if (seenPageSlugs.has(page.slug)) {
+                return false;
+            }
+            seenPageSlugs.add(page.slug);
+            return true;
+        });
+        const dedupedMemories = memories.filter((memory) => {
+            if (seenMemoryIds.has(memory.id)) {
+                return false;
+            }
+            seenMemoryIds.add(memory.id);
+            return true;
+        });
+        const dedupedSkills = skills.filter((skill) => {
+            if (seenSkillIds.has(skill.id)) {
+                return false;
+            }
+            seenSkillIds.add(skill.id);
+            return true;
+        });
+        entries.push({
+            file,
+            pages,
+            memories: dedupedMemories,
+            skills: dedupedSkills
+        });
+    }
+    return {
+        files: entries,
+        pageCount: seenPageSlugs.size,
+        memoryCount: seenMemoryIds.size,
+        skillCount: seenSkillIds.size
+    };
+}
+export function renderDiffContextMarkdown(result) {
+    if (result.files.length === 0) {
+        return '_Dendrite Wiki MCP found no changed files to analyze._';
+    }
+    const lines = [
+        '## Dendrite Wiki: relevant context for this change',
+        '',
+        `Reviewed ${result.files.length} file${result.files.length === 1 ? '' : 's'}. Surfaced ${result.pageCount} wiki page${result.pageCount === 1 ? '' : 's'}, ${result.memoryCount} memor${result.memoryCount === 1 ? 'y' : 'ies'}, and ${result.skillCount} skill${result.skillCount === 1 ? '' : 's'}.`,
+        ''
+    ];
+    for (const entry of result.files) {
+        if (entry.pages.length === 0 && entry.memories.length === 0 && entry.skills.length === 0) {
+            continue;
+        }
+        lines.push(`### \`${entry.file}\``, '');
+        if (entry.skills.length > 0) {
+            lines.push('**Matching skills**');
+            for (const skill of entry.skills) {
+                lines.push(`- \`${skill.id}\` — ${escape(skill.summary)} _(${skill.reasons.slice(0, 2).join('; ')})_`);
+            }
+            lines.push('');
+        }
+        if (entry.memories.length > 0) {
+            lines.push('**Relevant memories**');
+            for (const memory of entry.memories) {
+                lines.push(`- \`${memory.id}\` — ${escape(memory.summary)} _(${memory.reasons.slice(0, 2).join('; ')})_`);
+            }
+            lines.push('');
+        }
+        if (entry.pages.length > 0) {
+            lines.push('**Relevant wiki pages**');
+            for (const page of entry.pages) {
+                lines.push(`- [\`${page.slug}\`](docs/wiki/${page.slug}.md) — ${escape(page.summary)} _(${escape(page.reason)})_`);
+            }
+            lines.push('');
+        }
+    }
+    if (result.pageCount === 0 && result.memoryCount === 0 && result.skillCount === 0) {
+        lines.push('_No matching wiki pages, memories, or skills were surfaced for the changed files. This usually means the changes touch new territory the wiki has not documented yet._');
+    }
+    return lines.join('\n');
+}
+function uniqueFiles(input) {
+    const seen = new Set();
+    for (const value of input) {
+        if (typeof value !== 'string')
+            continue;
+        const normalized = value.trim().replace(/\\/g, '/');
+        if (!normalized)
+            continue;
+        seen.add(normalized);
+    }
+    return Array.from(seen);
+}
+function escape(value) {
+    return value.replace(/\|/g, '\\|').replace(/[\r\n]+/g, ' ').trim();
+}

package/dist/doctor.js

@@ -0,0 +1,220 @@
+/**
+ * `dendrite-wiki doctor` — project-health audit.
+ *
+ * Aggregates findings from every health-relevant subsystem into one ranked list with
+ * severities (`critical`, `warning`, `info`): missing required files, stale benchmark
+ * snapshots, accumulated wiki lint findings, contested or unsupported memories, missing
+ * telemetry config when sharing is opt-in, etc. The CLI prints a human report by default
+ * and a structured `--json` output for scripted health checks.
+ *
+ * The doctor exits 1 on any `critical` finding so it integrates cleanly with CI gates and
+ * pre-commit hooks. Most findings are advisory and live as `warning` so the doctor stays
+ * useful without becoming a nag.
+ */
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { readBenchmarkHistory } from './benchmark.js';
+import { reviewProjectMemories } from '@rarusoft/dendrite-memory';
+import { lintWikiPages, listWikiPages, listWikiProposals } from './store.js';
+import { writeTelemetryStatusArtifact } from './telemetry.js';
+export async function runDoctor(options = {}) {
+    const root = path.resolve(options.root ?? process.cwd());
+    const findings = [];
+    // Critical filesystem checks first — if these fail, deeper checks may throw.
+    const wikiDirExists = await pathExists(path.join(root, 'docs', 'wiki'));
+    if (!wikiDirExists) {
+        findings.push({
+            severity: 'critical',
+            rule: 'no-wiki-directory',
+            title: 'Wiki directory is missing.',
+            detail: 'Dendrite expects markdown pages under docs/wiki/. The agent has nothing to read or update.',
+            fix: 'npx dendrite-wiki init'
+        });
+    }
+    const indexExists = await pathExists(path.join(root, 'docs', 'index.md'));
+    if (!indexExists) {
+        findings.push({
+            severity: 'critical',
+            rule: 'no-index-page',
+            title: 'docs/index.md is missing.',
+            detail: 'Agents are instructed to read docs/index.md first. Without it, orientation breaks.',
+            fix: 'npx dendrite-wiki init'
+        });
+    }
+    const mcpClientPaths = [
+        { client: 'Claude Code', file: '.mcp.json' },
+        { client: 'VS Code / Copilot', file: '.vscode/mcp.json' },
+        { client: 'Cursor', file: '.cursor/mcp.json' },
+        { client: 'Codex', file: '.codex/config.toml' },
+        { client: 'Continue', file: '.continue/mcpServers/dendrite-wiki-mcp.json' }
+    ];
+    const presentClients = [];
+    for (const entry of mcpClientPaths) {
+        if (await pathExists(path.join(root, entry.file))) {
+            presentClients.push(entry.client);
+        }
+    }
+    if (presentClients.length === 0) {
+        findings.push({
+            severity: 'critical',
+            rule: 'no-mcp-client-config',
+            title: 'No MCP client config files found.',
+            detail: 'No editor or agent client knows how to launch the MCP server. The agent cannot reach Dendrite.',
+            fix: 'npx dendrite-wiki init --profile claude  (or --profile cursor / copilot-vscode / codex / continue)'
+        });
+    }
+    else {
+        findings.push({
+            severity: 'info',
+            rule: 'mcp-clients-configured',
+            title: `${presentClients.length} MCP client config${presentClients.length === 1 ? '' : 's'} present.`,
+            detail: `Configured: ${presentClients.join(', ')}.`
+        });
+    }
+    // If the basic skeleton is broken, skip deeper checks to avoid noisy errors.
+    const skeletonOk = wikiDirExists && indexExists;
+    if (skeletonOk) {
+        const [pages, lintFindings, proposals, memoryReview, history, telemetryStatus] = await Promise.all([
+            listWikiPages().catch(() => []),
+            lintWikiPages().catch(() => []),
+            listWikiProposals().catch(() => []),
+            reviewProjectMemories().catch(() => ({ findings: [] })),
+            readBenchmarkHistory(root).catch(() => null),
+            writeTelemetryStatusArtifact(root).catch(() => null)
+        ]);
+        if (lintFindings.length > 0) {
+            findings.push({
+                severity: 'warning',
+                rule: 'lint-findings-present',
+                title: `${lintFindings.length} wiki lint finding${lintFindings.length === 1 ? '' : 's'}.`,
+                detail: 'The wiki has open hygiene issues (oversized guidance, stale claims, orphan pages, etc.). Review the maintenance inbox to triage.',
+                fix: 'Open docs/wiki/maintenance-inbox.md or run `npx dendrite-wiki benchmark:snapshot` to refresh state.'
+            });
+        }
+        if (proposals.length > 0) {
+            findings.push({
+                severity: 'warning',
+                rule: 'pending-proposals',
+                title: `${proposals.length} pending maintenance proposal${proposals.length === 1 ? '' : 's'}.`,
+                detail: 'Generated guidance cleanup proposals are waiting for review.',
+                fix: 'Open docs/wiki/maintenance-review.md in the browser, or call wiki_apply_proposal for low-risk items.'
+            });
+        }
+        const contradictionFindings = memoryReview.findings.filter((f) => f.kind === 'contradiction');
+        if (contradictionFindings.length > 0) {
+            findings.push({
+                severity: 'warning',
+                rule: 'memory-contradictions',
+                title: `${contradictionFindings.length} memory contradiction group${contradictionFindings.length === 1 ? '' : 's'} detected.`,
+                detail: 'Two or more memories disagree. The agent may be acting on inconsistent project truth.',
+                fix: 'Open the Maintenance Review board in the browser to inspect and resolve.'
+            });
+        }
+        if (history && history.snapshots.length > 0) {
+            const latest = history.latest && history.latest.timestamp ? history.latest : history.snapshots.at(-1);
+            if (latest && latest.timestamp) {
+                const ageDays = Math.floor((Date.now() - new Date(latest.timestamp).getTime()) / (1000 * 60 * 60 * 24));
+                if (ageDays > 14) {
+                    findings.push({
+                        severity: 'warning',
+                        rule: 'stale-benchmark',
+                        title: `Last benchmark snapshot is ${ageDays} days old.`,
+                        detail: 'Benchmarks should be captured at session boundaries to detect drift. Stale snapshots make trend lines meaningless.',
+                        fix: 'npx dendrite-wiki benchmark:snapshot --label session-end'
+                    });
+                }
+            }
+        }
+        else {
+            findings.push({
+                severity: 'warning',
+                rule: 'no-benchmark-history',
+                title: 'No benchmark snapshots have been captured.',
+                detail: 'Without baseline snapshots there is no way to measure whether Dendrite is helping the project over time.',
+                fix: 'npx dendrite-wiki benchmark:snapshot --label baseline'
+            });
+        }
+        const projectLogPath = path.join(root, 'docs', 'wiki', 'project-log.md');
+        if (await pathExists(projectLogPath)) {
+            const projectLogStat = await fs.stat(projectLogPath);
+            const logAgeDays = Math.floor((Date.now() - projectLogStat.mtime.getTime()) / (1000 * 60 * 60 * 24));
+            if (logAgeDays > 7) {
+                findings.push({
+                    severity: 'warning',
+                    rule: 'stale-project-log',
+                    title: `project-log.md was last touched ${logAgeDays} days ago.`,
+                    detail: 'No meaningful work has been logged in the past week. The project log is the chronological record agents read for context.',
+                    fix: 'Append an entry via wiki_log when meaningful work happens.'
+                });
+            }
+        }
+        if (!(await pathExists(path.join(root, '.git')))) {
+            findings.push({
+                severity: 'warning',
+                rule: 'no-git-repository',
+                title: 'No .git/ directory found.',
+                detail: 'Dendrite assumes git for diff-based review. Without git, audit and rollback are weakened.',
+                fix: 'git init'
+            });
+        }
+        findings.push({
+            severity: 'info',
+            rule: 'project-stats',
+            title: `${pages.length} wiki page${pages.length === 1 ? '' : 's'} total.`,
+            detail: `${lintFindings.length} lint finding${lintFindings.length === 1 ? '' : 's'}, ${proposals.length} proposal${proposals.length === 1 ? '' : 's'}, ${memoryReview.findings.length} memory finding${memoryReview.findings.length === 1 ? '' : 's'}. Telemetry: ${telemetryStatus?.sharingMode ?? 'unknown'}.`
+        });
+    }
+    const counts = {
+        critical: findings.filter((f) => f.severity === 'critical').length,
+        warning: findings.filter((f) => f.severity === 'warning').length,
+        info: findings.filter((f) => f.severity === 'info').length
+    };
+    const status = counts.critical > 0 ? 'critical' : counts.warning > 0 ? 'warnings' : 'healthy';
+    return {
+        generatedAt: new Date().toISOString(),
+        root,
+        findings,
+        counts,
+        status
+    };
+}
+export function formatDoctorReport(report) {
+    const lines = [];
+    const statusEmoji = report.status === 'healthy' ? 'OK' : report.status === 'warnings' ? 'WARN' : 'FAIL';
+    lines.push(`Dendrite Doctor — ${statusEmoji}`);
+    lines.push(`Project: ${report.root}`);
+    lines.push(`Critical: ${report.counts.critical}  Warnings: ${report.counts.warning}  Info: ${report.counts.info}`);
+    lines.push('');
+    const sections = [
+        { severity: 'critical', label: 'CRITICAL' },
+        { severity: 'warning', label: 'WARNING' },
+        { severity: 'info', label: 'INFO' }
+    ];
+    for (const section of sections) {
+        const sectionFindings = report.findings.filter((f) => f.severity === section.severity);
+        if (sectionFindings.length === 0)
+            continue;
+        lines.push(`[${section.label}]`);
+        for (const finding of sectionFindings) {
+            lines.push(`  ${finding.title}`);
+            lines.push(`    ${finding.detail}`);
+            if (finding.fix) {
+                lines.push(`    Fix: ${finding.fix}`);
+            }
+            lines.push('');
+        }
+    }
+    if (report.findings.length === 0) {
+        lines.push('No findings — Dendrite is healthy.');
+    }
+    return lines.join('\n');
+}
+async function pathExists(target) {
+    try {
+        await fs.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}