@gcunharodrigues/wrxn 0.1.0

package/payload/.claude/hooks/session-history.cjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+'use strict';
+
+// WRXN session-history hook — the turn-trail recorder (wrxn-kernel-10).
+// UserPromptSubmit. Appends one `<iso>\t<first-line>` record per turn to the session's trail
+// at .wrxn/history/<sid>.trail. SessionEnd reads this trail to build the durable session page.
+//
+// Self-contained: ships into installs, MUST NOT import the kernel lib (node stdlib only).
+// Pass-through recorder: it NEVER injects context and NEVER blocks — always emits {} (exit 0).
+// Fail-open: any fault still emits {}.
+//
+// Contract: UserPromptSubmit event JSON on stdin → {} on stdout (exit 0). Side effect: trail append.
+
+const fs = require('fs');
+const path = require('path');
+
+function emitEmpty() {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+
+function findInstallRoot(startDir) {
+  let dir = startDir || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  for (let i = 0; i < 12; i++) {
+    if (fs.existsSync(path.join(dir, 'wrxn.install.json'))) return dir;
+    const up = path.dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return null;
+}
+
+function nowISO() {
+  return process.env.WRXN_NOW || new Date().toISOString();
+}
+
+function safeId(sid) {
+  return String(sid || 'session')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 48) || 'session';
+}
+
+function main() {
+  let event = {};
+  try {
+    const stdin = fs.readFileSync(0, 'utf8');
+    if (stdin.trim()) event = JSON.parse(stdin);
+  } catch {
+    emitEmpty();
+  }
+
+  const root = findInstallRoot();
+  if (!root) emitEmpty();
+
+  const sid = safeId(event.session_id);
+  const prompt = String(event.prompt || '').split('\n')[0].slice(0, 200).replace(/\t/g, ' ').trim();
+  if (prompt) {
+    try {
+      const dir = path.join(root, '.wrxn', 'history');
+      fs.mkdirSync(dir, { recursive: true });
+      fs.appendFileSync(path.join(dir, `${sid}.trail`), `${nowISO()}\t${prompt}\n`);
+    } catch {
+      /* trail append is best-effort — never block the prompt */
+    }
+  }
+
+  emitEmpty();
+}
+
+try {
+  main();
+} catch {
+  emitEmpty();
+}

package/payload/.claude/hooks/session-start.cjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+'use strict';
+
+// WRXN session-start hook — the orientation surface (wrxn-kernel-10).
+// SessionStart. Injects identity + resume as additionalContext so every new session opens
+// oriented. The resume gives the DELIBERATE handoff baton precedence over the automatic
+// episodic record: a baton at .wrxn/continuity/latest.md (single writer = the handoff skill)
+// wins; otherwise the most-recent dated session page is surfaced as the resume pointer.
+//
+// Self-contained: ships into installs, MUST NOT import the kernel lib (node stdlib only).
+// Fail-open: any fault emits {} (no orientation) — the hook NEVER blocks a session opening.
+//
+// Contract: SessionStart event JSON on stdin → envelope JSON on stdout (exit 0).
+//   inject → { "hookSpecificOutput": { "hookEventName": "SessionStart", "additionalContext": "…" } }
+//   no-op  → {}
+
+const fs = require('fs');
+const path = require('path');
+
+function emit(envelope) {
+  process.stdout.write(JSON.stringify(envelope));
+  process.exit(0);
+}
+
+// Walk up from CLAUDE_PROJECT_DIR (or cwd) to the install root carrying wrxn.install.json.
+function findInstallRoot(startDir) {
+  let dir = startDir || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  for (let i = 0; i < 12; i++) {
+    if (fs.existsSync(path.join(dir, 'wrxn.install.json'))) return dir;
+    const up = path.dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return null;
+}
+
+function readFileOr(p, fallback) {
+  try {
+    return fs.readFileSync(p, 'utf8');
+  } catch {
+    return fallback;
+  }
+}
+
+function identityLine(root) {
+  const name = path.basename(root);
+  let version = '';
+  let profile = 'project';
+  try {
+    const receipt = JSON.parse(fs.readFileSync(path.join(root, 'wrxn.install.json'), 'utf8'));
+    version = receipt.kernelVersion ? ` v${receipt.kernelVersion}` : '';
+    profile = receipt.profile || 'project';
+  } catch {
+    /* receipt unreadable → name-only identity */
+  }
+  return `Install: ${name}${version} (${profile} profile)`;
+}
+
+// The deliberate handoff baton — the intent-carrying continuity slot. Single writer: the
+// handoff skill. Read-only here; its presence takes precedence over the episodic record.
+function readBaton(root) {
+  return readFileOr(path.join(root, '.wrxn', 'continuity', 'latest.md'), null);
+}
+
+// The automatic episodic record: the most-recent dated session page (sessions tier).
+function latestSessionPage(root) {
+  const dir = path.join(root, '.wrxn', 'wiki', 'sessions');
+  let names;
+  try {
+    names = fs.readdirSync(dir).filter((n) => n.endsWith('.md'));
+  } catch {
+    return null;
+  }
+  if (names.length === 0) return null;
+  names.sort(); // dated `YYYY-MM-DD-…` slugs sort chronologically
+  return names[names.length - 1];
+}
+
+function main() {
+  let consumed = '';
+  try {
+    consumed = fs.readFileSync(0, 'utf8');
+  } catch {
+    /* no stdin → still try to orient */
+  }
+  void consumed; // SessionStart carries no field we need beyond the install context
+
+  const root = findInstallRoot();
+  if (!root) emit({});
+
+  const parts = [identityLine(root)];
+
+  const baton = readBaton(root);
+  if (baton && baton.trim()) {
+    parts.push('', 'Resume — deliberate handoff baton (.wrxn/continuity/latest.md):', baton.trim());
+  } else {
+    const page = latestSessionPage(root);
+    if (page) {
+      parts.push('', `Resume — last session: .wrxn/wiki/sessions/${page}`);
+    } else {
+      parts.push('', 'Resume — fresh install, no prior session recorded.');
+    }
+  }
+
+  emit({
+    hookSpecificOutput: {
+      hookEventName: 'SessionStart',
+      additionalContext: ['<wrxn-orientation>', ...parts, '</wrxn-orientation>'].join('\n'),
+    },
+  });
+}
+
+try {
+  main();
+} catch {
+  emit({}); // fail-open: never block a session opening
+}

package/payload/.claude/hooks/synapse-engine.cjs

@@ -0,0 +1,351 @@
+#!/usr/bin/env node
+'use strict';
+
+// WRXN SYNAPSE engine — the per-prompt context-injection core (the layered port).
+// UserPromptSubmit. Assembles the active domains into a <synapse-rules> block and injects it
+// as additionalContext so every prompt carries the constitution + operational rules.
+//
+// Self-contained: this hook ships into installs and CANNOT import the kernel lib/. It reads the
+// install's own .synapse/ domains + .claude/constitution.md + the manifest. Silent / fail-open:
+// any fault emits {} (no injection) — the engine NEVER blocks a prompt.
+//
+// Contract: UserPromptSubmit event JSON on stdin → envelope JSON on stdout (exit 0).
+//   inject → { "hookSpecificOutput": { "hookEventName": "UserPromptSubmit", "additionalContext": "<synapse-rules>…" } }
+//   no-op  → {}
+//
+// Layers (faithful to the WRXN-OS SYNAPSE model, reimplemented standalone):
+//   L0 Constitution — always, sourced from .claude/constitution.md, NEVER trimmed.
+//   L1 Global / Pipeline — always-on domains (.synapse/<domain>, KEY=VALUE rules).
+//   L6 Keyword-recall — domains that fire only when a trigger word appears in the prompt (06b).
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function emit(envelope) {
+  process.stdout.write(JSON.stringify(envelope));
+  process.exit(0);
+}
+
+// Walk up from CLAUDE_PROJECT_DIR (or cwd) to the install root carrying wrxn.install.json.
+// Same resolution as the managed-guard hook — the receipt marks an install root.
+function findInstallRoot(startDir) {
+  let dir = startDir || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  for (let i = 0; i < 8; i++) {
+    if (fs.existsSync(path.join(dir, 'wrxn.install.json'))) return dir;
+    const up = path.dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return null;
+}
+
+function readFileOr(p, fallback) {
+  try {
+    return fs.readFileSync(p, 'utf8');
+  } catch {
+    return fallback;
+  }
+}
+
+// ── parsing ────────────────────────────────────────────────────────────────────
+
+// Parse the flat KEY=VALUE .synapse/manifest into a domain map:
+//   { GLOBAL: { state, alwaysOn, recall:[...] }, ROUTING: {...}, ... }
+// Per-domain keys: <DOMAIN>_STATE, <DOMAIN>_ALWAYS_ON, <DOMAIN>_RECALL. Non-domain keys
+// (RULES_BUDGET_TOKENS, HANDOFF_PCT) are left for the caller to read raw.
+function parseSynapseManifest(text) {
+  const domains = {};
+  const ensure = (name) => (domains[name] || (domains[name] = { state: '', alwaysOn: false, recall: [] }));
+  for (const line of String(text || '').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eq = trimmed.indexOf('=');
+    if (eq < 0) continue;
+    const key = trimmed.slice(0, eq);
+    const val = trimmed.slice(eq + 1);
+    let m;
+    if ((m = key.match(/^(.+)_STATE$/))) ensure(m[1]).state = val;
+    else if ((m = key.match(/^(.+)_ALWAYS_ON$/))) ensure(m[1]).alwaysOn = val === 'true';
+    else if ((m = key.match(/^(.+)_RECALL$/))) ensure(m[1]).recall = val.split(',').map((s) => s.trim()).filter(Boolean);
+  }
+  return domains;
+}
+
+// Read a single scalar key from the flat manifest (e.g. RULES_BUDGET_TOKENS), or '' if absent.
+function manifestValue(text, key) {
+  for (const line of String(text || '').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eq = trimmed.indexOf('=');
+    if (eq < 0) continue;
+    if (trimmed.slice(0, eq) === key) return trimmed.slice(eq + 1);
+  }
+  return '';
+}
+
+// Extract <DOMAIN>_RULE_N values from a domain file, ordered by N ascending.
+function domainRules(domainUpper, text) {
+  const re = new RegExp(`^${domainUpper}_RULE_(\\d+)=(.*)$`);
+  const found = [];
+  for (const line of String(text || '').split('\n')) {
+    const m = line.match(re);
+    if (m) found.push({ n: Number(m[1]), v: m[2] });
+  }
+  found.sort((a, b) => a.n - b.n);
+  return found.map((x) => x.v);
+}
+
+// ── rendering ────────────────────────────────────────────────────────────────────
+
+// Render constitution.md into the always-kept L0 section. Keep article headings + their bullets,
+// drop the prose preamble so the injection stays compact. Returns the section body (no header).
+function renderConstitution(md) {
+  const lines = String(md || '').split('\n');
+  const out = [];
+  let inArticle = false;
+  for (const line of lines) {
+    if (/^##\s+/.test(line)) {
+      inArticle = true;
+      out.push(line.replace(/^##\s+/, '').trim());
+      continue;
+    }
+    if (!inArticle) continue;
+    if (/^#\s/.test(line)) { inArticle = false; continue; }
+    const t = line.trim();
+    if (!t) continue;
+    if (t.startsWith('-')) {
+      out.push('  ' + t.replace(/^-\s*/, ''));
+    } else if (out.length) {
+      // A wrapped bullet's continuation line — fold it into the preceding bullet rather than drop it.
+      out[out.length - 1] += ' ' + t;
+    }
+  }
+  return out.join('\n');
+}
+
+// A rules domain section: a `[HEADER]` line followed by numbered rules.
+function renderRulesSection(header, rules) {
+  const body = rules.map((r, i) => `  ${i + 1}. ${r}`).join('\n');
+  return `[${header}]\n${body}`;
+}
+
+function estimateTokens(s) {
+  return Math.ceil(String(s || '').length / 4);
+}
+
+// ── budget governor ────────────────────────────────────────────────────────────
+
+// Bound the trimmable sections by a token budget. The constitution is OUTSIDE the budget and
+// always kept. Trimmable sections are dropped lowest-priority-LAST first (the array is in priority
+// order; we drop from the end) until the kept set fits. Returns { kept:[...], trimmed:[names] }.
+function applyBudget(trimmable, budget) {
+  const kept = trimmable.slice();
+  const trimmed = [];
+  const total = () => kept.reduce((sum, s) => sum + estimateTokens(s.text), 0);
+  while (kept.length && total() > budget) {
+    const dropped = kept.pop();
+    trimmed.unshift(dropped.name);
+  }
+  return { kept, trimmed };
+}
+
+// ── token-base + forced handoff (06c) ────────────────────────────────────────────
+//
+// The handoff math must run on REAL token usage, not an assumed 200k (the original bug fired
+// at ~37% of a 1M window). Both signals are portable into any install:
+//   resident → the last assistant line's usage in the transcript (transcript_path is in the payload).
+//   window   → ~/.claude.json projects[cwd].lastModelUsage KEYS carry the tagged id; [1m] ⇒ 1M else 200k.
+// See memory `synapse-model-window-from-claude-json`.
+
+// Resident tokens = the last assistant turn's input + cache_read + cache_creation (output EXCLUDED —
+// it is not resident in the next prompt's context). Returns a number, or null when unreadable.
+function readResidentTokens(transcriptPath) {
+  try {
+    const lines = fs.readFileSync(transcriptPath, 'utf8').split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      let obj;
+      try { obj = JSON.parse(line); } catch { continue; }
+      const msg = obj && obj.message;
+      if (!msg || msg.role !== 'assistant' || !msg.usage) continue;
+      const u = msg.usage;
+      return (u.input_tokens || 0) + (u.cache_read_input_tokens || 0) + (u.cache_creation_input_tokens || 0);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// Model context window, resolved by an explicit precedence (issue 29). On [1m] sessions
+// lastModelUsage is often EMPTY and the transcript model id lacks the [1m] tag — there is no
+// reliable auto-signal — so the window must be settable explicitly rather than guessed:
+//   1. env WRXN_CONTEXT_WINDOW — a positive finite number wins unconditionally.
+//   2. manifest CONTEXT_WINDOW — a positive finite value (when manifestText is supplied).
+//   3. ~/.claude.json lastModelUsage KEYS — a [1m] tag ⇒ 1,000,000 (auto-detect, when present).
+//   4. fallback 200,000.
+// homeDir/manifestText overrides keep it testable.
+function modelWindow(cwd, homeDir, manifestText) {
+  // 1. explicit env override.
+  const envWin = Number(process.env.WRXN_CONTEXT_WINDOW);
+  if (Number.isFinite(envWin) && envWin > 0) return envWin;
+
+  // 2. manifest CONTEXT_WINDOW (the engine already reads scalar manifest values).
+  if (manifestText != null) {
+    const manWin = Number(manifestValue(manifestText, 'CONTEXT_WINDOW'));
+    if (Number.isFinite(manWin) && manWin > 0) return manWin;
+  }
+
+  // 3. lastModelUsage [1m] auto-detect.
+  try {
+    const home = homeDir || process.env.HOME || os.homedir();
+    const cfg = JSON.parse(fs.readFileSync(path.join(home, '.claude.json'), 'utf8'));
+    const proj = (cfg.projects && cfg.projects[cwd]) || {};
+    const keys = Object.keys(proj.lastModelUsage || {});
+    if (keys.some((k) => /\[1m\]/i.test(k))) return 1000000;
+  } catch {
+    // fall through to the default.
+  }
+
+  // 4. fallback.
+  return 200000;
+}
+
+// Handoff threshold (fraction of the window): env WRXN_HANDOFF_PCT > manifest HANDOFF_PCT > 0.40.
+function resolveHandoffPct(manifestText) {
+  const env = Number(process.env.WRXN_HANDOFF_PCT);
+  if (Number.isFinite(env) && env > 0) return env;
+  const m = Number(manifestValue(manifestText, 'HANDOFF_PCT'));
+  return Number.isFinite(m) && m > 0 ? m : 0.40;
+}
+
+// The NON-BLOCKING forced-handoff directive (never refuses work — orders the agent to wrap up cleanly).
+function handoffDirective(consumed, pct) {
+  const now = Math.round(consumed * 100);
+  const thresh = Math.round(pct * 100);
+  return [
+    '[HANDOFF REQUIRED]',
+    `  Context is at ~${now}% of the model window (>= the ${thresh}% handoff threshold). NON-BLOCKING — do NOT stop work:`,
+    '  1. Finish the current request.',
+    '  2. Run the handoff skill to write the baton (a compact handoff document).',
+    '  3. Tell the operator to /clear and open a fresh session, where the baton injects on resume.',
+  ].join('\n');
+}
+
+// ── assembly ────────────────────────────────────────────────────────────────────
+
+// Build the active section list for a prompt. Returns ordered sections:
+//   [{ name, header, text, always }]  — `always` marks the never-trimmed constitution.
+function buildSections(root, prompt) {
+  const manifestText = readFileOr(path.join(root, '.synapse', 'manifest'), '');
+  const domains = parseSynapseManifest(manifestText);
+  const promptLower = String(prompt || '').toLowerCase();
+  const sections = [];
+
+  // L0 — Constitution (always; from constitution.md). Skip silently if the file/domain is absent.
+  if (domains.CONSTITUTION && domains.CONSTITUTION.state === 'active') {
+    const body = renderConstitution(readFileOr(path.join(root, '.claude', 'constitution.md'), ''));
+    if (body.trim()) {
+      sections.push({ name: 'CONSTITUTION', header: 'CONSTITUTION', text: `[CONSTITUTION] (NON-NEGOTIABLE)\n${body}`, always: true });
+    }
+  }
+
+  // L1/L6 — every other active domain, in manifest order. always-on loads unconditionally;
+  // a recall domain loads only when one of its trigger words appears in the prompt (06b).
+  for (const [name, d] of Object.entries(domains)) {
+    if (name === 'CONSTITUTION' || d.state !== 'active') continue;
+    const fires = d.alwaysOn || (d.recall.length > 0 && d.recall.some((w) => promptLower.includes(w.toLowerCase())));
+    if (!fires) continue;
+    const domainText = readFileOr(path.join(root, '.synapse', name.toLowerCase()), '');
+    const rules = domainRules(name, domainText);
+    if (!rules.length) continue;
+    const header = d.alwaysOn ? name : `RECALL: ${name.toLowerCase()}`;
+    sections.push({ name, header, text: renderRulesSection(header, rules), always: false });
+  }
+
+  return { sections, manifestText };
+}
+
+function resolveBudget(manifestText) {
+  const env = Number(process.env.WRXN_RULES_BUDGET);
+  if (Number.isFinite(env) && env > 0) return env;
+  const m = Number(manifestValue(manifestText, 'RULES_BUDGET_TOKENS'));
+  return Number.isFinite(m) && m > 0 ? m : 600;
+}
+
+// Compose the full additionalContext for an UserPromptSubmit event at an install root, or '' to no-op.
+function compose(root, event) {
+  const ev = event || {};
+  const { sections, manifestText } = buildSections(root, ev.prompt);
+  if (!sections.length) return '';
+
+  const always = sections.filter((s) => s.always);
+  const trimmable = sections.filter((s) => !s.always);
+  const { kept, trimmed } = applyBudget(trimmable, resolveBudget(manifestText));
+
+  const out = [...always.map((s) => s.text), ...kept.map((s) => s.text)];
+  if (trimmed.length) {
+    out.push(`[SYNAPSE-RULES-TRIM] ${trimmed.join(', ')} dropped over the ${resolveBudget(manifestText)}-token rules budget`);
+  }
+
+  // 06c — forced handoff at >= threshold of REAL consumed context. Always-kept (outside the budget):
+  // a handoff directive must never be trimmed. Silent when the token base is unreadable.
+  if (ev.transcript_path) {
+    const resident = readResidentTokens(ev.transcript_path);
+    if (resident != null) {
+      const window = modelWindow(ev.cwd || root, process.env.HOME || os.homedir(), manifestText);
+      const consumed = resident / window;
+      const pct = resolveHandoffPct(manifestText);
+      if (consumed >= pct) out.push(handoffDirective(consumed, pct));
+    }
+  }
+
+  return `<synapse-rules>\n\n${out.join('\n\n')}\n\n</synapse-rules>`;
+}
+
+// ── entrypoint ────────────────────────────────────────────────────────────────────
+
+function main() {
+  let event;
+  try {
+    event = JSON.parse(fs.readFileSync(0, 'utf8') || '{}');
+  } catch {
+    return emit({}); // unparseable → fail open (no injection)
+  }
+
+  const root = findInstallRoot(event.cwd);
+  if (!root) return emit({}); // not inside a wrxn install → nothing to inject
+
+  let additionalContext = '';
+  try {
+    additionalContext = compose(root, event);
+  } catch {
+    return emit({}); // any assembly fault → fail open
+  }
+  if (!additionalContext) return emit({});
+
+  return emit({
+    hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext },
+  });
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  parseSynapseManifest,
+  manifestValue,
+  domainRules,
+  renderConstitution,
+  renderRulesSection,
+  estimateTokens,
+  applyBudget,
+  buildSections,
+  compose,
+  findInstallRoot,
+  readResidentTokens,
+  modelWindow,
+  resolveHandoffPct,
+  handoffDirective,
+};

package/payload/.claude/hooks/wiki-lint.cjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+'use strict';
+
+// WRXN wiki-lint hook — session-close wiki-integrity flag (wrxn-kernel-11).
+// Stop. At session close it sweeps the wiki tiers for MALFORMED pages — a page is malformed if it
+// lacks a well-formed frontmatter block or is missing a required key (name / description / tier).
+// When any malformed page exists it injects a <wiki-lint> flag naming them; otherwise silent.
+// REPORT-ONLY: it never edits or deletes a page.
+//
+// Self-contained: ships into installs, MUST NOT import the kernel lib (node stdlib only).
+// Fail-open: any fault emits {} — session close must NEVER hang or throw.
+//
+// Contract: Stop event JSON on stdin → envelope JSON on stdout (exit 0).
+
+const fs = require('fs');
+const path = require('path');
+
+const TIERS = ['concepts', 'decisions', 'gotchas', 'sessions'];
+const REQUIRED_KEYS = ['name', 'description', 'tier'];
+const MAX_FLAGGED = 20;
+
+function emit(envelope) {
+  process.stdout.write(JSON.stringify(envelope));
+  process.exit(0);
+}
+
+function findInstallRoot(startDir) {
+  let dir = startDir || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  for (let i = 0; i < 12; i++) {
+    if (fs.existsSync(path.join(dir, 'wrxn.install.json'))) return dir;
+    const up = path.dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return null;
+}
+
+// Return the reason a page is malformed, or null when it is well-formed.
+function lintPage(text) {
+  const src = String(text || '');
+  if (!src.startsWith('---')) return 'no frontmatter';
+  const end = src.indexOf('\n---', 3);
+  if (end < 0) return 'unterminated frontmatter';
+  const fm = src.slice(3, end);
+  const missing = REQUIRED_KEYS.filter((k) => !new RegExp(`^${k}\\s*:`, 'm').test(fm));
+  if (missing.length) return `missing ${missing.join('/')}`;
+  return null;
+}
+
+function sweep(root) {
+  const flagged = [];
+  for (const tier of TIERS) {
+    const dir = path.join(root, '.wrxn', 'wiki', tier);
+    let names;
+    try {
+      names = fs.readdirSync(dir).filter((n) => n.endsWith('.md'));
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      let text;
+      try {
+        text = fs.readFileSync(path.join(dir, name), 'utf8');
+      } catch {
+        continue;
+      }
+      const reason = lintPage(text);
+      if (reason) {
+        flagged.push(`${tier}/${name} — ${reason}`);
+        if (flagged.length >= MAX_FLAGGED) return flagged;
+      }
+    }
+  }
+  return flagged;
+}
+
+function main() {
+  try {
+    fs.readFileSync(0, 'utf8'); // drain stdin (Stop payload unused beyond presence)
+  } catch {
+    /* no stdin → still sweep */
+  }
+
+  const root = findInstallRoot();
+  if (!root) emit({});
+
+  const flagged = sweep(root);
+  if (!flagged.length) emit({}); // clean wiki → silent
+
+  const ctx = [
+    '<wiki-lint>',
+    `${flagged.length} malformed wiki page(s) — fix the frontmatter (name / description / tier):`,
+    ...flagged.map((f) => `- ${f}`),
+    '</wiki-lint>',
+  ].join('\n');
+
+  emit({ hookSpecificOutput: { hookEventName: 'Stop', additionalContext: ctx } });
+}
+
+try {
+  main();
+} catch {
+  emit({});
+}