@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/memory/lint.js

@@ -1,671 +1,2 @@
-// lint.ts — the ONE memory validation engine. It checks a PHYSICAL store (every
-// markdown file it holds, whether or not the runtime will mount it) or a whole
-// TARGET VIEW (every store a cwd/profile/node sees, plus the cross-store
-// diagnostics only a view can produce), and returns structured findings. The
-// `memory lint` leaf, migration verification, the plugin candidate gate, and
-// the build's builtin-corpus gate all consume this module rather than
-// reimplementing a rule: a rule asserted in one caller holds only there.
-//
-// Severity is the contract: `error` fails an authoring/mount gate, `warning` is
-// a non-fatal authoring smell, `notice` is inspection data (duplicate stores are
-// legitimate, so equal-canonical candidates across stores are reported, never
-// failed).
-import { envNodeId, envProfileId } from '../../shared/env.js';
-import { basename, join, matchesGlob, relative, sep } from 'node:path';
-import { pathExists, readText, realpathOrSelf, walkFiles } from '../fs-utils.js';
-import { parseFrontmatterGeneric } from '../frontmatter.js';
-import { descendantStoreRoots } from '../nested-stores.js';
-import { projectScopeRoots } from '../scope.js';
-import { associateRepository } from './repository-association.js';
-import { loadProfileManifest } from '../profiles/manifest.js';
-import { loadMemoryTargetView, loadStoreMemoryDocs, openProjectMemoryStore, } from '../memory-resolver.js';
-import { buildMemoryTree } from './tree.js';
-import { canonicalSegments, collapseTrailingIndex, INDEX_SEGMENT, localNameFromPath, normalizeDocName, validateExplicitLocalName, } from './identity.js';
-import { lintSubstrateFrontmatter, parsedSubstrateSurfaces } from '../substrate/frontmatter-validation.js';
-import { memoryExtensionValidationCatalog, validateMemoryExtensionValues } from './extensions.js';
-import { docLinkNames } from './doc-link-grammar.js';
-/** The rules that decide whether a corpus is COMPATIBLE with exact canonical
- *  identity — what a plugin candidate gate, the builtin build gate, and
- *  migration verification refuse a corpus on, independent of authoring-quality
- *  rules such as length or routing lines. */
-export const MEMORY_LINT_IDENTITY_RULES = new Set([
-    'store-namespace',
-    'namespace-placement',
-    'owner-path-collision',
-    'root-name',
-    'root-index-unaddressable',
-    'local-name',
-    'canonical-collision',
-    'dangling-link',
-    'memory-read-route',
-]);
-function makeResult(findings, checked, documents, storesLinted) {
-    const errors = findings.filter((f) => f.severity === 'error');
-    return {
-        ok: errors.length === 0,
-        checked,
-        documents,
-        storesLinted,
-        findings,
-        errors,
-        warnings: findings.filter((f) => f.severity === 'warning'),
-        notices: findings.filter((f) => f.severity === 'notice'),
-    };
-}
-// Body-length caps, measured in WORDS (frontmatter excluded). Words, not lines:
-// house style writes each paragraph as ONE logical line and lets the editor
-// soft-wrap, so a line count measures wrapping style rather than context cost.
-//
-// A `boot` entry at `content` inlines the whole body into every agent's system
-// prompt; a `content` entry on any other event surfaces the whole body whenever
-// the entry fires — both cap at 1000 words. A `boot` entry at `preview` routes a
-// deliberate reader into the whole body, so its cap is the longest doc worth
-// reading end to end. `name` entries and surface-less docs never cap: such a doc
-// is only reached deliberately, so its length is the reader's choice. The
-// strictest applicable cap wins.
-//
-// Persona layers — canonical names under `kinds/`, the docs the prompt render
-// composes into an agent's persona — are structurally exempt: an agent reads its
-// whole persona by construction. Suppression elsewhere is deliberate and
-// per-doc: `lint-ignore: length`, surfaced ONLY by the finding itself.
-const BOOT_CONTENT_MAX_WORDS = 1000;
-const EVENT_CONTENT_MAX_WORDS = 1000;
-const BOOT_PREVIEW_MAX_WORDS = 3000;
-/** A routing line costs more than it saves for a short rule or fact. */
-const PREVIEW_TO_CONTENT_MAX_WORDS = 30;
-const LENGTH_REMEDY = 'Keep the load-bearing core here and split the depth into [[linked]] reference docs carrying no surfaces at all (the listing and the link are how they are found, so they cost nothing until followed). Split by subject: each leaf covers a different subject a task might need on its own; never split off “further evidence”, examples, or references — a references leaf is never followed, so supporting material stays next to the point it supports or gets cut. Keep it whole — `lint-ignore: length` in the frontmatter — only when every reader who surfaces this doc genuinely benefits from reading 100% of it, or it is one indivisible body of knowledge; then splitting just adds hops.';
-function ignoresRule(fm, rule) {
-    const v = fm['lint-ignore'];
-    return v === rule || (Array.isArray(v) && v.includes(rule));
-}
-function countBodyWords(body) {
-    const trimmed = body.trim();
-    return trimmed === '' ? 0 : trimmed.split(/\s+/).length;
-}
-/** The length rule. Caps come from the parsed entries — an invalid entry already
- *  fails the schema check, so it simply matches no cap here. `docName` is the
- *  doc's canonical identity; persona layers under `kinds/` are never capped. */
-export function lintBodyLength(fm, body, docName) {
-    if (ignoresRule(fm, 'length'))
-        return null;
-    if (docName === 'kinds' || docName.startsWith('kinds/'))
-        return null;
-    const entries = parsedSubstrateSurfaces(fm);
-    const words = countBodyWords(body);
-    if (entries.some((e) => e.on === 'boot' && e.at === 'content') && words > BOOT_CONTENT_MAX_WORDS) {
-        return `body is ${words} words but a boot entry at \`content\` inlines every word into every agent's system prompt — capped at ${BOOT_CONTENT_MAX_WORDS} words (boot preview gets ${BOOT_PREVIEW_MAX_WORDS}; name entries are never capped). ${LENGTH_REMEDY}`;
-    }
-    const contentEvents = [...new Set(entries.filter((e) => e.on !== 'boot' && e.at === 'content').map((e) => e.on))];
-    if (contentEvents.length > 0 && words > EVENT_CONTENT_MAX_WORDS) {
-        return `body is ${words} words, over the ${EVENT_CONTENT_MAX_WORDS}-word cap for a \`content\` entry on ${contentEvents.join('/')} (the whole body delivers every time the entry fires; name entries are never capped). ${LENGTH_REMEDY}`;
-    }
-    if (entries.some((e) => e.on === 'boot' && e.at === 'preview') && words > BOOT_PREVIEW_MAX_WORDS) {
-        return `body is ${words} words, over the ${BOOT_PREVIEW_MAX_WORDS}-word cap for boot preview (the routing line invites every reader into the whole body, so the cap is the longest doc worth reading end-to-end; boot content is capped at ${BOOT_CONTENT_MAX_WORDS} words; name entries are never capped). ${LENGTH_REMEDY}`;
-    }
-    return null;
-}
-/** Warn when a body short enough to inline still pays a routing line. */
-export function lintShortPreviewBody(fm, body) {
-    const words = countBodyWords(body);
-    if (words >= PREVIEW_TO_CONTENT_MAX_WORDS)
-        return null;
-    const previewEvents = [...new Set(parsedSubstrateSurfaces(fm).filter((e) => e.at === 'preview').map((e) => e.on))];
-    if (previewEvents.length === 0)
-        return null;
-    const noun = previewEvents.length === 1 ? 'entry delivers' : 'entries deliver';
-    return `body is ${words} words but the ${previewEvents.join('/')} ${noun} \`preview\`; use \`at: content\` so agents receive the whole rule without a separate memory read`;
-}
-// Reference resolution: what a `[[link]]` or a `memory-read` route may name.
-/** Every canonical name a reference may target in a corpus: each document's
- *  exact identity plus every canonical directory, because reading a directory
- *  answers with its own document and its listing. Derived from the canonical
- *  tree, never from string prefixes of a name. */
-export function resolvableCanonicalNames(docs) {
-    const names = new Set();
-    const walk = (node) => {
-        if (node.name !== '')
-            names.add(node.name);
-        for (const child of node.childDirectories)
-            walk(child);
-        for (const child of node.childDocuments)
-            names.add(child.name);
-    };
-    walk(buildMemoryTree(docs).root);
-    return names;
-}
-/** The orphan rule. A document is reachable when an agent is routed to it
- *  without knowing its name: a surface delivers it (a `memory-read` surface is
- *  deliberate companion wiring and counts), it is invocable as a slash command,
- *  a reached document's real `[[link]]` names it, or a reached CURATED INDEX
- *  document's listing includes it. The listing edge routes only through a
- *  directory that carries its own non-root index document — a bare directory
- *  has no curator, and a store's root front door is delivered with the whole
- *  boot tree, so treating either listing as a route would reach every doc and
- *  defeat the rule (the same reason the corpus root is never seeded). Curated
- *  BODY LINKS on those docs still route. Reachability is computed over the
- *  WHOLE target view — a doc linked only from another store is still reachable.
- *  `flagStoreRoot` restricts which store's unreachable docs are flagged while
- *  every store still participates in the graph as a potential linker. */
-export function lintOrphans(viewDocs, options = {}) {
-    const tree = buildMemoryTree(viewDocs);
-    const index = new Map();
-    const indexWalk = (node) => {
-        if (node.name !== '')
-            index.set(node.name, node);
-        for (const child of node.childDirectories)
-            indexWalk(child);
-        for (const child of node.childDocuments)
-            index.set(child.name, child);
-    };
-    indexWalk(tree.root);
-    const reachable = new Set();
-    const queue = [];
-    const enqueue = (name) => {
-        if (name === '' || reachable.has(name) || !index.has(name))
-            return;
-        reachable.add(name);
-        queue.push(name);
-    };
-    // Roots: a doc an agent reaches without a name — any surface entry, or a
-    // slash command. A `memory-read` surface counts (deliberate companion wiring).
-    for (const doc of viewDocs) {
-        const fm = doc.frontmatter ?? {};
-        if (parsedSubstrateSurfaces(fm).length > 0 || fm['slash'] === true)
-            enqueue(doc.name);
-    }
-    // Fixpoint: reading a reachable node routes to its real links, and — when the
-    // node is a curated non-root index — to the members its listing renders.
-    while (queue.length > 0) {
-        const node = index.get(queue.shift());
-        const doc = node.document;
-        if (doc !== null) {
-            for (const target of docLinkNames(doc.body))
-                if (index.has(target))
-                    enqueue(target);
-        }
-        if (doc === null || doc.localName === '')
-            continue;
-        for (const child of node.childDirectories) {
-            if (child.document?.frontmatter?.['unlisted'] === true)
-                continue;
-            enqueue(child.name);
-        }
-        for (const child of node.childDocuments) {
-            if (child.document.frontmatter?.['unlisted'] === true)
-                continue;
-            enqueue(child.name);
-        }
-    }
-    const findings = [];
-    for (const doc of viewDocs) {
-        if (options.flagStoreRoot !== undefined && doc.store.storeRoot !== options.flagStoreRoot)
-            continue;
-        if (reachable.has(doc.name))
-            continue;
-        // Not the running user's to fix, but still a linker in the graph above.
-        if (doc.scope === 'builtin' || doc.plugin !== undefined)
-            continue;
-        // A store's root document is its entry point by definition.
-        if (doc.localName === '')
-            continue;
-        // Persona layers are read by construction, same as the length rule.
-        if (doc.name === 'kinds' || doc.name.startsWith('kinds/'))
-            continue;
-        if (ignoresRule(doc.frontmatter ?? {}, 'orphan'))
-            continue;
-        findings.push({
-            severity: 'warning',
-            rule: 'orphan',
-            path: doc.path,
-            name: doc.name,
-            scope: doc.scope,
-            ...(doc.store.storeRoot === '' ? {} : { storeRoot: doc.store.storeRoot }),
-            message: `\`${doc.name}\` is unreachable: no surface delivers it, no reached document links it, and no reached directory lists it — it is findable only by deliberate search. Give it a surface, link it from a reached doc (a cluster index, or its directory's own ${INDEX_SEGMENT}.md), or accept it with \`lint-ignore: orphan\`.`,
-        });
-    }
-    return findings;
-}
-const FRONT_DOOR_REMEDY = 'the store\'s root INDEX.md is the workspace front door: give it `surfaces: [{on: workspace-open, at: content}, {on: read, match: "./**", at: content}]` (run `crtr memory write -h` first)';
-const GLOB_META_RE = /[*?[\]{}]/;
-function safeGlob(target, glob) {
-    try {
-        return matchesGlob(target, glob);
-    }
-    catch {
-        return false;
-    }
-}
-/** The exact canonical name a WILDCARD-FREE `memory-read` glob names. A `./`
- *  glob is relative to the carrier's routing anchor — its own canonical name
- *  when it is its directory's document, else the canonical directory it sits
- *  in. */
-function literalRouteTarget(glob, routingAnchor) {
-    const rest = glob.startsWith('./') ? glob.slice(2) : glob;
-    const absolute = glob.startsWith('./') ? `${routingAnchor}/${rest}` : rest;
-    return canonicalSegments(normalizeDocName(absolute)).join('/');
-}
-function routeMatchesAny(glob, routingAnchor, names) {
-    if (!glob.startsWith('./')) {
-        for (const name of names)
-            if (safeGlob(name, glob))
-                return true;
-        return false;
-    }
-    const rest = glob.slice(2);
-    const prefix = routingAnchor === '' ? '' : `${routingAnchor}/`;
-    for (const name of names) {
-        if (!name.startsWith(prefix))
-            continue;
-        if (safeGlob(name.slice(prefix.length), rest))
-            return true;
-    }
-    return false;
-}
-/** The tail a not-found reference should be searched by, plus the `/INDEX`
- *  diagnostic when the reference still uses the retired directory spelling. */
-function missingNameDiagnostic(name) {
-    const segments = canonicalSegments(name);
-    const collapsedIndex = segments[segments.length - 1] === INDEX_SEGMENT;
-    const collapsed = collapseTrailingIndex(name);
-    const leaf = canonicalSegments(collapsed).pop() ?? name;
-    const indexNote = collapsedIndex
-        ? ` A directory's own document answers at the directory name, so name \`${collapsed}\` instead.`
-        : '';
-    return `${indexNote} Run \`crtr memory find ${leaf}\` for the canonical name, or drop the reference.`;
-}
-/** Files a store holds but the substrate never loads as documents: `SKILL.md`
- *  is an Agent Skill bundle and `MEMORY.md` an index file. They are YAML-parsed
- *  so a broken one is still caught, and nothing else applies to them. */
-const NON_DOCUMENT_FILES = new Set(['SKILL.md', 'MEMORY.md']);
-/** Lint ONE physical store, whether or not the runtime mounts it. An undeclared
- *  or invalid project store still has its files checked — every store-local rule
- *  holds before a namespace exists — but its references are deferred, because
- *  the identities its links resolve against are undetermined until migration
- *  declares the namespace. */
-export function lintMemoryStore(store, options = {}) {
-    const findings = [];
-    const base = {
-        scope: store.scope,
-        ...(store.storeRoot === '' ? {} : { storeRoot: store.storeRoot }),
-    };
-    const add = (severity, rule, path, message, extra = {}) => {
-        findings.push({ severity, rule, path, message, ...base, ...extra });
-    };
-    const mounted = store.mountStatus === 'ready';
-    if (store.mountFailure === 'collision') {
-        add('error', 'owner-path-collision', store.namespacePath ?? store.storeRoot, store.diagnostic ?? `project memory stores have owner directories that normalize to the same effective prefix \`${store.namespace}\` — rename one owner directory`);
-    }
-    else if (store.mountStatus === 'undeclared' || store.mountStatus === 'invalid') {
-        add('error', 'store-namespace', store.namespacePath ?? store.storeRoot, store.diagnostic ?? 'project memory store does not mount');
-    }
-    if (store.mountStatus === 'undeclared' || store.mountStatus === 'invalid') {
-        if (options.resolvable !== undefined) {
-            add('notice', 'reference-check-deferred', store.storeRoot, 'links and `memory-read` routes are not checked here: the canonical identities they resolve against are undetermined until this store declares its namespace');
-        }
-    }
-    const isProjectStore = store.scope === 'project' && store.plugin === undefined;
-    const frontDoorMode = options.frontDoor ?? 'ignore';
-    const frontDoors = [];
-    // Documents as the runtime loads them, keyed by absolute path: the walk below
-    // owns file-level checks (including the files loading drops), these own every
-    // identity-level one. Hidden dirs are excluded from both.
-    const docs = loadStoreMemoryDocs(store, true).filter((doc) => !doc.physicalRelativePath.split('/').some((segment) => segment.startsWith('.')));
-    const docsByPath = new Map(docs.map((doc) => [doc.path, doc]));
-    let checked = 0;
-    let documents = 0;
-    for (const file of walkFiles(store.storeRoot, (n) => n.endsWith('.md'), (d) => d.startsWith('.'))) {
-        const relPath = relative(store.storeRoot, file).split(sep).join('/');
-        if (relPath === '')
-            continue;
-        checked += 1;
-        if (lintDocumentFile({
-            store,
-            file,
-            relPath,
-            doc: docsByPath.get(file),
-            isProjectStore,
-            mounted,
-            ...(options.resolvable === undefined ? {} : { resolvable: options.resolvable }),
-            nestedStore: options.nestedStore === true,
-            add,
-            frontDoors,
-        }) === 'document') {
-            documents += 1;
-        }
-    }
-    // Same-store canonical collisions. The loader already orders `foo/INDEX.md`
-    // ahead of `foo.md`, so the first candidate is the deterministic read winner.
-    const byName = new Map();
-    for (const doc of docs) {
-        const bucket = byName.get(doc.name);
-        if (bucket)
-            bucket.push(doc);
-        else
-            byName.set(doc.name, [doc]);
-    }
-    for (const [name, candidates] of byName) {
-        if (candidates.length < 2)
-            continue;
-        const paths = candidates.map((doc) => doc.path);
-        add('error', 'canonical-collision', paths[0], `${candidates.length} files in this store own canonical name \`${name}\` (${paths.join(', ')}); \`${candidates[0].physicalRelativePath}\` is the deterministic read winner. Recover the collision with \`crtr memory move ${name} --to <new-free-name>\`; move selects the first physical path in stable lexical order, and no filesystem surgery is needed.`, { name, paths });
-    }
-    if (isProjectStore) {
-        for (const door of frontDoors) {
-            if (door.root)
-                continue;
-            add('error', 'front-door', door.path, `a project store's workspace front door is its root ${INDEX_SEGMENT}.md, not this doc — a {on: workspace-open, at: content} entry here delivers a second whole document at every workspace open; fold it into the root document or lower this entry`);
-        }
-        const repositoryRoot = (store.ownerRelativePath ?? '') === '';
-        const hasRootDoor = frontDoors.some((door) => door.root && door.complete);
-        if (repositoryRoot && !hasRootDoor && frontDoorMode !== 'ignore') {
-            const owner = store.ownerDir ?? store.storeRoot;
-            const message = frontDoorMode === 'required'
-                ? `the selected profile manages this project but its store has no workspace front door — ${FRONT_DOOR_REMEDY}`
-                : `this project store has no workspace front door, so agents open the workspace blind — ${FRONT_DOOR_REMEDY}`;
-            add(frontDoorMode === 'required' ? 'error' : 'warning', 'front-door', owner, message);
-        }
-    }
-    return makeResult(findings, checked, documents, 1);
-}
-/** Every rule that reads ONE file. The store sweep runs it per file, and
- *  `lintMemoryDocument` runs it alone; a rule asserted in one caller holds only
- *  there, so neither reimplements one. Store-level rules (canonical collisions,
- *  front-door coverage) are the caller's, because one file cannot see them. */
-function lintDocumentFile(ctx) {
-    const { store, file, relPath, doc, isProjectStore, mounted, resolvable, add } = ctx;
-    let fm;
-    let body;
-    try {
-        ({ data: fm, body } = parseFrontmatterGeneric(readText(file)));
-    }
-    catch (e) {
-        add('error', 'yaml', file, `invalid YAML frontmatter: ${(e instanceof Error ? e.message : String(e)).split('\n')[0]}`);
-        return 'yaml-error';
-    }
-    if (NON_DOCUMENT_FILES.has(basename(file)))
-        return 'non-document';
-    const isRootFile = localNameFromPath(relPath) === '';
-    // A file the loader dropped (a root INDEX.md composing to the empty name)
-    // carries no canonical identity, but its frontmatter contract still holds —
-    // the field rules below run before the identity-dependent ones.
-    const named = doc === undefined ? {} : { name: doc.name };
-    const schemaError = lintSubstrateFrontmatter(fm);
-    if (schemaError !== null)
-        add('error', 'schema', file, schemaError, named);
-    if (fm !== null) {
-        const isRepositoryRootStore = isProjectStore && store.ownerRelativePath === '';
-        if (fm['namespace'] !== undefined && !(isRootFile && isRepositoryRootStore)) {
-            const message = isRootFile && isProjectStore && store.ownerRelativePath !== undefined && store.ownerRelativePath !== ''
-                ? `\`namespace:\` belongs only on the repository-root store's ${INDEX_SEGMENT}.md (${store.namespacePath ?? store.storeRoot}) — a nested store's prefix is derived from its path under ${store.repositoryRoot ?? store.ownerDir ?? store.storeRoot}`
-                : `\`namespace:\` belongs only on a project store's root ${INDEX_SEGMENT}.md, where it declares the whole store's prefix — drop it here (an explicit \`name:\` is store-LOCAL and never carries a namespace)`;
-            add('error', 'namespace-placement', file, message, named);
-        }
-        if (isRootFile && fm['name'] !== undefined) {
-            add('error', 'root-name', file, `a store's root ${INDEX_SEGMENT}.md carries no \`name:\` — its identity answers at \`${store.namespace}\`; drop the field`, named);
-        }
-    }
-    if (doc === undefined) {
-        // In a project store the missing/invalid declaration is already the finding.
-        if (isRootFile && !isProjectStore) {
-            add('error', 'root-index-unaddressable', file, `a root ${INDEX_SEGMENT}.md has no canonical name in a ${store.scope} store, which declares no namespace — only a project store's root document answers at its namespace, so rename this file to a named document (\`<topic>.md\`) or fold its content into the docs it introduces`);
-        }
-        return 'document';
-    }
-    if (fm !== null) {
-        if (!isRootFile && fm['name'] !== undefined) {
-            const raw = fm['name'];
-            if (typeof raw !== 'string' || raw.trim() === '') {
-                add('error', 'local-name', file, `invalid name: ${JSON.stringify(raw)} (expected a non-empty store-local name)`, named);
-            }
-            else {
-                // Validated as WRITTEN: normalizing first would silently accept an
-                // `NN-` ordering prefix, which is physical-path-only. The suggestion
-                // is the normalized spelling.
-                const valid = validateExplicitLocalName(raw.trim(), store.namespace);
-                if (!valid.ok) {
-                    const suggested = suggestedLocalName(normalizeDocName(raw.trim()), store.namespace, relPath);
-                    add('error', 'local-name', file, `invalid name \`${raw}\`: ${valid.reason} — ${suggested}`, named);
-                }
-            }
-        }
-        for (const issue of validateMemoryExtensionValues(fm['extensions'], memoryExtensionValidationCatalog(doc))) {
-            add('error', 'extension', file, `${issue.path}: ${issue.message}`, named);
-        }
-        const lengthError = lintBodyLength(fm, body, doc.name);
-        if (lengthError !== null)
-            add('error', 'length', file, lengthError, named);
-        const shortPreview = lintShortPreviewBody(fm, body);
-        if (shortPreview !== null)
-            add('warning', 'short-preview', file, shortPreview, named);
-        const entries = parsedSubstrateSurfaces(fm);
-        if (ctx.nestedStore && entries.some((e) => e.on === 'boot')) {
-            add('warning', 'nested-store-boot', file, 'nested-store docs never ride the boot catalog, so its boot surfaces entries are inert — drop them', named);
-        }
-        if (isProjectStore && entries.some((e) => e.on === 'workspace-open' && e.at === 'content')) {
-            const complete = entries.some((entry) => {
-                if (entry.on !== 'read' || entry.at !== 'content')
-                    return false;
-                return entry.match?.includes('./**') === true;
-            });
-            ctx.frontDoors.push({ path: file, root: isRootFile, complete });
-        }
-        for (const entry of entries) {
-            if (entry.on !== 'memory-read')
-                continue;
-            lintMemoryReadEntry(entry, doc, fm, resolvable, mounted, add);
-        }
-    }
-    if (resolvable !== undefined && mounted) {
-        for (const name of docLinkNames(body)) {
-            if (resolvable.has(name))
-                continue;
-            add('error', 'dangling-link', file, `dangling doc link [[${name}]]: no memory document or directory in this target view has that exact canonical name.${missingNameDiagnostic(name)}`, named);
-        }
-    }
-    return 'document';
-}
-/** Lint ONE document, by absolute path, in the store that holds it. Runs every
- *  file-level rule the store sweep runs, and the store-level front-door rule
- *  this one file can violate on its own. It does NOT run the rules that need
- *  the whole store (canonical collisions, missing front-door coverage), so it
- *  never replaces `crtr memory lint` — it catches what an author just typed. */
-export function lintMemoryDocument(store, filePath, options = {}) {
-    const findings = [];
-    const base = {
-        scope: store.scope,
-        ...(store.storeRoot === '' ? {} : { storeRoot: store.storeRoot }),
-    };
-    const add = (severity, rule, path, message, extra = {}) => {
-        findings.push({ severity, rule, path, message, ...base, ...extra });
-    };
-    const relPath = relative(store.storeRoot, filePath).split(sep).join('/');
-    const doc = loadStoreMemoryDocs(store, true).find((candidate) => candidate.path === filePath);
-    const frontDoors = [];
-    const outcome = lintDocumentFile({
-        store,
-        file: filePath,
-        relPath,
-        doc,
-        isProjectStore: store.scope === 'project' && store.plugin === undefined,
-        mounted: store.mountStatus === 'ready',
-        ...(options.resolvable === undefined ? {} : { resolvable: options.resolvable }),
-        nestedStore: options.nestedStore === true,
-        add,
-        frontDoors,
-    });
-    // The one store-level rule a single document can break by itself: a front
-    // door anywhere but the store root delivers a second whole doc at every
-    // workspace open. A MISSING front door is the store's fault, not this doc's,
-    // so it stays with the sweep.
-    for (const door of frontDoors) {
-        if (door.root)
-            continue;
-        add('error', 'front-door', door.path, `a project store's workspace front door is its root ${INDEX_SEGMENT}.md, not this doc — a {on: workspace-open, at: content} entry here delivers a second whole document at every workspace open; fold it into the root document or lower this entry`);
-    }
-    return makeResult(findings, 1, outcome === 'document' ? 1 : 0, 1);
-}
-/** The local spelling an invalid explicit `name:` should use: dropping the field
- *  entirely when the physical path already derives the same identity. */
-function suggestedLocalName(local, namespace, physicalRelativePath) {
-    let fixed = collapseTrailingIndex(local);
-    if (namespace !== '') {
-        const nsSegments = canonicalSegments(namespace);
-        const segments = canonicalSegments(fixed);
-        if (nsSegments.every((s, i) => segments[i] === s))
-            fixed = segments.slice(nsSegments.length).join('/');
-    }
-    if (fixed === '') {
-        return `remove the field: this document's identity would be the store root's, which only the root ${INDEX_SEGMENT}.md owns`;
-    }
-    return fixed === localNameFromPath(physicalRelativePath)
-        ? `drop the field — its physical path already derives \`${fixed}\``
-        : `use \`name: ${fixed}\``;
-}
-function lintMemoryReadEntry(entry, doc, fm, resolvable, mounted, add) {
-    for (const glob of entry.match ?? []) {
-        if ((glob === '**' || glob === '*') && !ignoresRule(fm, 'broad-memory-read')) {
-            add('warning', 'broad-memory-read', doc.path, `memory-read glob \`${glob}\` fires on every memory read — scope it to a name subtree`, { name: doc.name });
-            continue;
-        }
-        if (resolvable === undefined || !mounted)
-            continue;
-        if (!GLOB_META_RE.test(glob)) {
-            const target = literalRouteTarget(glob, doc.routingAnchor);
-            if (!resolvable.has(target)) {
-                add('error', 'memory-read-route', doc.path, `memory-read route \`${glob}\` names \`${target}\`, which is no document or directory in this target view, so the entry can never fire.${missingNameDiagnostic(target)}`, { name: doc.name });
-            }
-            continue;
-        }
-        if (!routeMatchesAny(glob, doc.routingAnchor, resolvable)) {
-            add('warning', 'memory-read-route', doc.path, `memory-read glob \`${glob}\`${glob.startsWith('./') ? ` (anchored at \`${doc.routingAnchor}\`)` : ''} matches no canonical name in this target view — a project document's name carries its store's namespace, so an unqualified subtree glob no longer matches`, { name: doc.name });
-        }
-    }
-}
-function ambientTarget() {
-    return {
-        cwd: process.cwd(),
-        profileId: envProfileId() || null,
-        nodeId: envNodeId() || null,
-    };
-}
-/** Lint every store a target sees, then the diagnostics only the merged view
- *  produces: references resolved against the view's canonical names, and equal
- *  canonical identities held by several stores. */
-export function lintMemoryTarget(options = {}) {
-    const target = options.target ?? ambientTarget();
-    const includeDescendants = options.includeDescendants ?? true;
-    const view = loadMemoryTargetView(target, {
-        ...(options.scope === undefined ? {} : { scope: options.scope }),
-        includeDescendants,
-        quiet: true,
-    });
-    const resolvable = resolvableCanonicalNames(view.docs);
-    const nestedStores = new Set(includeDescendants
-        ? descendantStoreRoots(projectScopeRoots(target.cwd, target.profileId)).map((root) => realpathOrSelf(join(root, 'memory')))
-        : []);
-    // Profile coverage: every project the selected profile manages carries a
-    // workspace front door. A managed project with no store at all still owes one.
-    const coverage = options.scope === undefined || options.scope === 'project';
-    const managed = new Set();
-    const managedRepositories = new Set();
-    if (coverage && target.profileId !== null && target.profileId !== '') {
-        try {
-            const { manifest } = loadProfileManifest(target.profileId);
-            for (const project of manifest.projects) {
-                const owner = realpathOrSelf(project.path);
-                managed.add(owner);
-                const association = associateRepository(owner);
-                managedRepositories.add(association.ok ? association.association.repositoryRoot : owner);
-            }
-        }
-        catch {
-            // Missing/deleted/invalid selected profile: no managed-project coverage.
-        }
-    }
-    const cwdReal = realpathOrSelf(target.cwd);
-    const findings = [];
-    let checked = 0;
-    let documents = 0;
-    let storesLinted = 0;
-    const linted = new Set();
-    for (const store of view.stores) {
-        const owner = store.ownerDir === undefined ? null : realpathOrSelf(store.ownerDir);
-        const repositoryRoot = store.repositoryRoot ?? owner;
-        if (repositoryRoot !== null && repositoryRoot !== undefined)
-            linted.add(repositoryRoot);
-        const nested = store.ownerRelativePath !== undefined && store.ownerRelativePath !== '';
-        const frontDoor = nested || !coverage || owner === null
-            ? 'ignore'
-            : managedRepositories.has(repositoryRoot ?? owner)
-                ? 'required'
-                : managed.size === 0 && owner === cwdReal
-                    ? 'advisory'
-                    : 'ignore';
-        const result = lintMemoryStore(store, {
-            resolvable,
-            frontDoor,
-            nestedStore: nestedStores.has(realpathOrSelf(store.storeRoot)),
-        });
-        findings.push(...result.findings);
-        checked += result.checked;
-        documents += result.documents;
-        storesLinted += result.storesLinted;
-    }
-    if (coverage) {
-        // A managed project whose directory holds no `.crouter/` never became a
-        // store in the view, and still owes a front door at its repository root.
-        for (const owner of managed) {
-            const association = associateRepository(owner);
-            const repositoryRoot = association.ok ? association.association.repositoryRoot : owner;
-            if (linted.has(repositoryRoot))
-                continue;
-            const result = lintMemoryStore(openProjectMemoryStore(repositoryRoot), { resolvable, frontDoor: 'required' });
-            findings.push(...result.findings);
-            checked += result.checked;
-            documents += result.documents;
-            storesLinted += result.storesLinted;
-            linted.add(repositoryRoot);
-        }
-        const cwdAssociation = associateRepository(cwdReal);
-        const cwdRepositoryRoot = cwdAssociation.ok ? cwdAssociation.association.repositoryRoot : cwdReal;
-        if (managed.size === 0 && !linted.has(cwdRepositoryRoot) && pathExists(join(target.cwd, '.crouter'))) {
-            const result = lintMemoryStore(openProjectMemoryStore(target.cwd), { resolvable, frontDoor: 'advisory' });
-            findings.push(...result.findings);
-            checked += result.checked;
-            documents += result.documents;
-            storesLinted += result.storesLinted;
-        }
-    }
-    // Equal canonical identities across stores are legitimate — a linked worktree
-    // and its main checkout declare one namespace on purpose — so they are
-    // reported with the view's winner and every ordered candidate, never failed.
-    const tree = buildMemoryTree(view.docs);
-    const walk = (node) => {
-        const candidates = node.documentCandidates;
-        if (candidates.length > 1 && new Set(candidates.map((doc) => doc.root)).size > 1) {
-            findings.push({
-                severity: 'notice',
-                rule: 'cross-store-candidates',
-                path: candidates[0].path,
-                name: node.name,
-                paths: candidates.map((doc) => doc.path),
-                message: `canonical name \`${node.name}\` is held by ${candidates.length} stores; this target view reads ${candidates[0].path} (${candidates[0].scope}) and the later candidates stay reachable with \`crtr memory read ${node.name} --dir <project>\``,
-            });
-        }
-        for (const child of node.childDirectories)
-            walk(child);
-        for (const child of node.childDocuments)
-            walk(child);
-    };
-    walk(tree.root);
-    // Reachability is a whole-view property, so it runs once over the target view
-    // and only in the unfiltered view — a `--scope` slice hides the surfaced or
-    // linking docs that make a doc reachable and would report false orphans.
-    if (options.scope === undefined)
-        findings.push(...lintOrphans(view.docs));
-    return {
-        ...makeResult(findings, checked, documents, storesLinted),
-        stores: view.stores,
-        profileProjects: managed.size,
-    };
-}
+var J=Object.defineProperty;var w=(e,t)=>J(e,"name",{value:t,configurable:!0});import{envNodeId as Q,envProfileId as Z}from"../../shared/env.js";import{basename as ee,join as L,matchesGlob as te,relative as W,sep as A}from"node:path";import{pathExists as oe,readText as ne,realpathOrSelf as D,walkFiles as re}from"../fs-utils.js";import{parseFrontmatterGeneric as se}from"../frontmatter.js";import{descendantStoreRoots as ie}from"../nested-stores.js";import{projectScopeRoots as ae}from"../scope.js";import{associateRepository as j}from"./repository-association.js";import{loadProfileManifest as ce}from"../profiles/manifest.js";import{loadMemoryTargetView as de,loadStoreMemoryDocs as F,openProjectMemoryStore as q}from"../memory-resolver.js";import{buildMemoryTree as N}from"./tree.js";import{canonicalSegments as E,collapseTrailingIndex as C,INDEX_SEGMENT as $,localNameFromPath as B,normalizeDocName as G,validateExplicitLocalName as le}from"./identity.js";import{lintSubstrateFrontmatter as me,parsedSubstrateSurfaces as x}from"../substrate/frontmatter-validation.js";import{memoryExtensionValidationCatalog as fe,validateMemoryExtensionValues as ue}from"./extensions.js";import{docLinkNames as z}from"./doc-link-grammar.js";const Ce=new Set(["store-namespace","namespace-placement","owner-path-collision","root-name","root-index-unaddressable","local-name","canonical-collision","dangling-link","memory-read-route"]);function M(e,t,n,r){const s=e.filter(a=>a.severity==="error");return{ok:s.length===0,checked:t,documents:n,storesLinted:r,findings:e,errors:s,warnings:e.filter(a=>a.severity==="warning"),notices:e.filter(a=>a.severity==="notice")}}w(M,"makeResult");const P=1e3,V=1e3,T=3e3,he=30,O="Keep the load-bearing core here and split the depth into [[linked]] reference docs carrying no surfaces at all (the listing and the link are how they are found, so they cost nothing until followed). Split by subject: each leaf covers a different subject a task might need on its own; never split off \u201Cfurther evidence\u201D, examples, or references \u2014 a references leaf is never followed, so supporting material stays next to the point it supports or gets cut. Keep it whole \u2014 `lint-ignore: length` in the frontmatter \u2014 only when every reader who surfaces this doc genuinely benefits from reading 100% of it, or it is one indivisible body of knowledge; then splitting just adds hops.";function _(e,t){const n=e["lint-ignore"];return n===t||Array.isArray(n)&&n.includes(t)}w(_,"ignoresRule");function X(e){const t=e.trim();return t===""?0:t.split(/\s+/).length}w(X,"countBodyWords");function pe(e,t,n){if(_(e,"length")||n==="kinds"||n.startsWith("kinds/"))return null;const r=x(e),s=X(t);if(r.some(d=>d.on==="boot"&&d.at==="content")&&s>P)return`body is ${s} words but a boot entry at \`content\` inlines every word into every agent's system prompt \u2014 capped at ${P} words (boot preview gets ${T}; name entries are never capped). ${O}`;const a=[...new Set(r.filter(d=>d.on!=="boot"&&d.at==="content").map(d=>d.on))];return a.length>0&&s>V?`body is ${s} words, over the ${V}-word cap for a \`content\` entry on ${a.join("/")} (the whole body delivers every time the entry fires; name entries are never capped). ${O}`:r.some(d=>d.on==="boot"&&d.at==="preview")&&s>T?`body is ${s} words, over the ${T}-word cap for boot preview (the routing line invites every reader into the whole body, so the cap is the longest doc worth reading end-to-end; boot content is capped at ${P} words; name entries are never capped). ${O}`:null}w(pe,"lintBodyLength");function ye(e,t){const n=X(t);if(n>=he)return null;const r=[...new Set(x(e).filter(a=>a.at==="preview").map(a=>a.on))];if(r.length===0)return null;const s=r.length===1?"entry delivers":"entries deliver";return`body is ${n} words but the ${r.join("/")} ${s} \`preview\`; use \`at: content\` so agents receive the whole rule without a separate memory read`}w(ye,"lintShortPreviewBody");function we(e){const t=new Set,n=w(r=>{r.name!==""&&t.add(r.name);for(const s of r.childDirectories)n(s);for(const s of r.childDocuments)t.add(s.name)},"walk");return n(N(e).root),t}w(we,"resolvableCanonicalNames");function ge(e,t={}){const n=N(e),r=new Map,s=w(o=>{o.name!==""&&r.set(o.name,o);for(const l of o.childDirectories)s(l);for(const l of o.childDocuments)r.set(l.name,l)},"indexWalk");s(n.root);const a=new Set,d=[],f=w(o=>{o===""||a.has(o)||!r.has(o)||(a.add(o),d.push(o))},"enqueue");for(const o of e){const l=o.frontmatter??{};(x(l).length>0||l.slash===!0)&&f(o.name)}for(;d.length>0;){const o=r.get(d.shift()),l=o.document;if(l!==null)for(const p of z(l.body))r.has(p)&&f(p);if(!(l===null||l.localName==="")){for(const p of o.childDirectories)p.document?.frontmatter?.unlisted!==!0&&f(p.name);for(const p of o.childDocuments)p.document.frontmatter?.unlisted!==!0&&f(p.name)}}const u=[];for(const o of e)t.flagStoreRoot!==void 0&&o.store.storeRoot!==t.flagStoreRoot||a.has(o.name)||o.scope==="builtin"||o.plugin!==void 0||o.localName!==""&&(o.name==="kinds"||o.name.startsWith("kinds/")||_(o.frontmatter??{},"orphan")||u.push({severity:"warning",rule:"orphan",path:o.path,name:o.name,scope:o.scope,...o.store.storeRoot===""?{}:{storeRoot:o.store.storeRoot},message:`\`${o.name}\` is unreachable: no surface delivers it, no reached document links it, and no reached directory lists it \u2014 it is findable only by deliberate search. Give it a surface, link it from a reached doc (a cluster index, or its directory's own ${$}.md), or accept it with \`lint-ignore: orphan\`.`}));return u}w(ge,"lintOrphans");const Y='the store\'s root INDEX.md is the workspace front door: give it `surfaces: [{on: workspace-open, at: content}, {on: read, match: "./**", at: content}]` (run `crtr memory write -h` first)',ve=/[*?[\]{}]/;function K(e,t){try{return te(e,t)}catch{return!1}}w(K,"safeGlob");function Re(e,t){const n=e.startsWith("./")?e.slice(2):e,r=e.startsWith("./")?`${t}/${n}`:n;return E(G(r)).join("/")}w(Re,"literalRouteTarget");function be(e,t,n){if(!e.startsWith("./")){for(const a of n)if(K(a,e))return!0;return!1}const r=e.slice(2),s=t===""?"":`${t}/`;for(const a of n)if(a.startsWith(s)&&K(a.slice(s.length),r))return!0;return!1}w(be,"routeMatchesAny");function U(e){const t=E(e),n=t[t.length-1]===$,r=C(e),s=E(r).pop()??e;return`${n?` A directory's own document answers at the directory name, so name \`${r}\` instead.`:""} Run \`crtr memory find ${s}\` for the canonical name, or drop the reference.`}w(U,"missingNameDiagnostic");const $e=new Set(["SKILL.md","MEMORY.md"]);function I(e,t={}){const n=[],r={scope:e.scope,...e.storeRoot===""?{}:{storeRoot:e.storeRoot}},s=w((c,m,g,i,y={})=>{n.push({severity:c,rule:m,path:g,message:i,...r,...y})},"add"),a=e.mountStatus==="ready";e.mountFailure==="collision"?s("error","owner-path-collision",e.namespacePath??e.storeRoot,e.diagnostic??`project memory stores have owner directories that normalize to the same effective prefix \`${e.namespace}\` \u2014 rename one owner directory`):(e.mountStatus==="undeclared"||e.mountStatus==="invalid")&&s("error","store-namespace",e.namespacePath??e.storeRoot,e.diagnostic??"project memory store does not mount"),(e.mountStatus==="undeclared"||e.mountStatus==="invalid")&&t.resolvable!==void 0&&s("notice","reference-check-deferred",e.storeRoot,"links and `memory-read` routes are not checked here: the canonical identities they resolve against are undetermined until this store declares its namespace");const d=e.scope==="project"&&e.plugin===void 0,f=t.frontDoor??"ignore",u=[],o=F(e,!0).filter(c=>!c.physicalRelativePath.split("/").some(m=>m.startsWith("."))),l=new Map(o.map(c=>[c.path,c]));let p=0,v=0;for(const c of re(e.storeRoot,m=>m.endsWith(".md"),m=>m.startsWith("."))){const m=W(e.storeRoot,c).split(A).join("/");m!==""&&(p+=1,H({store:e,file:c,relPath:m,doc:l.get(c),isProjectStore:d,mounted:a,...t.resolvable===void 0?{}:{resolvable:t.resolvable},nestedStore:t.nestedStore===!0,add:s,frontDoors:u})==="document"&&(v+=1))}const R=new Map;for(const c of o){const m=R.get(c.name);m?m.push(c):R.set(c.name,[c])}for(const[c,m]of R){if(m.length<2)continue;const g=m.map(i=>i.path);s("error","canonical-collision",g[0],`${m.length} files in this store own canonical name \`${c}\` (${g.join(", ")}); \`${m[0].physicalRelativePath}\` is the deterministic read winner. Recover the collision with \`crtr memory move ${c} --to <new-free-name>\`; move selects the first physical path in stable lexical order, and no filesystem surgery is needed.`,{name:c,paths:g})}if(d){for(const g of u)g.root||s("error","front-door",g.path,`a project store's workspace front door is its root ${$}.md, not this doc \u2014 a {on: workspace-open, at: content} entry here delivers a second whole document at every workspace open; fold it into the root document or lower this entry`);const c=(e.ownerRelativePath??"")==="",m=u.some(g=>g.root&&g.complete);if(c&&!m&&f!=="ignore"){const g=e.ownerDir??e.storeRoot,i=f==="required"?`the selected profile manages this project but its store has no workspace front door \u2014 ${Y}`:`this project store has no workspace front door, so agents open the workspace blind \u2014 ${Y}`;s(f==="required"?"error":"warning","front-door",g,i)}}return M(n,p,v,1)}w(I,"lintMemoryStore");function H(e){const{store:t,file:n,relPath:r,doc:s,isProjectStore:a,mounted:d,resolvable:f,add:u}=e;let o,l;try{({data:o,body:l}=se(ne(n)))}catch(c){return u("error","yaml",n,`invalid YAML frontmatter: ${(c instanceof Error?c.message:String(c)).split(`
+`)[0]}`),"yaml-error"}if($e.has(ee(n)))return"non-document";const p=B(r)==="",v=s===void 0?{}:{name:s.name},R=me(o);if(R!==null&&u("error","schema",n,R,v),o!==null){const c=a&&t.ownerRelativePath==="";if(o.namespace!==void 0&&!(p&&c)){const m=p&&a&&t.ownerRelativePath!==void 0&&t.ownerRelativePath!==""?`\`namespace:\` belongs only on the repository-root store's ${$}.md (${t.namespacePath??t.storeRoot}) \u2014 a nested store's prefix is derived from its path under ${t.repositoryRoot??t.ownerDir??t.storeRoot}`:`\`namespace:\` belongs only on a project store's root ${$}.md, where it declares the whole store's prefix \u2014 drop it here (an explicit \`name:\` is store-LOCAL and never carries a namespace)`;u("error","namespace-placement",n,m,v)}p&&o.name!==void 0&&u("error","root-name",n,`a store's root ${$}.md carries no \`name:\` \u2014 its identity answers at \`${t.namespace}\`; drop the field`,v)}if(s===void 0)return p&&!a&&u("error","root-index-unaddressable",n,`a root ${$}.md has no canonical name in a ${t.scope} store, which declares no namespace \u2014 only a project store's root document answers at its namespace, so rename this file to a named document (\`<topic>.md\`) or fold its content into the docs it introduces`),"document";if(o!==null){if(!p&&o.name!==void 0){const i=o.name;if(typeof i!="string"||i.trim()==="")u("error","local-name",n,`invalid name: ${JSON.stringify(i)} (expected a non-empty store-local name)`,v);else{const y=le(i.trim(),t.namespace);if(!y.ok){const h=Se(G(i.trim()),t.namespace,r);u("error","local-name",n,`invalid name \`${i}\`: ${y.reason} \u2014 ${h}`,v)}}}for(const i of ue(o.extensions,fe(s)))u("error","extension",n,`${i.path}: ${i.message}`,v);const c=pe(o,l,s.name);c!==null&&u("error","length",n,c,v);const m=ye(o,l);m!==null&&u("warning","short-preview",n,m,v);const g=x(o);if(e.nestedStore&&g.some(i=>i.on==="boot")&&u("warning","nested-store-boot",n,"nested-store docs never ride the boot catalog, so its boot surfaces entries are inert \u2014 drop them",v),a&&g.some(i=>i.on==="workspace-open"&&i.at==="content")){const i=g.some(y=>y.on!=="read"||y.at!=="content"?!1:y.match?.includes("./**")===!0);e.frontDoors.push({path:n,root:p,complete:i})}for(const i of g)i.on==="memory-read"&&ke(i,s,o,f,d,u)}if(f!==void 0&&d)for(const c of z(l))f.has(c)||u("error","dangling-link",n,`dangling doc link [[${c}]]: no memory document or directory in this target view has that exact canonical name.${U(c)}`,v);return"document"}w(H,"lintDocumentFile");function Be(e,t,n={}){const r=[],s={scope:e.scope,...e.storeRoot===""?{}:{storeRoot:e.storeRoot}},a=w((l,p,v,R,c={})=>{r.push({severity:l,rule:p,path:v,message:R,...s,...c})},"add"),d=W(e.storeRoot,t).split(A).join("/"),f=F(e,!0).find(l=>l.path===t),u=[],o=H({store:e,file:t,relPath:d,doc:f,isProjectStore:e.scope==="project"&&e.plugin===void 0,mounted:e.mountStatus==="ready",...n.resolvable===void 0?{}:{resolvable:n.resolvable},nestedStore:n.nestedStore===!0,add:a,frontDoors:u});for(const l of u)l.root||a("error","front-door",l.path,`a project store's workspace front door is its root ${$}.md, not this doc \u2014 a {on: workspace-open, at: content} entry here delivers a second whole document at every workspace open; fold it into the root document or lower this entry`);return M(r,1,o==="document"?1:0,1)}w(Be,"lintMemoryDocument");function Se(e,t,n){let r=C(e);if(t!==""){const s=E(t),a=E(r);s.every((d,f)=>a[f]===d)&&(r=a.slice(s.length).join("/"))}return r===""?`remove the field: this document's identity would be the store root's, which only the root ${$}.md owns`:r===B(n)?`drop the field \u2014 its physical path already derives \`${r}\``:`use \`name: ${r}\``}w(Se,"suggestedLocalName");function ke(e,t,n,r,s,a){for(const d of e.match??[]){if((d==="**"||d==="*")&&!_(n,"broad-memory-read")){a("warning","broad-memory-read",t.path,`memory-read glob \`${d}\` fires on every memory read \u2014 scope it to a name subtree`,{name:t.name});continue}if(!(r===void 0||!s)){if(!ve.test(d)){const f=Re(d,t.routingAnchor);r.has(f)||a("error","memory-read-route",t.path,`memory-read route \`${d}\` names \`${f}\`, which is no document or directory in this target view, so the entry can never fire.${U(f)}`,{name:t.name});continue}be(d,t.routingAnchor,r)||a("warning","memory-read-route",t.path,`memory-read glob \`${d}\`${d.startsWith("./")?` (anchored at \`${t.routingAnchor}\`)`:""} matches no canonical name in this target view \u2014 a project document's name carries its store's namespace, so an unqualified subtree glob no longer matches`,{name:t.name})}}}w(ke,"lintMemoryReadEntry");function De(){return{cwd:process.cwd(),profileId:Z()||null,nodeId:Q()||null}}w(De,"ambientTarget");function Ge(e={}){const t=e.target??De(),n=e.includeDescendants??!0,r=de(t,{...e.scope===void 0?{}:{scope:e.scope},includeDescendants:n,quiet:!0}),s=we(r.docs),a=new Set(n?ie(ae(t.cwd,t.profileId)).map(i=>D(L(i,"memory"))):[]),d=e.scope===void 0||e.scope==="project",f=new Set,u=new Set;if(d&&t.profileId!==null&&t.profileId!=="")try{const{manifest:i}=ce(t.profileId);for(const y of i.projects){const h=D(y.path);f.add(h);const S=j(h);u.add(S.ok?S.association.repositoryRoot:h)}}catch{}const o=D(t.cwd),l=[];let p=0,v=0,R=0;const c=new Set;for(const i of r.stores){const y=i.ownerDir===void 0?null:D(i.ownerDir),h=i.repositoryRoot??y;h!=null&&c.add(h);const k=i.ownerRelativePath!==void 0&&i.ownerRelativePath!==""||!d||y===null?"ignore":u.has(h??y)?"required":f.size===0&&y===o?"advisory":"ignore",b=I(i,{resolvable:s,frontDoor:k,nestedStore:a.has(D(i.storeRoot))});l.push(...b.findings),p+=b.checked,v+=b.documents,R+=b.storesLinted}if(d){for(const h of f){const S=j(h),k=S.ok?S.association.repositoryRoot:h;if(c.has(k))continue;const b=I(q(k),{resolvable:s,frontDoor:"required"});l.push(...b.findings),p+=b.checked,v+=b.documents,R+=b.storesLinted,c.add(k)}const i=j(o),y=i.ok?i.association.repositoryRoot:o;if(f.size===0&&!c.has(y)&&oe(L(t.cwd,".crouter"))){const h=I(q(t.cwd),{resolvable:s,frontDoor:"advisory"});l.push(...h.findings),p+=h.checked,v+=h.documents,R+=h.storesLinted}}const m=N(r.docs),g=w(i=>{const y=i.documentCandidates;y.length>1&&new Set(y.map(h=>h.root)).size>1&&l.push({severity:"notice",rule:"cross-store-candidates",path:y[0].path,name:i.name,paths:y.map(h=>h.path),message:`canonical name \`${i.name}\` is held by ${y.length} stores; this target view reads ${y[0].path} (${y[0].scope}) and the later candidates stay reachable with \`crtr memory read ${i.name} --dir <project>\``});for(const h of i.childDirectories)g(h);for(const h of i.childDocuments)g(h)},"walk");return g(m.root),e.scope===void 0&&l.push(...ge(r.docs)),{...M(l,p,v,R),stores:r.stores,profileProjects:f.size}}w(Ge,"lintMemoryTarget");export{Ce as MEMORY_LINT_IDENTITY_RULES,pe as lintBodyLength,Be as lintMemoryDocument,I as lintMemoryStore,Ge as lintMemoryTarget,ge as lintOrphans,ye as lintShortPreviewBody,we as resolvableCanonicalNames};