@plebeiantech/lat.md 0.12.3-fork.12 → 0.12.3-fork.14

package/dist/src/cli/check.js

@@ -1,17 +1,21 @@
-import { readFile, writeFile, lstat, rename, unlink } from 'node:fs/promises';
+import { lstat, rename, unlink, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { basename, dirname, extname, join, relative, resolve } from 'node:path';
-import { listLatticeFiles, loadAllSections, extractLinks, extractRefs, flattenSections, parseFrontmatter, parseSections, buildFileIndex, buildSectionSlugIndex, resolveRef, } from '../lattice.js';
-import { scanCodeRefs } from '../code-refs.js';
+import { performance } from 'node:perf_hooks';
+import { flattenSections, resolveRef } from '../lattice-model.js';
+import { isSourceFileExtension, SOURCE_FILE_EXTENSIONS, } from '../source-formats.js';
+import { inspectRepositoryPath, normalizeRepositoryPath, } from '../repository-path.js';
+import { toPosix } from '../path.js';
+import { TimingProfiler } from '../profiler.js';
 import { checkMode } from './check-mode.js';
 import { checkStatus } from './check-status.js';
 import { checkFrontmatter } from './check-frontmatter.js';
 import { checkCoverage } from './check-coverage.js';
 import { indexEntryNameFromDest } from './link-scheme.js';
 import { fencedLineMask } from './gen-index.js';
-import { SOURCE_EXTENSIONS, clearSymbolCache } from '../source-parser.js';
-import { toPosix, walkEntries } from '../walk.js';
 import { INIT_VERSION, readInitVersion } from '../init-version.js';
+import { CheckRunContext } from './check-context.js';
+import { parseLocalMarkdownTarget } from '../markdown-validation.js';
 function filePart(id) {
     const h = id.indexOf('#');
     return h === -1 ? id : id.slice(0, h);
@@ -31,50 +35,66 @@ export function ambiguousRefMessage(target, candidates, suggested) {
     lines.push(`  The short path "${shortName}" is ambiguous — ${candidates.length} files match:`, fileList, `  Please fix the link to use a fully qualified path.`);
     return lines.join('\n');
 }
-function countByExt(paths) {
-    const stats = {};
-    for (const p of paths) {
-        const ext = extname(p) || '(no ext)';
-        stats[ext] = (stats[ext] || 0) + 1;
-    }
-    return stats;
+async function profileTime(profile, label, work, detail) {
+    return profile ? profile.time(label, work, detail) : work();
 }
-function isSourcePath(target) {
-    const hashIdx = target.indexOf('#');
-    const filePart = hashIdx === -1 ? target : target.slice(0, hashIdx);
-    const ext = extname(filePart);
-    return SOURCE_EXTENSIONS.has(ext);
+function profileTimeSync(profile, label, work, detail) {
+    return profile ? profile.timeSync(label, work, detail) : work();
 }
 /**
- * Try resolving a wiki link target as a source code reference.
- * Returns null if the reference is valid, or an error message string.
+ * Validate an unresolved wiki link as a repository path or source symbol.
+ * Returns null when valid, otherwise a user-facing error message.
  */
-export async function sourceRefError(target, projectRoot) {
-    if (!isSourcePath(target)) {
-        // Check if it looks like a file path with an unsupported extension
-        const hashIdx = target.indexOf('#');
-        const filePart = hashIdx === -1 ? target : target.slice(0, hashIdx);
-        const ext = extname(filePart);
-        if (ext && hashIdx !== -1) {
-            const supported = [...SOURCE_EXTENSIONS].sort().join(', ');
-            return `broken link [[${target}]] — unsupported file extension "${ext}". Supported: ${supported}`;
-        }
+export async function repositoryRefError(target, projectRoot, sourceOptions = {}) {
+    const hashIdx = target.indexOf('#');
+    const authoredPath = hashIdx === -1 ? target : target.slice(0, hashIdx);
+    if (!authoredPath) {
         return `broken link [[${target}]] — no matching section found`;
     }
-    const hashIdx = target.indexOf('#');
-    const filePart = hashIdx === -1 ? target : target.slice(0, hashIdx);
+    const filePart = normalizeRepositoryPath(authoredPath);
+    if (!filePart) {
+        return `broken link [[${target}]] — repository path "${authoredPath}" must stay within the project root`;
+    }
     const symbolPart = hashIdx === -1 ? '' : target.slice(hashIdx + 1);
-    const absPath = join(projectRoot, filePart);
-    if (!existsSync(absPath)) {
+    const ext = extname(filePart);
+    const sourcePath = isSourceFileExtension(ext);
+    const inspected = await inspectRepositoryPath(projectRoot, filePart);
+    if (inspected.kind === 'outside') {
+        return `broken link [[${target}]] — repository path "${filePart}" resolves outside the project root`;
+    }
+    if (hashIdx === -1) {
+        if (inspected.kind === 'missing') {
+            return `broken link [[${target}]] — repository file or directory "${filePart}" not found`;
+        }
+        if (inspected.kind === 'other') {
+            return `broken link [[${target}]] — repository path "${filePart}" is not a regular file or directory`;
+        }
+        return null;
+    }
+    if (inspected.kind === 'directory') {
+        return `broken link [[${target}]] — directory "${filePart}" cannot have a fragment`;
+    }
+    if (inspected.kind === 'other') {
+        return `broken link [[${target}]] — repository path "${filePart}" is not a regular file or directory`;
+    }
+    if (!sourcePath) {
+        if (ext || inspected.kind === 'file') {
+            const shownExtension = ext || '(none)';
+            const supported = SOURCE_FILE_EXTENSIONS.join(', ');
+            return `broken link [[${target}]] — unsupported file extension "${shownExtension}" for fragment reference. Supported: ${supported}`;
+        }
+        return `broken link [[${target}]] — no matching section found`;
+    }
+    if (inspected.kind === 'missing') {
         return `broken link [[${target}]] — file "${filePart}" not found`;
     }
     if (!symbolPart) {
-        // File-only link with no symbol — valid as long as file exists
+        // Preserve the existing file-level behavior for an empty fragment.
         return null;
     }
     try {
         const { resolveSourceSymbol } = await import('../source-parser.js');
-        const { found, error } = await resolveSourceSymbol(filePart, symbolPart, projectRoot);
+        const { found, error } = await resolveSourceSymbol(filePart, symbolPart, projectRoot, sourceOptions);
         if (error) {
             return `broken link [[${target}]] — ${error}`;
         }
@@ -87,20 +107,50 @@ export async function sourceRefError(target, projectRoot) {
         return `broken link [[${target}]] — failed to parse "${filePart}": ${err instanceof Error ? err.message : String(err)}`;
     }
 }
-export async function checkMd(latticeDir, projectRoot = dirname(latticeDir)) {
-    clearSymbolCache();
-    const files = await listLatticeFiles(latticeDir);
-    const allSections = await loadAllSections(latticeDir, projectRoot);
-    const flat = flattenSections(allSections);
-    const sectionIds = new Set(flat.map((s) => s.id.toLowerCase()));
-    const fileIndex = buildFileIndex(allSections);
-    const slugIndex = buildSectionSlugIndex(allSections);
+export async function checkMd(latticeDir, projectRoot = dirname(latticeDir), context) {
+    const run = context ?? new CheckRunContext(latticeDir, projectRoot);
+    run.clearSourceSymbolCache();
+    const files = await run.markdownFiles();
+    const { sectionIds, fileIndex, slugIndex } = await run.sectionIndex();
     const errors = [];
+    const external = await run.externalResolver();
+    for (const error of external.snapshot.errors) {
+        errors.push({
+            file: relative(process.cwd(), error.file),
+            line: 1,
+            target: '',
+            message: error.message,
+        });
+    }
     for (const file of files) {
-        const content = await readFile(file, 'utf-8');
-        const refs = extractRefs(file, content, projectRoot);
+        const refs = await run.refs(file);
         const relPath = relative(process.cwd(), file);
         for (const ref of refs) {
+            try {
+                if (external.parse(ref.target)) {
+                    await run.resolveExternal(ref.target);
+                    continue;
+                }
+            }
+            catch (error) {
+                errors.push({
+                    file: relPath,
+                    line: ref.line,
+                    target: ref.target,
+                    message: `broken external link [[${ref.target}]] — ${error.message}`,
+                });
+                continue;
+            }
+            const unknownExternal = external.unknownTargetMessage(ref.target);
+            if (unknownExternal) {
+                errors.push({
+                    file: relPath,
+                    line: ref.line,
+                    target: ref.target,
+                    message: unknownExternal,
+                });
+                continue;
+            }
             const { resolved, ambiguous, suggested } = resolveRef(ref.target, sectionIds, fileIndex, slugIndex);
             if (ambiguous) {
                 errors.push({
@@ -111,8 +161,8 @@ export async function checkMd(latticeDir, projectRoot = dirname(latticeDir)) {
                 });
             }
             else if (!sectionIds.has(resolved.toLowerCase())) {
-                // Try resolving as a source code reference (e.g. [[src/foo.ts#bar]])
-                const sourceErr = await sourceRefError(ref.target, projectRoot);
+                // Try resolving as a repository path or source symbol.
+                const sourceErr = await run.resolveRepositoryLink(ref.target, () => repositoryRefError(ref.target, projectRoot, run.sourceSymbolOptions()));
                 if (sourceErr !== null) {
                     errors.push({
                         file: relPath,
@@ -124,84 +174,36 @@ export async function checkMd(latticeDir, projectRoot = dirname(latticeDir)) {
             }
         }
     }
-    return { errors, files: countByExt(files) };
+    return { errors };
 }
-function decodeLinkPart(value) {
-    try {
-        return decodeURIComponent(value);
-    }
-    catch {
-        return value;
-    }
-}
-/** Parse a local markdown destination without confusing escaped #/? in paths. */
-function localLinkTarget(url) {
-    const u = url.trim();
-    if (u.startsWith('/'))
-        return null;
-    const windowsDrivePath = /^[a-zA-Z]:\\/.test(u);
-    if (!windowsDrivePath && /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(u)) {
-        return null;
-    }
-    // Split before decoding: `%23` and `%3F` decode to `#` and `?`, which would
-    // then truncate a filename that legitimately contains them.
-    const queryAt = u.indexOf('?');
-    const fragmentAt = u.indexOf('#');
-    const pathEnd = Math.min(queryAt === -1 ? u.length : queryAt, fragmentAt === -1 ? u.length : fragmentAt);
-    const rawPath = u.slice(0, pathEnd);
-    const path = rawPath === '' ? null : decodeLinkPart(rawPath);
-    const fragment = fragmentAt === -1 ? null : decodeLinkPart(u.slice(fragmentAt + 1));
-    if (rawPath === '' && fragment === null)
-        return null;
-    if (path?.includes('\\'))
-        return { kind: 'invalid-backslash' };
-    return {
-        kind: 'target',
-        path,
-        fragment,
-    };
-}
-export async function checkLinks(latticeDir) {
-    const files = await listLatticeFiles(latticeDir);
+// --- Relative link validation ---
+export async function checkLinks(latticeDir, context) {
+    const run = context ?? new CheckRunContext(latticeDir, dirname(latticeDir));
+    const files = await run.markdownFiles();
     const errors = [];
-    const headingCache = new Map();
-    const headingsFor = async (file) => {
-        const cached = headingCache.get(file);
-        if (cached)
-            return cached;
-        const content = await readFile(file, 'utf-8');
-        const headings = new Set(flattenSections(parseSections(file, content)).map((section) => section.githubSlug));
-        headingCache.set(file, headings);
-        return headings;
-    };
     for (const file of files) {
-        const content = await readFile(file, 'utf-8');
+        const links = await run.links(file);
         const relPath = toPosix(relative(process.cwd(), file));
-        for (const link of extractLinks(content)) {
-            if ('identifier' in link) {
-                const kind = link.kind === 'imageReference' ? 'image' : 'link';
-                errors.push({
-                    file: relPath,
-                    line: link.line,
-                    target: link.identifier,
-                    message: `undefined ${kind} reference (${link.source}) — definition "[${link.identifier}]" not found`,
-                });
+        for (const diagnostic of await run.diagnostics(file)) {
+            if (diagnostic.rule !== 'markdown-reference-definition' &&
+                diagnostic.rule !== 'markdown-path-separator') {
                 continue;
             }
-            const target = localLinkTarget(link.url);
+            errors.push({
+                file: relPath,
+                line: diagnostic.line,
+                target: diagnostic.target,
+                message: diagnostic.message,
+            });
+        }
+        for (const link of links) {
+            if ('identifier' in link)
+                continue;
+            const target = parseLocalMarkdownTarget(link.url);
             if (target === null)
                 continue;
-            if (target.kind === 'invalid-backslash') {
-                const kind = link.kind === 'image' ? 'image' : 'link';
-                errors.push({
-                    file: relPath,
-                    line: link.line,
-                    target: link.url,
-                    message: `invalid ${kind} (${link.url}) — backslashes are not path ` +
-                        'separators in Markdown; use "/" instead',
-                });
+            if (target.kind === 'invalid-backslash')
                 continue;
-            }
             const abs = target.path ? resolve(dirname(file), target.path) : file;
             if (!existsSync(abs)) {
                 const kind = link.kind === 'image' ? 'image' : 'link';
@@ -217,7 +219,7 @@ export async function checkLinks(latticeDir) {
             if (target.fragment &&
                 extname(abs).toLowerCase() === '.md' &&
                 link.kind !== 'image') {
-                const headings = await headingsFor(abs);
+                const headings = await run.headings(abs);
                 if (!headings.has(target.fragment)) {
                     const shown = toPosix(relative(process.cwd(), abs));
                     errors.push({
@@ -232,17 +234,51 @@ export async function checkLinks(latticeDir) {
     }
     return errors;
 }
-export async function checkCodeRefs(latticeDir, projectRoot = dirname(latticeDir)) {
-    const allSections = await loadAllSections(latticeDir, projectRoot);
-    const flat = flattenSections(allSections);
-    const sectionIds = new Set(flat.map((s) => s.id.toLowerCase()));
-    const fileIndex = buildFileIndex(allSections);
-    const slugIndex = buildSectionSlugIndex(allSections);
-    const scan = await scanCodeRefs(projectRoot);
+export async function checkCodeRefs(latticeDir, projectRoot = dirname(latticeDir), context) {
+    const run = context ?? new CheckRunContext(latticeDir, projectRoot);
+    const [{ sectionIds, fileIndex, slugIndex }, scan, external] = await Promise.all([
+        run.sectionIndex(),
+        run.codeRefs(),
+        run.externalResolver(),
+    ]);
     const errors = [];
+    for (const error of external.snapshot.errors) {
+        errors.push({
+            file: relative(process.cwd(), error.file),
+            line: 1,
+            target: '',
+            message: error.message,
+        });
+    }
     const mentionedSections = new Set();
     for (const ref of scan.refs) {
-        const { resolved, ambiguous, suggested } = resolveRef(ref.target, sectionIds, fileIndex, slugIndex);
+        try {
+            const externalTarget = profileTimeSync(run.profile, 'classify code-reference target', () => external.parse(ref.target), ref.target);
+            if (externalTarget) {
+                await run.resolveExternal(ref.target);
+                continue;
+            }
+        }
+        catch (error) {
+            errors.push({
+                file: relative(process.cwd(), join(projectRoot, ref.file)),
+                line: ref.line,
+                target: ref.target,
+                message: `@lat: [[${ref.target}]] — ${error.message}`,
+            });
+            continue;
+        }
+        const unknownExternal = profileTimeSync(run.profile, 'check unknown external handle', () => external.unknownTargetMessage(ref.target), ref.target);
+        if (unknownExternal) {
+            errors.push({
+                file: relative(process.cwd(), join(projectRoot, ref.file)),
+                line: ref.line,
+                target: ref.target,
+                message: `@lat: [[${ref.target}]] — ${unknownExternal}`,
+            });
+            continue;
+        }
+        const { resolved, ambiguous, suggested } = profileTimeSync(run.profile, 'resolve internal code reference', () => resolveRef(ref.target, sectionIds, fileIndex, slugIndex), ref.target);
         mentionedSections.add(resolved.toLowerCase());
         const displayPath = relative(process.cwd(), join(projectRoot, ref.file));
         if (ambiguous) {
@@ -262,15 +298,13 @@ export async function checkCodeRefs(latticeDir, projectRoot = dirname(latticeDir
             });
         }
     }
-    const files = await listLatticeFiles(latticeDir);
+    const files = await run.markdownFiles();
     for (const file of files) {
-        const content = await readFile(file, 'utf-8');
-        const fm = parseFrontmatter(content);
+        const fm = await run.frontmatter(file);
         if (!fm.requireCodeMention)
             continue;
-        const sections = parseSections(file, content, projectRoot);
-        const fileSections = flattenSections(sections);
-        const leafSections = fileSections.filter((s) => s.children.length === 0);
+        const fileSections = flattenSections(await run.sections(file));
+        const leafSections = fileSections.filter((section) => section.children.length === 0);
         const relPath = relative(process.cwd(), file);
         for (const leaf of leafSections) {
             if (!mentionedSections.has(leaf.id.toLowerCase())) {
@@ -283,7 +317,7 @@ export async function checkCodeRefs(latticeDir, projectRoot = dirname(latticeDir
             }
         }
     }
-    return { errors, files: countByExt(scan.files) };
+    return { errors };
 }
 /**
  * Extract the immediate (first-level) entries from walkEntries results.
@@ -335,17 +369,41 @@ function entryToStem(name) {
 function indexSnippet(entries) {
     return entries.map((e) => `- [[${entryToStem(e)}]] — <describe>`).join('\n');
 }
-export async function checkIndex(latticeDir, opts = {}) {
+export async function checkIndex(latticeDir, context, opts = {}) {
+    const run = context ?? new CheckRunContext(latticeDir, dirname(latticeDir));
     const errors = [];
-    const allPaths = await walkEntries(latticeDir);
-    // Flag non-.md files — only markdown belongs in the checked directory.
+    const allPaths = await run.entries();
+    const referencedResources = new Set();
+    for (const file of await run.markdownFiles()) {
+        for (const link of await run.links(file)) {
+            if ('identifier' in link)
+                continue;
+            const target = parseLocalMarkdownTarget(link.url);
+            if (!target || target.kind === 'invalid-backslash' || !target.path) {
+                continue;
+            }
+            const absolutePath = resolve(dirname(file), target.path);
+            const resourcePath = toPosix(relative(latticeDir, absolutePath));
+            if (resourcePath &&
+                resourcePath !== '..' &&
+                !resourcePath.startsWith('../') &&
+                !resourcePath.toLowerCase().endsWith('.md')) {
+                referencedResources.add(resourcePath);
+            }
+        }
+    }
+    // Flag non-.md files unless Markdown reaches them as local resources. The
+    // machine-local external override is the other intentional non-Markdown
+    // configuration file in the vault.
     for (const p of allPaths) {
         const name = p.includes('/') ? p.slice(p.lastIndexOf('/') + 1) : p;
-        if (!name.endsWith('.md')) {
+        if (!name.endsWith('.md') &&
+            p !== 'config.local.yaml' &&
+            !referencedResources.has(p)) {
             const relDir = basename(latticeDir) + '/';
             errors.push({
                 dir: relDir,
-                message: `"${p}" is not a .md file — only markdown files belong in the checked directory`,
+                message: `"${p}" is not a .md file or a referenced local resource — remove it or link to it from Markdown`,
             });
         }
     }
@@ -382,7 +440,7 @@ export async function checkIndex(latticeDir, opts = {}) {
         const indexFullPath = join(latticeDir, indexRelPath);
         let content;
         try {
-            content = await readFile(indexFullPath, 'utf-8');
+            content = await run.content(indexFullPath);
         }
         catch {
             content = null;
@@ -533,53 +591,26 @@ async function writeGeneratedIndex(latticeDir, dir, indexFullPath, dirName, exis
     return null;
 }
 // --- Section structure validation ---
-/** Max characters for the first paragraph of a section (excluding [[wiki links]]). */
-const MAX_BODY_LENGTH = 250;
-/** Count body text length excluding `[[...]]` wiki link markers and content. */
-function bodyTextLength(body) {
-    return body.replace(/\[\[[^\]]*\]\]/g, '').length;
-}
-export async function checkSections(latticeDir, projectRoot = dirname(latticeDir)) {
-    const files = await listLatticeFiles(latticeDir);
+export async function checkSections(latticeDir, projectRoot = dirname(latticeDir), context) {
+    const run = context ?? new CheckRunContext(latticeDir, projectRoot);
+    const files = await run.markdownFiles();
     const errors = [];
     for (const file of files) {
-        const content = await readFile(file, 'utf-8');
-        const sections = parseSections(file, content, projectRoot);
-        const flat = flattenSections(sections);
         const relPath = relative(process.cwd(), file);
-        for (const section of flat) {
-            if (!section.firstParagraph) {
-                errors.push({
-                    file: relPath,
-                    line: section.startLine,
-                    target: section.id,
-                    message: `section "${section.id}" has no leading paragraph. ` +
-                        `Every section must start with a brief overview (≤${MAX_BODY_LENGTH} chars) ` +
-                        `summarizing what it documents — this powers search snippets and command output.`,
-                });
+        for (const diagnostic of await run.diagnostics(file)) {
+            if (diagnostic.rule !== 'section-leading-paragraph')
                 continue;
-            }
-            const len = bodyTextLength(section.firstParagraph);
-            if (len > MAX_BODY_LENGTH) {
-                errors.push({
-                    file: relPath,
-                    line: section.startLine,
-                    target: section.id,
-                    message: `section "${section.id}" leading paragraph is ${len} characters ` +
-                        `(max ${MAX_BODY_LENGTH}, excluding [[wiki links]]). ` +
-                        `Keep the first paragraph brief — it serves as the section's summary ` +
-                        `in search results and command output. Use subsequent paragraphs for details.`,
-                });
-            }
+            errors.push({
+                file: relPath,
+                line: diagnostic.line,
+                target: diagnostic.target,
+                message: diagnostic.message,
+            });
         }
     }
     return errors;
 }
 // --- Formatting helpers (shared by all check commands) ---
-function formatFileStats(files, s) {
-    const entries = Object.entries(files).sort(([a], [b]) => a.localeCompare(b));
-    return s.dim(`Scanned ${entries.map(([ext, n]) => `${n} ${ext}`).join(', ')}`);
-}
 function formatCheckErrors(errors, s) {
     const lines = [];
     for (const err of errors) {
@@ -609,42 +640,64 @@ function formatCheckIndexErrors(errors, s) {
 function formatErrorCount(count, s) {
     return s.red(`\n${count} error${count === 1 ? '' : 's'} found`);
 }
-// --- Unified command functions ---
-export async function checkAllCommand(ctx, opts = {}) {
-    const startTime = Date.now();
-    const md = await checkMd(ctx.latDir, ctx.projectRoot);
-    const linkErrors = await checkLinks(ctx.latDir);
-    const code = await checkCodeRefs(ctx.latDir, ctx.projectRoot);
+export async function checkAllCommand(ctx, options = {}) {
+    const startTime = performance.now();
+    const profile = options.profile ? new TimingProfiler() : undefined;
     // `--fix` is index-only: an index is derived from frontmatter, so it can be
     // regenerated. Nothing else `lat check` reports has a mechanical fix.
-    const indexErrors = await checkIndex(ctx.latDir, opts);
-    const sectionErrors = await checkSections(ctx.latDir, ctx.projectRoot);
-    const modeErrors = await checkMode(ctx.latDir, ctx.projectRoot);
-    const statusErrors = await checkStatus(ctx.latDir, ctx.projectRoot);
-    const fmErrors = await checkFrontmatter(ctx.latDir, ctx.projectRoot);
-    const coverageErrors = await checkCoverage(ctx.latDir, ctx.projectRoot);
-    const elapsed = Date.now() - startTime;
-    const allErrors = [...md.errors, ...linkErrors, ...code.errors];
-    const allFiles = { ...md.files };
-    for (const [ext, n] of Object.entries(code.files)) {
-        allFiles[ext] = (allFiles[ext] || 0) + n;
-    }
-    const s = ctx.styler;
-    const elapsedStr = elapsed < 1000 ? `${elapsed}ms` : `${(elapsed / 1000).toFixed(1)}s`;
-    const lines = [
-        formatFileStats(allFiles, s) + s.dim(` in ${elapsedStr}`),
+    //
+    // A fixing run also has to finish before any other check starts. The checks
+    // below run concurrently over one shared parse cache, and --fix rewrites the
+    // very files they read; interleaving that write with those reads would make
+    // the run's verdict depend on scheduling. So it gets its own context, and
+    // the readers get a fresh one built after the writing is done.
+    const fixIndexErrors = options.fix
+        ? await profileTime(profile, 'generate directory indexes', () => checkIndex(ctx.latDir, new CheckRunContext(ctx.latDir, ctx.projectRoot, profile), { fix: true }))
+        : null;
+    const run = new CheckRunContext(ctx.latDir, ctx.projectRoot, profile);
+    const [md, linkErrors, code, checkedIndexErrors, sectionErrors, modeErrors, statusErrors, fmErrors, coverageErrors,] = await Promise.all([
+        profileTime(profile, 'check Markdown wiki links', () => checkMd(ctx.latDir, ctx.projectRoot, run)),
+        profileTime(profile, 'check relative Markdown links', () => checkLinks(ctx.latDir, run)),
+        profileTime(profile, 'check @lat code references', () => checkCodeRefs(ctx.latDir, ctx.projectRoot, run)),
+        // Already generated above when --fix is set; re-reporting it would only
+        // describe the state the fix just left behind.
+        fixIndexErrors
+            ? Promise.resolve([])
+            : profileTime(profile, 'check directory indexes', () => checkIndex(ctx.latDir, run)),
+        profileTime(profile, 'check section structure', () => checkSections(ctx.latDir, ctx.projectRoot, run)),
+        profileTime(profile, 'check Diátaxis modes', () => checkMode(ctx.latDir, ctx.projectRoot)),
+        profileTime(profile, 'check review status', () => checkStatus(ctx.latDir, ctx.projectRoot)),
+        profileTime(profile, 'check frontmatter placement', () => checkFrontmatter(ctx.latDir, ctx.projectRoot)),
+        profileTime(profile, 'check documentation coverage', () => checkCoverage(ctx.latDir, ctx.projectRoot)),
+    ]);
+    const indexErrors = fixIndexErrors ?? checkedIndexErrors;
+    const elapsed = performance.now() - startTime;
+    const allErrors = [
+        ...new Map([...md.errors, ...linkErrors, ...code.errors].map((error) => [
+            `${error.file}\0${error.line}\0${error.target}\0${error.message}`,
+            error,
+        ])).values(),
     ];
+    const s = ctx.styler;
+    const elapsedStr = elapsed < 1000
+        ? `${Math.round(elapsed)}ms`
+        : `${(elapsed / 1000).toFixed(1)}s`;
+    const lines = profile ? profile.format(elapsed) : [];
     // Init version warning first — user should fix setup before addressing errors
     if (!ctx.headless) {
         const storedVersion = readInitVersion(ctx.latDir);
         if (storedVersion === null) {
-            lines.push('', s.yellow('Warning:') +
+            if (lines.length > 0)
+                lines.push('');
+            lines.push(s.yellow('Warning:') +
                 ' No init version recorded — run ' +
                 s.cyan('lat init') +
                 ' to set up agent hooks and configuration.');
         }
         else if (storedVersion < INIT_VERSION) {
-            lines.push('', s.yellow('Warning:') +
+            if (lines.length > 0)
+                lines.push('');
+            lines.push(s.yellow('Warning:') +
                 ' Your setup is outdated (v' +
                 storedVersion +
                 ' → v' +
@@ -672,7 +725,7 @@ export async function checkAllCommand(ctx, opts = {}) {
         lines.push(formatErrorCount(totalErrors, s));
         return { output: lines.join('\n'), isError: true };
     }
-    lines.push(s.green('All checks passed'));
+    lines.push(s.green(`All checks passed in ${elapsedStr}`));
     // Suggest ripgrep if check was slow (>1s) and rg is not available
     if (elapsed > 1000) {
         const { hasRipgrep } = await import('../code-refs.js');
@@ -687,9 +740,9 @@ export async function checkAllCommand(ctx, opts = {}) {
     return { output: lines.join('\n') };
 }
 export async function checkMdCommand(ctx) {
-    const { errors, files } = await checkMd(ctx.latDir, ctx.projectRoot);
+    const { errors } = await checkMd(ctx.latDir, ctx.projectRoot);
     const s = ctx.styler;
-    const lines = [formatFileStats(files, s)];
+    const lines = [];
     lines.push(...formatCheckErrors(errors, s));
     if (errors.length > 0) {
         lines.push(formatErrorCount(errors.length, s));
@@ -711,9 +764,9 @@ export async function checkLinksCommand(ctx) {
     return { output: lines.join('\n') };
 }
 export async function checkCodeRefsCommand(ctx) {
-    const { errors, files } = await checkCodeRefs(ctx.latDir, ctx.projectRoot);
+    const { errors } = await checkCodeRefs(ctx.latDir, ctx.projectRoot);
     const s = ctx.styler;
-    const lines = [formatFileStats(files, s)];
+    const lines = [];
     lines.push(...formatCheckErrors(errors, s));
     if (errors.length > 0) {
         lines.push(formatErrorCount(errors.length, s));
@@ -723,7 +776,7 @@ export async function checkCodeRefsCommand(ctx) {
     return { output: lines.join('\n') };
 }
 export async function checkIndexCommand(ctx, opts = {}) {
-    const errors = await checkIndex(ctx.latDir, opts);
+    const errors = await checkIndex(ctx.latDir, undefined, opts);
     const s = ctx.styler;
     const lines = [];
     if (opts.fix) {

package/dist/src/cli/context.js

@@ -1,7 +1,7 @@
 import { statSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { styleText } from 'node:util';
-import { findLatticeDir } from '../lattice.js';
+import { findLatticeDir } from '../project-discovery.js';
 export function makeStyler() {
     return {
         bold: (s) => styleText('bold', s),