hypomnema 1.3.3 → 1.4.0

package/scripts/lib/hypo-ignore.mjs

@@ -23,6 +23,30 @@ function globToRegex(glob) {
   );
 }
 
+// Generated, regenerable tool artifacts that live at the WIKI ROOT and must not
+// pollute the knowledge catalog. These are intentionally NOT added to
+// .hypoignore: that list also drives the pre-commit secret gate
+// (hooks/hypo-pre-commit.mjs), so listing them there would block the report's
+// commit and freeze every auto-commit while it sits at root. Instead they are
+// excluded from catalog/scan only, via isScanIgnored(). The patterns are
+// anchored to the root-relative path (no '/'), so an equivalent name nested
+// under pages/, projects/, or sources/ is left untouched.
+const GENERATED_ARTIFACT_RES = [/^MIGRATION-v[^/]*\.md$/, /^GRAPH_REPORT\.md$/];
+
+export function isGeneratedArtifact(filePath, hypoDir) {
+  const rel = relative(hypoDir, filePath).replace(/\\/g, '/');
+  return GENERATED_ARTIFACT_RES.some((re) => re.test(rel));
+}
+
+// Catalog/scan exclusion = privacy/.hypoignore patterns PLUS generated root
+// artifacts. Use this in tools that build the knowledge catalog (lint, graph,
+// stats, query, verify, crystallize, rename, doctor broken-links). Do NOT use it
+// in the pre-commit gate or ingest --check, which are privacy boundaries that
+// must stay on isIgnored()/.hypoignore alone.
+export function isScanIgnored(filePath, hypoDir, patterns) {
+  return isIgnored(filePath, hypoDir, patterns) || isGeneratedArtifact(filePath, hypoDir);
+}
+
 export function isIgnored(filePath, hypoDir, patterns) {
   const rel = relative(hypoDir, filePath).replace(/\\/g, '/');
   const base = basename(filePath);

package/scripts/lib/schema-vocab.mjs

@@ -94,3 +94,38 @@ export function parseSchemaPageDirs(hypoDir) {
   }
   return dirs;
 }
+
+// Type-token shape: lowercase identifier (a-z, digits, hyphen). Excludes
+// memory-layer rows whose first cell is a filename (`hot.md`, `log.md`) — those
+// carry a `.` and never match — so only real type names survive.
+const TYPE_TOKEN_RE = /^[a-z][a-z0-9-]+$/;
+
+// Derive the set of valid page `type` values from the SCHEMA "Page Type
+// Taxonomy" table — the FIRST backticked cell of each table row (the type
+// column). Single source of truth, mirroring parseSchemaPageDirs: adding a type
+// row to a vault's SCHEMA automatically widens the accepted types, so a
+// vault-local extension (e.g. working-doc / draft / qa-run) stops tripping the
+// W2 unknown-type warning without editing lint. Returns an empty Set when
+// SCHEMA.md or the table is absent — callers union this with a hardcoded core so
+// the core types never depend on a present/complete SCHEMA.
+export function parseSchemaTypes(hypoDir) {
+  const path = join(hypoDir, 'SCHEMA.md');
+  if (!existsSync(path)) return new Set();
+  const content = readFileSync(path, 'utf-8');
+
+  const headerMatch = TYPE_TAXONOMY_HEADER_RE.exec(content);
+  if (!headerMatch) return new Set();
+
+  const sectionStart = headerMatch.index + headerMatch[0].length;
+  const rest = content.slice(sectionStart);
+  const nextH2 = NEXT_H2_RE.exec(rest);
+  const section = nextH2 ? rest.slice(0, nextH2.index) : rest;
+
+  const types = new Set();
+  for (const rawLine of section.split('\n')) {
+    if (!rawLine.trimStart().startsWith('|')) continue;
+    const m = rawLine.match(/`([^`]+)`/); // first backtick token = type column
+    if (m && TYPE_TOKEN_RE.test(m[1].trim())) types.add(m[1].trim());
+  }
+  return types;
+}

package/scripts/lib/template-schema-version.mjs

@@ -0,0 +1,21 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { parseFrontmatter } from './frontmatter.mjs';
+
+// The SCHEMA version this package ships, read from templates/SCHEMA.md
+// frontmatter. init.mjs / upgrade.mjs stamp it into hypo-pkg.json metadata;
+// deriving it here (rather than hardcoding a literal at each write site) keeps
+// the stamped value from going stale on a schema bump — the failure mode that
+// FEAT-1's 2.0 → 2.1 bump would otherwise have introduced. Returns null only if
+// the template is missing/unreadable (a broken package), in which case callers
+// keep their prior literal default.
+export function templateSchemaVersion(pkgRoot) {
+  const p = join(pkgRoot, 'templates', 'SCHEMA.md');
+  if (!existsSync(p)) return null;
+  try {
+    const v = (parseFrontmatter(readFileSync(p, 'utf-8')) || {}).version;
+    return v ? String(v) : null;
+  } catch {
+    return null;
+  }
+}

package/scripts/lib/wikilink.mjs

@@ -0,0 +1,156 @@
+// Shared wikilink primitives — the ONE source of truth for vault traversal,
+// slug-form generation, and bare wikilink extraction.
+//
+// Consumed by:
+//   - scripts/lint.mjs        (slug map, page collection, link-target scan)
+//   - scripts/rename.mjs      (form index with collision detection, page scan)
+//   - scripts/graph.mjs       (slug index, page collection, link extraction)
+//   - scripts/crystallize.mjs (page collection, link extraction)
+//
+// IMPR-13 consolidation. Before this lib, each script carried its own copy of
+// collectPages + a slug-form deriver, drifting in subtle ways. The four
+// collectPages variants are NOT interchangeable — they differ deliberately in
+// traversal/security/output-shape policy (codex design review, CONCERN):
+//
+//   - rename uses lstat + skips symlinks   → a vault scan can never escape via a
+//     symlinked dir/file (security boundary).
+//   - lint skips `_`-prefixed DIRECTORIES  → pages/feedback/_drafts scaffolds
+//     stay out of the lint set, while `_`-prefixed FILES (e.g. _index.md) lint.
+//   - crystallize skips ANY `.`-prefixed entry (dir AND file).
+//   - graph/lint/rename skip only `.`-prefixed FILES.
+//   - graph/crystallize emit raw `rel`/`slug`; lint keeps OS-native `rel`
+//     (its own buildSlugMap POSIX-normalizes downstream); rename/graph
+//     POSIX-normalize the slug at scan time.
+//
+// So this lib exposes ONE walker core plus four NAMED PRESETS, not a pile of
+// boolean flags — each preset pins exactly one caller's historical behavior and
+// is fixed by a unit test. readdirSync order is preserved verbatim (NO sort):
+// graph's bare-first slug index is order-sensitive (first page wins a shared
+// bare form), so adding a sort would silently change resolution.
+//
+// Collision RESOLUTION is intentionally NOT shared: lint dedups into a Set
+// (membership), rename detects ambiguity to refuse unsafe auto-rewrites, graph
+// is first-wins. Each caller builds its own structure from slugForms(); only the
+// form GENERATION lives here.
+
+import { existsSync, readdirSync, statSync, lstatSync } from 'fs';
+import { join, relative, extname, basename } from 'path';
+import { isScanIgnored } from './hypo-ignore.mjs';
+
+// ── markdown page walker (shared core) ─────────────────────────────────────────
+// `policy` keys (all optional):
+//   lstat            — stat with lstatSync and skip symlinks (rename's security
+//                      boundary). Default: statSync, symlinks followed.
+//   skipDotEntry     — skip ANY entry (dir or file) whose name starts with `.`
+//                      BEFORE the ignore check (crystallize).
+//   skipUnderscoreDir— skip directories whose name starts with `_` (lint).
+//   skipDotFile      — among `.md` files, skip names starting with `.`.
+//   shape(full)      — build the per-page record pushed onto the accumulator.
+function walkMarkdown(dir, root, ignorePatterns, policy, acc) {
+  if (!existsSync(dir)) return acc;
+  for (const entry of readdirSync(dir)) {
+    if (policy.skipDotEntry && entry.startsWith('.')) continue;
+    const full = join(dir, entry);
+    if (isScanIgnored(full, root, ignorePatterns)) continue;
+    const st = policy.lstat ? lstatSync(full) : statSync(full);
+    if (policy.lstat && st.isSymbolicLink()) continue;
+    if (st.isDirectory()) {
+      if (policy.skipUnderscoreDir && entry.startsWith('_')) continue;
+      walkMarkdown(full, root, ignorePatterns, policy, acc);
+    } else if (extname(entry) === '.md' && !(policy.skipDotFile && entry.startsWith('.'))) {
+      acc.push(policy.shape(full));
+    }
+  }
+  return acc;
+}
+
+const posixSlug = (full, root) => relative(root, full).replace(/\.md$/, '').replace(/\\/g, '/');
+
+// lint: `_`-dir skip + `_`-file kept; OS-native `rel` (buildSlugMap normalizes).
+export function collectPagesLint(dir, root, ignorePatterns = []) {
+  return walkMarkdown(
+    dir,
+    root,
+    ignorePatterns,
+    {
+      skipDotFile: true,
+      skipUnderscoreDir: true,
+      shape: (full) => ({ path: full, rel: relative(root, full) }),
+    },
+    [],
+  );
+}
+
+// graph: POSIX slug + bare, no `rel`.
+export function collectPagesGraph(dir, root, ignorePatterns = []) {
+  return walkMarkdown(
+    dir,
+    root,
+    ignorePatterns,
+    {
+      skipDotFile: true,
+      shape: (full) => ({ path: full, slug: posixSlug(full, root), bare: basename(full, '.md') }),
+    },
+    [],
+  );
+}
+
+// rename: lstat + symlink skip (security); POSIX rel/slug/bare.
+export function collectPagesRename(dir, root, ignorePatterns = []) {
+  return walkMarkdown(
+    dir,
+    root,
+    ignorePatterns,
+    {
+      lstat: true,
+      skipDotFile: true,
+      shape: (full) => {
+        const rel = relative(root, full).replace(/\\/g, '/');
+        return { path: full, rel, slug: rel.replace(/\.md$/, ''), bare: basename(full, '.md') };
+      },
+    },
+    [],
+  );
+}
+
+// crystallize: skip ANY `.`-prefixed entry; OS-native `rel`.
+export function collectPagesCrystallize(dir, root, ignorePatterns = []) {
+  return walkMarkdown(
+    dir,
+    root,
+    ignorePatterns,
+    { skipDotEntry: true, shape: (full) => ({ path: full, rel: relative(root, full) }) },
+    [],
+  );
+}
+
+// ── slug-form generation ───────────────────────────────────────────────────────
+// From a POSIX no-extension slug (e.g. `pages/learnings/foo`), derive the three
+// link forms a [[wikilink]] may use:
+//   full   — the whole slug                       [[pages/learnings/foo]]
+//   bare   — the basename                         [[foo]]
+//   dirRel — slug minus the leading scan-dir seg  [[learnings/foo]]  (null if the
+//            slug has no `/`, i.e. nothing to drop)
+// Callers pick which forms to register and own their own collision policy. Do NOT
+// apply this to link-target-only slugs (lint's root-md/sources extraTargets,
+// rename's sources/*) — those resolve VERBATIM, with no derived alias, so a bare
+// form can't mask an unrelated broken link or block a safe rewrite.
+export function slugForms(slug) {
+  const slash = slug.indexOf('/');
+  return { full: slug, bare: basename(slug), dirRel: slash === -1 ? null : slug.slice(slash + 1) };
+}
+
+// ── bare wikilink extraction (graph/crystallize variant) ───────────────────────
+// Raw extraction: matches [[target]] / [[target|alias]] / [[target#anchor]]
+// anywhere, INCLUDING inside code fences (graph counts those as edges, and
+// crystallize counts them for unlinked-page detection — preserving that is
+// behavior-stable). lint uses a DIFFERENT extractor (strips code regions and
+// handles table-escaped `\|`); rename uses length-preserving masking. Neither
+// shares this one.
+export function extractWikilinks(content) {
+  const links = [];
+  for (const m of content.matchAll(/\[\[([^\]|#]+?)(?:[|#][^\]]*?)?\]\]/g)) {
+    links.push(m[1].trim());
+  }
+  return links;
+}

package/scripts/lint.mjs

@@ -17,13 +17,21 @@
  */
 
 import { existsSync, readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
-import { join, relative, extname, basename } from 'path';
+import { join, extname, basename } from 'path';
 import { resolveHypoRoot, expandHome } from './lib/hypo-root.mjs';
 import { SESSION_STATE_NEXT_HEADINGS } from '../hooks/hypo-shared.mjs';
-import { loadHypoIgnore, isIgnored } from './lib/hypo-ignore.mjs';
-import { parseSchemaVocab, checkForbidden, parseSchemaPageDirs } from './lib/schema-vocab.mjs';
+import { loadHypoIgnore, isScanIgnored } from './lib/hypo-ignore.mjs';
+import {
+  parseSchemaVocab,
+  checkForbidden,
+  parseSchemaPageDirs,
+  parseSchemaTypes,
+} from './lib/schema-vocab.mjs';
 import { findDesignHistoryStale } from './lib/design-history-stale.mjs';
 import { FEEDBACK_SCOPE_RE } from './lib/feedback-scope.mjs';
+import { FAILURE_TYPE_ENUM } from './lib/failure-type.mjs';
+import { collectPagesLint, slugForms } from './lib/wikilink.mjs';
+import { parseFrontmatter, SEQUENCE_ENTRY_RE } from './lib/frontmatter.mjs';
 
 // ── arg parsing ──────────────────────────────────────────────────────────────
 
@@ -41,19 +49,45 @@ function parseArgs(argv) {
 
 // ── frontmatter parser ────────────────────────────────────────────────────────
 
-function parseFrontmatter(content) {
-  const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!m) return null;
-  const fm = {};
-  for (const line of m[1].split('\n')) {
+// ── W9: narrow invalid-YAML detector ───────────────────────────────────────────
+// NOT a full YAML parser (zero-dep policy). Catches only specific classes the
+// lenient line-scanner (parseFrontmatter, imported from lib) silently passes but
+// a real YAML parser (js-yaml, what Obsidian uses) rejects. Each class is
+// conservative — it may miss, but must NOT false-positive on valid YAML, so it
+// inspects only top-level (unindented) lines: indented lines may be block-scalar
+// content where ": "/tabs are legal, and reliably telling content from structure
+// needs a real parser. (A leading-tab class was considered and dropped for this
+// reason — it cannot distinguish `relations:\n\t- x` from a tabbed block-scalar
+// body without tracking block context.) Returns an array of reasons.
+function checkYamlInvalid(block) {
+  const reasons = [];
+  const seen = new Set();
+  for (const raw of block.split('\n')) {
+    const line = raw.replace(/\r$/, '');
+    if (!line.trim()) continue;
+    if (/^\s/.test(line) || SEQUENCE_ENTRY_RE.test(line)) continue; // top-level keys only
     const idx = line.indexOf(':');
     if (idx < 0) continue;
-    fm[line.slice(0, idx).trim()] = line
-      .slice(idx + 1)
-      .trim()
-      .replace(/^["']|["']$/g, '');
+    const key = line.slice(0, idx).trim();
+    if (!key) continue;
+    // duplicate top-level key (YAML rejects; line-scanner silently keeps one)
+    if (seen.has(key)) reasons.push(`duplicate key: "${key}"`);
+    else seen.add(key);
+    // colon-space inside an unquoted, non-flow plain scalar. A plain scalar may
+    // not contain ": " — js-yaml hard-errors or silently truncates. Skip quoted
+    // ("/') and flow ([/{) values where ": " is legal, and strip an inline
+    // " #" comment before scanning.
+    let val = line.slice(idx + 1).trim();
+    const c = val[0];
+    if (val && c !== '"' && c !== "'" && c !== '[' && c !== '{') {
+      const hash = val.indexOf(' #');
+      if (hash >= 0) val = val.slice(0, hash);
+      if (/:\s/.test(val)) {
+        reasons.push(`unquoted "${key}" value contains ": " (quote it): "${val.slice(0, 40)}"`);
+      }
+    }
   }
-  return fm;
+  return reasons;
 }
 
 function parseTagsField(rawValue) {
@@ -108,31 +142,14 @@ const TYPE_ENUM_FIELDS = {
     status: ['active', 'superseded', 'archived'],
     tier: ['L1', 'L2'],
     sensitivity: ['public', 'sanitized'],
+    // FEAT-1: optional failure taxonomy. The enum loop guards on `if (fm[field])`,
+    // so an omitted failure_type is never validated (optional, migration-safe).
+    failure_type: FAILURE_TYPE_ENUM,
   },
 };
 
 // ── page collector ────────────────────────────────────────────────────────────
 
-function collectPages(dir, root, pages = [], ignorePatterns = []) {
-  if (!existsSync(dir)) return pages;
-  for (const entry of readdirSync(dir)) {
-    const full = join(dir, entry);
-    if (isIgnored(full, root, ignorePatterns)) continue;
-    const st = statSync(full);
-    if (st.isDirectory()) {
-      // `_`-prefixed dirs (e.g. pages/feedback/_drafts) hold scaffolds / scratch
-      // not yet promoted to content — skip so incomplete frontmatter never errors
-      // (mirrors loadFeedbackPages in feedback-sync.mjs). `_`-prefixed *files*
-      // (e.g. _index.md) are still linted.
-      if (entry.startsWith('_')) continue;
-      collectPages(full, root, pages, ignorePatterns);
-    } else if (extname(entry) === '.md' && !entry.startsWith('.')) {
-      pages.push({ path: full, rel: relative(root, full) });
-    }
-  }
-  return pages;
-}
-
 // ── slug map ─────────────────────────────────────────────────────────────────
 
 // `extraTargets` are link-target-only slugs (root *.md, sources/*) that resolve
@@ -142,13 +159,14 @@ function buildSlugMap(pages, extraTargets = []) {
   const map = new Set();
   for (const { rel } of pages) {
     const noExt = rel.replace(/\.md$/, '').replace(/\\/g, '/');
-    map.add(noExt);
-    map.add(basename(rel, '.md'));
-    // Dir-relative alias: drop the leading scan-dir segment so the vault's
-    // convention link [[learnings/foo]] resolves to pages/learnings/foo.md.
-    // (A page directly under a scan dir has no extra segment to drop.)
-    const slash = noExt.indexOf('/');
-    if (slash !== -1) map.add(noExt.slice(slash + 1));
+    // full slug + bare basename + dir-relative alias (drop the leading scan-dir
+    // segment so the convention link [[learnings/foo]] resolves to
+    // pages/learnings/foo.md). slugForms returns dirRel=null when the slug has no
+    // `/` (a page directly under a scan dir has no extra segment to drop).
+    const { full, bare, dirRel } = slugForms(noExt);
+    map.add(full);
+    map.add(bare);
+    if (dirRel) map.add(dirRel);
   }
   for (const t of extraTargets) map.add(t);
   return map;
@@ -164,13 +182,14 @@ function collectLinkTargets(hypoDir, ignorePatterns = []) {
   if (existsSync(hypoDir)) {
     for (const entry of readdirSync(hypoDir)) {
       const full = join(hypoDir, entry);
-      // root-level *.md FILES only (no recursion), honoring .hypoignore exactly
-      // like collectPages — otherwise an ignored root file (e.g. a secret) would
-      // resolve [[its-slug]] as valid, a false negative.
+      // root-level *.md FILES only (no recursion), honoring .hypoignore plus the
+      // scan-only generated-artifact exclusions (isScanIgnored) like collectPagesLint
+      // — otherwise an ignored root file (e.g. a secret) or a regenerable report
+      // would resolve [[its-slug]] as valid, a false negative.
       if (
         extname(entry) === '.md' &&
         !entry.startsWith('.') &&
-        !isIgnored(full, hypoDir, ignorePatterns) &&
+        !isScanIgnored(full, hypoDir, ignorePatterns) &&
         statSync(full).isFile()
       ) {
         targets.push(entry.replace(/\.md$/, ''));
@@ -179,7 +198,7 @@ function collectLinkTargets(hypoDir, ignorePatterns = []) {
   }
   // sources/*: linkable as the full 'sources/<name>' slug only — deliberately no
   // bare basename, so a stale [[name]] can't silently resolve to a source file.
-  for (const { rel } of collectPages(join(hypoDir, 'sources'), hypoDir, [], ignorePatterns)) {
+  for (const { rel } of collectPagesLint(join(hypoDir, 'sources'), hypoDir, ignorePatterns)) {
     targets.push(rel.replace(/\.md$/, '').replace(/\\/g, '/'));
   }
   return targets;
@@ -258,10 +277,15 @@ const issues = [];
 // STRICT_PROMOTE_IDS (OQ-E1, frozen as a code constant): confirmed content
 // defects only.
 //   W1 no-frontmatter / W2 unknown-type / W4 broken-wikilink → promote.
+//   W9 invalid-YAML → promote (frontmatter a real YAML parser rejects).
 //   W3 missing-updated  → excluded (auto-repaired by --fix).
 //   W8 design-history-stale → excluded (hypo-personal-check handles it; would
 //                             double-gate).
-const STRICT_PROMOTE_IDS = new Set(['W1', 'W2', 'W4']);
+// NOTE: no gate currently passes --strict (npm run lint / CI / release.yml /
+// crystallize / the close-gate all run plain lint), so promotion is
+// forward-looking — these surface as warnings today. IMPR-3's deliverable is
+// "stop silently green-passing invalid YAML"; the W9 warning satisfies that.
+const STRICT_PROMOTE_IDS = new Set(['W1', 'W2', 'W4', 'W9']);
 
 function issue(severity, rel, msg, fullPath = null, id = null) {
   issues.push({ severity, file: rel, message: msg, path: fullPath, id });
@@ -284,7 +308,7 @@ function lintSessionStateHeadings(content, rel) {
   }
 }
 
-function lintPage({ path, rel }, slugMap, tagVocab, pageDirs) {
+function lintPage({ path, rel }, slugMap, tagVocab, pageDirs, validTypes) {
   // Directory whitelist: a content page under pages/<subdir>/ must live in a
   // SCHEMA-defined directory. Catches typo'd dirs (e.g. pages/learning/ vs the
   // canonical pages/learnings/) regardless of frontmatter, since a directory
@@ -318,6 +342,16 @@ function lintPage({ path, rel }, slugMap, tagVocab, pageDirs) {
     return;
   }
 
+  // W9: invalid-YAML frontmatter the lenient line-scanner would otherwise pass
+  // green. Runs on the raw `---` block (the `content.match` above guarantees an
+  // opening fence; an unclosed fence falls through to the W3/parse path below).
+  const fmBlock = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (fmBlock) {
+    for (const reason of checkYamlInvalid(fmBlock[1])) {
+      issue('warn', rel, `Invalid YAML frontmatter: ${reason}`, null, 'W9');
+    }
+  }
+
   const fm = parseFrontmatter(content);
   if (!fm) {
     issue('error', rel, 'Malformed frontmatter (unclosed ---)');
@@ -328,7 +362,7 @@ function lintPage({ path, rel }, slugMap, tagVocab, pageDirs) {
     if (!fm[field]) issue('error', rel, `Missing required frontmatter field: ${field}`);
   }
 
-  if (fm.type && !VALID_TYPES.includes(fm.type)) {
+  if (fm.type && !validTypes.has(fm.type)) {
     issue('warn', rel, `Unknown type: "${fm.type}"`, null, 'W2');
   }
 
@@ -412,13 +446,19 @@ const args = parseArgs(process.argv);
 
 const ignorePatterns = loadHypoIgnore(args.hypoDir);
 const scanDirs = ['pages', 'projects', 'journal'].map((d) => join(args.hypoDir, d));
-const pages = scanDirs.flatMap((d) => collectPages(d, args.hypoDir, [], ignorePatterns));
+const pages = scanDirs.flatMap((d) => collectPagesLint(d, args.hypoDir, ignorePatterns));
 const linkTargets = collectLinkTargets(args.hypoDir, ignorePatterns);
 const slugMap = buildSlugMap(pages, linkTargets);
 const tagVocab = parseSchemaVocab(args.hypoDir);
 const pageDirs = parseSchemaPageDirs(args.hypoDir);
-
-for (const page of pages) lintPage(page, slugMap, tagVocab, pageDirs);
+// Accepted page types = hardcoded core ∪ the vault SCHEMA's taxonomy. Union (not
+// replace) so core types lint specially handles (session-state, source, …) are
+// never lost when a vault's SCHEMA omits or predates them, while a vault-local
+// extension (working-doc / draft / qa-run) is honored without editing lint —
+// mirroring how tags and page dirs are SCHEMA-derived.
+const validTypes = new Set([...VALID_TYPES, ...parseSchemaTypes(args.hypoDir)]);
+
+for (const page of pages) lintPage(page, slugMap, tagVocab, pageDirs, validTypes);
 
 // W8: design-history.md stale relative to session-log.md. Emitted once per
 // project (not per page) — runs outside the page loop. POSIX-separated path

package/scripts/query.mjs

@@ -19,7 +19,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { join, relative, extname } from 'path';
 import { resolveHypoRoot, expandHome } from './lib/hypo-root.mjs';
-import { loadHypoIgnore, isIgnored } from './lib/hypo-ignore.mjs';
+import { loadHypoIgnore, isScanIgnored } from './lib/hypo-ignore.mjs';
 
 // ── arg parsing ──────────────────────────────────────────────────────────────
 
@@ -42,7 +42,7 @@ function collectMdFiles(dir, root, acc = [], ignorePatterns = []) {
   for (const entry of readdirSync(dir)) {
     if (entry.startsWith('.')) continue;
     const full = join(dir, entry);
-    if (isIgnored(full, root, ignorePatterns)) continue;
+    if (isScanIgnored(full, root, ignorePatterns)) continue;
     const st = statSync(full);
     if (st.isDirectory()) collectMdFiles(full, root, acc, ignorePatterns);
     else if (extname(entry) === '.md') acc.push({ path: full, rel: relative(root, full) });

package/scripts/rename.mjs

@@ -47,9 +47,10 @@ import {
   lstatSync,
   realpathSync,
 } from 'fs';
-import { join, relative, extname, basename, dirname, normalize, isAbsolute, sep } from 'path';
+import { join, basename, dirname, normalize, isAbsolute, sep } from 'path';
 import { resolveHypoRoot, expandHome } from './lib/hypo-root.mjs';
-import { loadHypoIgnore, isIgnored } from './lib/hypo-ignore.mjs';
+import { loadHypoIgnore } from './lib/hypo-ignore.mjs';
+import { collectPagesRename, slugForms } from './lib/wikilink.mjs';
 
 // ── arg parsing ───────────────────────────────────────────────────────────────
 
@@ -66,28 +67,6 @@ function parseArgs(argv) {
   return args;
 }
 
-// ── page collection (mirrors graph.mjs / crystallize.mjs collectPages) ──────────
-
-function collectPages(dir, root, pages = [], ignorePatterns = []) {
-  if (!existsSync(dir)) return pages;
-  for (const entry of readdirSync(dir)) {
-    const full = join(dir, entry);
-    if (isIgnored(full, root, ignorePatterns)) continue;
-    // lstat (never follow): a symlinked dir or file is skipped entirely so the
-    // whole-vault scan can never traverse out of the vault via a symlink.
-    const st = lstatSync(full);
-    if (st.isSymbolicLink()) {
-      continue;
-    } else if (st.isDirectory()) {
-      collectPages(full, root, pages, ignorePatterns);
-    } else if (extname(entry) === '.md' && !entry.startsWith('.')) {
-      const rel = relative(root, full).replace(/\\/g, '/');
-      pages.push({ path: full, rel, slug: rel.replace(/\.md$/, ''), bare: basename(full, '.md') });
-    }
-  }
-  return pages;
-}
-
 // ── preservation class of a link-source path ───────────────────────────────────
 // Two distinct reasons a file is normally skipped as a link SOURCE, kept separate
 // because directory mode treats them differently (codex design BLOCKER):
@@ -123,10 +102,7 @@ function isPreservedSource(rel) {
 // needs to KNOW when a form is shared, so it maps each form → the set of page
 // rels that expose it. precedence forms per page: full noExt slug, bare
 // basename, dir-relative (drop the leading scan-dir segment).
-function dirRelForm(slug) {
-  const slash = slug.indexOf('/');
-  return slash === -1 ? null : slug.slice(slash + 1);
-}
+const dirRelForm = (slug) => slugForms(slug).dirRel;
 
 function buildFormIndex(pages) {
   const index = new Map(); // form → Set<rel>
@@ -473,7 +449,7 @@ function runDirectory(args, fromDirRel, ignorePatterns) {
     fail(args, `--from subtree contains a symlink — refusing (move could escape the vault)`);
   }
 
-  const pages = collectPages(args.hypoDir, args.hypoDir, [], ignorePatterns);
+  const pages = collectPagesRename(args.hypoDir, args.hypoDir, ignorePatterns);
   const formIndex = buildFormIndex(pages);
 
   // The moving pages: every collected page whose rel is under the from-directory.
@@ -676,7 +652,7 @@ function run(args) {
     return runDirectory(args, fromNorm, ignorePatterns);
   }
 
-  const pages = collectPages(args.hypoDir, args.hypoDir, [], ignorePatterns);
+  const pages = collectPagesRename(args.hypoDir, args.hypoDir, ignorePatterns);
   const formIndex = buildFormIndex(pages);
 
   const fromPage = resolveArgToPage(args.from, pages, formIndex);