@mcptoolshop/loadout-os 0.0.0 → 1.0.0

package/dist/loadout-os.js

@@ -0,0 +1,3759 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync as readFileSync12 } from "node:fs";
+import { dirname as dirname8, join as join9, resolve as resolve11 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir as homedir5 } from "node:os";
+
+// src/console.ts
+var BOLD = "\x1B[1m";
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var CYAN = "\x1B[36m";
+var YELLOW = "\x1B[33m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+function log(msg = "") {
+  console.log(msg);
+}
+function ok(msg) {
+  log(`  ${GREEN}\u2713${RESET} ${msg}`);
+}
+function warn(msg) {
+  log(`  ${YELLOW}!${RESET} ${msg}`);
+}
+function info(msg) {
+  log(`  ${CYAN}i${RESET} ${msg}`);
+}
+var CliError = class extends Error {
+  code;
+  hint;
+  exitCode;
+  constructor(code, message, hint, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.hint = hint;
+    this.exitCode = exitCode;
+  }
+};
+function fail(code, message, hint, exitCode = 1) {
+  throw new CliError(code, message, hint, exitCode);
+}
+function hasFlag(args, flag) {
+  return args.includes(`--${flag}`);
+}
+function flagValue(args, flag) {
+  const eqPrefix = `--${flag}=`;
+  for (const a of args) {
+    if (a.startsWith(eqPrefix)) return a.slice(eqPrefix.length);
+  }
+  const idx = args.indexOf(`--${flag}`);
+  if (idx === -1) return void 0;
+  const next = args[idx + 1];
+  if (next === void 0 || next.startsWith("--")) {
+    fail(
+      "MISSING_FLAG_VALUE",
+      `--${flag} was given without a value${next ? ` (the next token "${next}" is a flag, not a value)` : ""}.`,
+      `Provide a value, e.g. '--${flag} <path>' or '--${flag}=<path>'.`
+    );
+  }
+  return next;
+}
+function positionalArgs(args) {
+  return args.filter((a) => !a.startsWith("--"));
+}
+
+// src/commands.ts
+import {
+  readFileSync as readFileSync9,
+  writeFileSync as writeFileSync2,
+  mkdirSync as mkdirSync2,
+  existsSync as existsSync8,
+  statSync as statSync2,
+  copyFileSync,
+  rmSync,
+  mkdtempSync
+} from "node:fs";
+import { resolve as resolve7, dirname as dirname5, join as join5, relative as relative2 } from "node:path";
+import { tmpdir } from "node:os";
+import { createInterface } from "node:readline";
+
+// ../kernel/dist/types.js
+var DEFAULT_TRIGGERS = {
+  task: true,
+  plan: true,
+  edit: false
+};
+
+// ../kernel/dist/frontmatter.js
+var VALID_PRIORITIES = /* @__PURE__ */ new Set(["core", "domain", "manual"]);
+function parseFrontmatter(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") {
+    return { frontmatter: null, body: content };
+  }
+  let closeIndex = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === "---") {
+      closeIndex = i;
+      break;
+    }
+  }
+  if (closeIndex === -1) {
+    return { frontmatter: null, body: content };
+  }
+  const fmLines = lines.slice(1, closeIndex);
+  const body = lines.slice(closeIndex + 1).join("\n");
+  const data = {};
+  let currentKey = "";
+  let currentArray = null;
+  let currentObject = null;
+  for (let i = 0; i < fmLines.length; i++) {
+    const line = fmLines[i];
+    const trimmed = line.trim();
+    if (trimmed === "")
+      continue;
+    if (currentArray !== null && trimmed.startsWith("- ")) {
+      currentArray.push(trimmed.slice(2).trim());
+      continue;
+    }
+    if (currentObject !== null && line.startsWith("  ")) {
+      const colonIdx2 = trimmed.indexOf(":");
+      if (colonIdx2 !== -1) {
+        const key2 = trimmed.slice(0, colonIdx2).trim();
+        const val = trimmed.slice(colonIdx2 + 1).trim();
+        currentObject[key2] = val === "true";
+        continue;
+      }
+    }
+    if (currentArray !== null) {
+      data[currentKey] = currentArray;
+      currentArray = null;
+    }
+    if (currentObject !== null) {
+      data[currentKey] = currentObject;
+      currentObject = null;
+    }
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1)
+      continue;
+    const key = trimmed.slice(0, colonIdx).trim();
+    const rawVal = trimmed.slice(colonIdx + 1).trim();
+    currentKey = key;
+    if (rawVal === "") {
+      if (i + 1 < fmLines.length) {
+        const nextTrimmed = fmLines[i + 1].trim();
+        if (nextTrimmed.startsWith("- ")) {
+          currentArray = [];
+        } else if (fmLines[i + 1].startsWith("  ")) {
+          currentObject = {};
+        }
+      }
+      continue;
+    }
+    if (rawVal.startsWith("[") && rawVal.endsWith("]")) {
+      const inner = rawVal.slice(1, -1);
+      data[key] = inner.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+      continue;
+    }
+    if (rawVal === "true") {
+      data[key] = true;
+      continue;
+    }
+    if (rawVal === "false") {
+      data[key] = false;
+      continue;
+    }
+    data[key] = rawVal.startsWith('"') && rawVal.endsWith('"') ? rawVal.slice(1, -1) : rawVal;
+  }
+  if (currentArray !== null)
+    data[currentKey] = currentArray;
+  if (currentObject !== null)
+    data[currentKey] = currentObject;
+  if (typeof data.id !== "string" || !data.id) {
+    return { frontmatter: null, body: content };
+  }
+  const fm = {
+    id: data.id,
+    keywords: Array.isArray(data.keywords) ? data.keywords : [],
+    patterns: Array.isArray(data.patterns) ? data.patterns : [],
+    priority: VALID_PRIORITIES.has(data.priority) ? data.priority : "domain",
+    triggers: parseTriggers(data.triggers)
+  };
+  return { frontmatter: fm, body };
+}
+function parseTriggers(raw) {
+  if (!raw || typeof raw !== "object")
+    return { ...DEFAULT_TRIGGERS };
+  const obj = raw;
+  return {
+    task: typeof obj.task === "boolean" ? obj.task : DEFAULT_TRIGGERS.task,
+    plan: typeof obj.plan === "boolean" ? obj.plan : DEFAULT_TRIGGERS.plan,
+    edit: typeof obj.edit === "boolean" ? obj.edit : DEFAULT_TRIGGERS.edit
+  };
+}
+function serializeFrontmatter(fm) {
+  const lines = ["---"];
+  lines.push(`id: ${fm.id}`);
+  lines.push(`keywords: [${fm.keywords.join(", ")}]`);
+  if (fm.patterns.length > 0) {
+    lines.push(`patterns: [${fm.patterns.join(", ")}]`);
+  }
+  lines.push(`priority: ${fm.priority}`);
+  lines.push("triggers:");
+  lines.push(`  task: ${fm.triggers.task}`);
+  lines.push(`  plan: ${fm.triggers.plan}`);
+  lines.push(`  edit: ${fm.triggers.edit}`);
+  lines.push("---");
+  return lines.join("\n");
+}
+
+// ../kernel/dist/tokens.js
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
+// ../kernel/dist/validate.js
+var KEBAB_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var VALID_PRIORITIES2 = /* @__PURE__ */ new Set(["core", "domain", "manual"]);
+function validateIndex(index) {
+  const issues = [];
+  if (!index.version) {
+    issues.push({
+      severity: "error",
+      code: "MISSING_VERSION",
+      message: "Index is missing a version field"
+    });
+  }
+  if (!index.generated) {
+    issues.push({
+      severity: "warning",
+      code: "MISSING_GENERATED",
+      message: "Index is missing a generated timestamp"
+    });
+  }
+  if (!Array.isArray(index.entries)) {
+    issues.push({
+      severity: "error",
+      code: "INVALID_ENTRIES",
+      message: "Index entries must be an array"
+    });
+    return issues;
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const entry of index.entries) {
+    if (!entry.id) {
+      issues.push({
+        severity: "error",
+        code: "MISSING_ID",
+        message: "Entry is missing an id field",
+        hint: "Every entry needs a unique kebab-case id"
+      });
+      continue;
+    }
+    if (!KEBAB_RE.test(entry.id)) {
+      issues.push({
+        severity: "warning",
+        code: "BAD_ID_FORMAT",
+        message: `ID "${entry.id}" is not kebab-case`,
+        entryId: entry.id
+      });
+    }
+    if (ids.has(entry.id)) {
+      issues.push({
+        severity: "error",
+        code: "DUPLICATE_ID",
+        message: `Duplicate entry ID: "${entry.id}"`,
+        entryId: entry.id
+      });
+    }
+    ids.add(entry.id);
+    if (!entry.path) {
+      issues.push({
+        severity: "error",
+        code: "MISSING_PATH",
+        message: `Entry "${entry.id}" has no path`,
+        hint: "Set path to the relative file location (e.g. .claude/rules/my-rule.md)",
+        entryId: entry.id
+      });
+    }
+    if (!VALID_PRIORITIES2.has(entry.priority)) {
+      issues.push({
+        severity: "error",
+        code: "INVALID_PRIORITY",
+        message: `Entry "${entry.id}" has invalid priority "${entry.priority}"`,
+        entryId: entry.id
+      });
+    }
+    if (!entry.summary || entry.summary.length === 0) {
+      issues.push({
+        severity: "error",
+        code: "MISSING_SUMMARY",
+        message: `Entry "${entry.id}" has no summary`,
+        entryId: entry.id
+      });
+    } else if (entry.summary.length > 120) {
+      issues.push({
+        severity: "warning",
+        code: "LONG_SUMMARY",
+        message: `Entry "${entry.id}" summary exceeds 120 chars (${entry.summary.length})`,
+        entryId: entry.id
+      });
+    }
+    if (entry.priority === "domain" && (!entry.keywords || entry.keywords.length === 0)) {
+      issues.push({
+        severity: "error",
+        code: "EMPTY_KEYWORDS",
+        message: `Domain entry "${entry.id}" has no keywords \u2014 cannot be routed`,
+        hint: "Add keywords to frontmatter so the matcher can find this entry",
+        entryId: entry.id
+      });
+    }
+    if (typeof entry.tokens_est !== "number" || entry.tokens_est < 0) {
+      issues.push({
+        severity: "warning",
+        code: "BAD_TOKEN_EST",
+        message: `Entry "${entry.id}" has invalid token estimate: ${entry.tokens_est}`,
+        entryId: entry.id
+      });
+    }
+  }
+  if (index.budget) {
+    if (index.budget.always_loaded_est < 0) {
+      issues.push({
+        severity: "warning",
+        code: "NEGATIVE_BUDGET",
+        message: "always_loaded_est is negative"
+      });
+    }
+    if (index.budget.on_demand_total_est < 0) {
+      issues.push({
+        severity: "warning",
+        code: "NEGATIVE_BUDGET",
+        message: "on_demand_total_est is negative"
+      });
+    }
+  }
+  return issues;
+}
+
+// ../kernel/dist/merge.js
+function mergeIndexes(layers) {
+  const entryMap = /* @__PURE__ */ new Map();
+  const provenance = {};
+  const conflicts = [];
+  const idLayers = /* @__PURE__ */ new Map();
+  for (const { name, index } of layers) {
+    for (const entry of index.entries) {
+      const existing = idLayers.get(entry.id) ?? [];
+      existing.push(name);
+      idLayers.set(entry.id, existing);
+      entryMap.set(entry.id, { entry, layer: name });
+      provenance[entry.id] = name;
+    }
+  }
+  for (const [id, layerNames] of idLayers) {
+    if (layerNames.length > 1) {
+      conflicts.push({
+        entryId: id,
+        layers: layerNames,
+        resolution: "override"
+      });
+    }
+  }
+  const entries = [...entryMap.values()].map((v) => v.entry);
+  const coreTokens = entries.filter((e) => e.priority === "core").reduce((sum, e) => sum + e.tokens_est, 0);
+  const onDemandTokens = entries.filter((e) => e.priority !== "core").reduce((sum, e) => sum + e.tokens_est, 0);
+  const domainEntries = entries.filter((e) => e.priority === "domain");
+  const avgTaskLoad = domainEntries.length > 0 ? Math.round(onDemandTokens / domainEntries.length) : 0;
+  const budget = {
+    always_loaded_est: coreTokens,
+    on_demand_total_est: onDemandTokens,
+    avg_task_load_est: avgTaskLoad,
+    avg_task_load_observed: null
+  };
+  return {
+    version: "1.0.0",
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    entries,
+    budget,
+    provenance,
+    conflicts
+  };
+}
+
+// ../kernel/dist/usage.js
+import { appendFileSync, readFileSync, existsSync } from "node:fs";
+function readUsageWithStats(filePath) {
+  if (!existsSync(filePath))
+    return { events: [], skipped: 0 };
+  const content = readFileSync(filePath, "utf-8");
+  const events = [];
+  let skipped = 0;
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      events.push(JSON.parse(trimmed));
+    } catch {
+      skipped++;
+    }
+  }
+  return { events, skipped };
+}
+function readUsage(filePath) {
+  return readUsageWithStats(filePath).events;
+}
+function summarizeUsage(events) {
+  const map = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const existing = map.get(event.entryId);
+    if (existing) {
+      existing.loadCount++;
+      existing.totalTokens += event.tokensEst;
+      if (event.timestamp > existing.lastLoaded) {
+        existing.lastLoaded = event.timestamp;
+      }
+      existing.triggers.add(event.trigger);
+      existing.modes.add(event.mode);
+    } else {
+      map.set(event.entryId, {
+        loadCount: 1,
+        totalTokens: event.tokensEst,
+        lastLoaded: event.timestamp,
+        triggers: /* @__PURE__ */ new Set([event.trigger]),
+        modes: /* @__PURE__ */ new Set([event.mode])
+      });
+    }
+  }
+  return [...map.entries()].map(([entryId, data]) => ({
+    entryId,
+    loadCount: data.loadCount,
+    totalTokens: data.totalTokens,
+    lastLoaded: data.lastLoaded,
+    triggers: [...data.triggers],
+    modes: data.modes
+  })).sort((a, b) => b.loadCount - a.loadCount);
+}
+function summaryToJSON(summary) {
+  return {
+    entryId: summary.entryId,
+    loadCount: summary.loadCount,
+    totalTokens: summary.totalTokens,
+    lastLoaded: summary.lastLoaded,
+    triggers: summary.triggers,
+    modes: [...summary.modes]
+  };
+}
+
+// ../kernel/dist/analysis.js
+function findDeadEntries(index, events) {
+  const loadedIds = new Set(events.map((e) => e.entryId));
+  const dead = [];
+  for (const entry of index.entries) {
+    if (entry.priority === "core")
+      continue;
+    if (!loadedIds.has(entry.id)) {
+      dead.push({
+        entry,
+        reason: `Never loaded (${entry.tokens_est} tokens wasted in index)`
+      });
+    }
+  }
+  dead.sort((a, b) => b.entry.tokens_est - a.entry.tokens_est);
+  return dead;
+}
+function findKeywordOverlaps(index) {
+  const keywordMap = /* @__PURE__ */ new Map();
+  for (const entry of index.entries) {
+    for (const kw of entry.keywords) {
+      const existing = keywordMap.get(kw) ?? [];
+      existing.push(entry.id);
+      keywordMap.set(kw, existing);
+    }
+  }
+  const overlaps = [];
+  for (const [keyword, entries] of keywordMap) {
+    if (entries.length > 1) {
+      overlaps.push({ keyword, entries });
+    }
+  }
+  overlaps.sort((a, b) => b.entries.length - a.entries.length);
+  return overlaps;
+}
+function analyzeBudget(index, usage) {
+  const core = index.entries.filter((e) => e.priority === "core");
+  const domain = index.entries.filter((e) => e.priority === "domain");
+  const manual = index.entries.filter((e) => e.priority === "manual");
+  const coreTokens = core.reduce((s, e) => s + e.tokens_est, 0);
+  const domainTokens = domain.reduce((s, e) => s + e.tokens_est, 0);
+  const manualTokens = manual.reduce((s, e) => s + e.tokens_est, 0);
+  const allEntries = index.entries;
+  const sorted = [...allEntries].sort((a, b) => b.tokens_est - a.tokens_est);
+  let observedAvg = null;
+  if (usage && usage.length > 0) {
+    const totalObservedTokens = usage.reduce((s, u) => s + u.totalTokens, 0);
+    const totalLoads = usage.reduce((s, u) => s + u.loadCount, 0);
+    if (totalLoads > 0) {
+      observedAvg = Math.round(totalObservedTokens / totalLoads);
+    }
+  }
+  return {
+    totalTokens: coreTokens + domainTokens + manualTokens,
+    coreTokens,
+    domainTokens,
+    manualTokens,
+    coreEntries: core.length,
+    domainEntries: domain.length,
+    manualEntries: manual.length,
+    avgDomainSize: domain.length > 0 ? Math.round(domainTokens / domain.length) : 0,
+    largestEntry: sorted.length > 0 ? { id: sorted[0].id, tokens: sorted[0].tokens_est } : null,
+    smallestEntry: sorted.length > 0 ? { id: sorted[sorted.length - 1].id, tokens: sorted[sorted.length - 1].tokens_est } : null,
+    observedAvg
+  };
+}
+
+// ../kernel/dist/resolve.js
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "node:fs";
+import { join, resolve as resolvePath } from "node:path";
+import { homedir } from "node:os";
+function discoverLayers(opts) {
+  const projectRoot = resolvePath(opts?.projectRoot ?? process.cwd());
+  const globalDir = opts?.globalDir ?? join(homedir(), ".ai-loadout");
+  const orgPath = opts?.orgPath ?? process.env.AI_LOADOUT_ORG ?? null;
+  const sessionPath = opts?.sessionPath ?? process.env.AI_LOADOUT_SESSION ?? null;
+  const candidates = [
+    { name: "global", path: join(globalDir, "index.json") }
+  ];
+  if (orgPath) {
+    candidates.push({ name: "org", path: resolvePath(orgPath) });
+  }
+  candidates.push({
+    name: "project",
+    path: join(projectRoot, ".claude", "loadout", "index.json")
+  });
+  if (sessionPath) {
+    candidates.push({ name: "session", path: resolvePath(sessionPath) });
+  }
+  const layers = [];
+  const searched = [];
+  for (const { name, path } of candidates) {
+    const found = existsSync2(path);
+    searched.push({ name, path, found });
+    if (found) {
+      try {
+        const raw = readFileSync2(path, "utf-8");
+        const index = JSON.parse(raw);
+        layers.push({ name, path, index });
+      } catch (e) {
+        const rec = searched[searched.length - 1];
+        rec.found = false;
+        rec.malformed = true;
+        rec.error = e.message;
+      }
+    }
+  }
+  return { layers, searched };
+}
+function resolveLoadout(opts) {
+  const { layers, searched } = discoverLayers(opts);
+  const merged = mergeIndexes(layers.map((l) => ({ name: l.name, index: l.index })));
+  return { merged, layers, searched };
+}
+function explainEntry(entryId, layers) {
+  const definitions = [];
+  const overrideChain = [];
+  for (const layer of layers) {
+    const entry = layer.index.entries.find((e) => e.id === entryId);
+    if (entry) {
+      definitions.push({
+        layer: layer.name,
+        summary: entry.summary,
+        priority: entry.priority,
+        tokens: entry.tokens_est,
+        keywords: entry.keywords,
+        path: entry.path
+      });
+      overrideChain.push(layer.name);
+    }
+  }
+  if (definitions.length === 0) {
+    return null;
+  }
+  return {
+    id: entryId,
+    finalLayer: overrideChain[overrideChain.length - 1],
+    definitions,
+    overrideChain,
+    isConflict: definitions.length > 1
+  };
+}
+
+// ../memories/dist/index-gen.js
+import { readFileSync as readFileSync4 } from "node:fs";
+import { dirname as dirname2, resolve as resolve2 } from "node:path";
+
+// ../memories/dist/analyze.js
+import { readFileSync as readFileSync3, existsSync as existsSync4, readdirSync, statSync } from "node:fs";
+import { join as join3, dirname, relative, extname, basename, resolve } from "node:path";
+
+// ../memories/dist/paths.js
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join2 } from "node:path";
+function resolveRefPath(refPath, ...baseDirs) {
+  for (const base of baseDirs) {
+    const full = join2(base, refPath);
+    if (existsSync3(full))
+      return full;
+  }
+  return null;
+}
+
+// ../memories/dist/analyze.js
+function analyzeMemoryMd(filePath) {
+  let content;
+  try {
+    content = readFileSync3(filePath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Cannot read MEMORY.md at ${filePath}: ${msg}`);
+  }
+  const fileDir = dirname(resolve(filePath));
+  const parentDir = dirname(fileDir);
+  const { sections, refs } = parseMemoryMd(content);
+  const inlineTokens = estimateTokens(content);
+  const diagnostics = [];
+  const missingFiles = [];
+  let topicTokens = 0;
+  for (const ref of refs) {
+    const resolved = resolveRefPath(ref.path, fileDir, parentDir);
+    if (resolved) {
+      try {
+        const topicContent = readFileSync3(resolved, "utf-8");
+        topicTokens += estimateTokens(topicContent);
+      } catch {
+        missingFiles.push(ref.path);
+        diagnostics.push({
+          severity: "error",
+          code: "MISSING_TOPIC_FILE",
+          message: `Referenced topic file not found: ${ref.path}`,
+          refPath: ref.path,
+          line: ref.line,
+          hint: "Create the file or remove the reference from MEMORY.md"
+        });
+      }
+    } else {
+      missingFiles.push(ref.path);
+      diagnostics.push({
+        severity: "error",
+        code: "MISSING_TOPIC_FILE",
+        message: `Referenced topic file not found: ${ref.path}`,
+        refPath: ref.path,
+        line: ref.line,
+        hint: "Create the file or remove the reference from MEMORY.md"
+      });
+    }
+  }
+  const referencedBasenames = /* @__PURE__ */ new Set();
+  for (const ref of refs) {
+    referencedBasenames.add(ref.path);
+    referencedBasenames.add(basename(ref.path));
+  }
+  const orphanFiles = [];
+  if (existsSync4(fileDir)) {
+    try {
+      for (const entry of readdirSync(fileDir)) {
+        const fullPath = join3(fileDir, entry);
+        try {
+          const stat = statSync(fullPath);
+          if (stat.isFile() && extname(entry) === ".md" && entry !== "MEMORY.md") {
+            if (!referencedBasenames.has(entry)) {
+              orphanFiles.push(entry);
+              diagnostics.push(orphanDiagnostic(entry));
+            }
+          }
+          if (stat.isDirectory()) {
+            scanDir(fullPath, fileDir, referencedBasenames, orphanFiles, diagnostics);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    filePath,
+    sections,
+    refs,
+    orphanFiles,
+    missingFiles,
+    diagnostics,
+    totalTokens: inlineTokens + topicTokens,
+    inlineTokens,
+    topicTokens
+  };
+}
+function orphanDiagnostic(path) {
+  return {
+    severity: "warning",
+    code: "ORPHAN_TOPIC_FILE",
+    message: `Topic file not referenced in MEMORY.md: ${path}`,
+    refPath: path,
+    hint: "Add a reference in MEMORY.md or delete the file"
+  };
+}
+function scanDir(dir, baseDir, referenced, orphans, diagnostics) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry);
+    try {
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        scanDir(fullPath, baseDir, referenced, orphans, diagnostics);
+      } else if (extname(entry) === ".md") {
+        const relPath = relative(baseDir, fullPath).replace(/\\/g, "/");
+        if (!referenced.has(relPath) && !referenced.has(basename(relPath))) {
+          orphans.push(relPath);
+          diagnostics.push(orphanDiagnostic(relPath));
+        }
+      }
+    } catch {
+    }
+  }
+}
+function extractKeywords(name, content) {
+  const words = /* @__PURE__ */ new Set();
+  for (const w of name.toLowerCase().split(/[\s-]+/)) {
+    if (w.length > 2 && !STOP_WORDS.has(w)) {
+      words.add(w);
+    }
+  }
+  for (const line of content.split("\n")) {
+    const headingMatch = line.match(/^#{1,3}\s+(.+)/);
+    if (headingMatch) {
+      for (const w of headingMatch[1].toLowerCase().split(/[\s-]+/)) {
+        const cleaned = w.replace(/[^a-z0-9]/g, "");
+        if (cleaned.length > 2 && !STOP_WORDS.has(cleaned)) {
+          words.add(cleaned);
+        }
+      }
+    }
+  }
+  return [...words].sort();
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "are",
+  "not",
+  "but",
+  "with",
+  "from",
+  "this",
+  "that",
+  "have",
+  "has",
+  "had",
+  "was",
+  "were",
+  "been",
+  "will",
+  "can",
+  "may",
+  "should",
+  "would",
+  "could",
+  "about",
+  "into",
+  "than",
+  "then",
+  "when",
+  "where",
+  "which",
+  "what",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "only",
+  "own",
+  "same",
+  "just",
+  "also",
+  "very",
+  "often",
+  "once",
+  "here",
+  "there",
+  "why",
+  "use",
+  "used",
+  "using",
+  "note",
+  "notes"
+]);
+
+// ../memories/dist/index-gen.js
+function generateIndex(analysis, opts = {}) {
+  const fileDir = dirname2(resolve2(analysis.filePath));
+  const parentDir = dirname2(fileDir);
+  const entries = [];
+  for (const ref of analysis.refs) {
+    const fullPath = resolveRefPath(ref.path, fileDir, parentDir);
+    if (!fullPath) {
+      if (!analysis.missingFiles.includes(ref.path)) {
+        analysis.missingFiles.push(ref.path);
+      }
+      if (!analysis.diagnostics.some((d) => d.code === "UNRESOLVED_REF" && d.refPath === ref.path)) {
+        analysis.diagnostics.push({
+          severity: "error",
+          code: "UNRESOLVED_REF",
+          message: `Reference could not be resolved to a file on disk: ${ref.path}`,
+          refPath: ref.path,
+          line: ref.line,
+          hint: "Create the file, fix the path, or remove the reference from MEMORY.md"
+        });
+      }
+      continue;
+    }
+    const content = readFileSync4(fullPath, "utf-8");
+    const { frontmatter } = parseFrontmatter(content);
+    if (frontmatter) {
+      entries.push(entryFromFrontmatter(frontmatter, ref, content));
+    } else {
+      entries.push(entryFromContent(ref, content));
+    }
+  }
+  const coreTokens = entries.filter((e) => e.priority === "core").reduce((sum, e) => sum + e.tokens_est, 0);
+  const onDemandTokens = entries.filter((e) => e.priority !== "core").reduce((sum, e) => sum + e.tokens_est, 0);
+  const domainEntries = entries.filter((e) => e.priority === "domain");
+  const avgTaskLoad = domainEntries.length > 0 ? Math.round(onDemandTokens / domainEntries.length) : 0;
+  const budget = {
+    always_loaded_est: analysis.inlineTokens + coreTokens,
+    on_demand_total_est: onDemandTokens,
+    avg_task_load_est: avgTaskLoad,
+    avg_task_load_observed: null
+  };
+  return {
+    version: "1.0.0",
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    source: analysis.filePath,
+    entries,
+    budget,
+    ...opts.lazyLoad ? { lazyLoad: true } : {}
+  };
+}
+var MAX_SUMMARY = 120;
+function truncateSummary(summary) {
+  return summary.slice(0, MAX_SUMMARY);
+}
+function entryFromFrontmatter(fm, ref, content) {
+  const lines = content.split("\n").length;
+  return {
+    id: fm.id,
+    path: ref.path,
+    keywords: fm.keywords,
+    patterns: fm.patterns,
+    priority: fm.priority,
+    // MEM-007: truncate here too — entryFromContent already truncated to
+    // 120, this branch did not, so a long summary survived asymmetrically.
+    summary: truncateSummary(ref.description || `Memory: ${ref.name}`),
+    triggers: fm.triggers,
+    tokens_est: estimateTokens(content),
+    lines
+  };
+}
+function entryFromContent(ref, content) {
+  const id = nameToId(ref.name);
+  const keywords = extractKeywords(ref.name, content);
+  const lines = content.split("\n").length;
+  return {
+    id,
+    path: ref.path,
+    keywords,
+    patterns: [],
+    priority: "domain",
+    summary: ref.description ? truncateSummary(ref.description) : `Memory: ${ref.name}`,
+    triggers: { ...DEFAULT_TRIGGERS },
+    tokens_est: estimateTokens(content),
+    lines
+  };
+}
+function nameToId(name) {
+  return name.toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-");
+}
+
+// ../memories/dist/parser.js
+var ARROW_REF_RE = /^(?:[-*]\s+)?(.+?)\s+→\s+`?([^\s`]+)`?\s*$/;
+var INLINE_PATH_RE = /`(memory\/[^\s`]+|[^\s`]+\.md)`/;
+function isRelativeTopicPath(path) {
+  if (!path)
+    return false;
+  if (path.includes("*"))
+    return false;
+  if (path.startsWith("/"))
+    return false;
+  if (/^[a-zA-Z]:[\\/]/.test(path))
+    return false;
+  if (/^\\\\/.test(path))
+    return false;
+  return true;
+}
+function parseMemoryMd(content) {
+  const lines = content.split("\n");
+  const sections = [];
+  const allRefs = [];
+  let currentSection = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)/);
+    if (headingMatch) {
+      if (currentSection) {
+        currentSection.endLine = i - 1;
+        sections.push(currentSection);
+      }
+      currentSection = {
+        heading: headingMatch[2].trim(),
+        level: headingMatch[1].length,
+        entries: [],
+        startLine: i,
+        endLine: i
+      };
+      continue;
+    }
+    if (!trimmed)
+      continue;
+    const ref = parseRefLine(trimmed, i);
+    if (ref) {
+      allRefs.push(ref);
+      if (currentSection) {
+        currentSection.entries.push(ref);
+      }
+    }
+  }
+  if (currentSection) {
+    currentSection.endLine = lines.length - 1;
+    sections.push(currentSection);
+  }
+  return { sections, refs: allRefs };
+}
+function parseRefLine(line, lineNum) {
+  const stripped = line.replace(/^[-*]\s+/, "").trim();
+  if (!stripped)
+    return null;
+  const arrowMatch = line.match(ARROW_REF_RE);
+  if (arrowMatch) {
+    const [, nameDesc, path] = arrowMatch;
+    const { name, description } = splitNameDesc(nameDesc);
+    return { name, description, path, line: lineNum };
+  }
+  const isBullet = /^[-*]\s+/.test(line);
+  const hasArrow = line.includes(" \u2192 ");
+  if (isBullet && hasArrow) {
+    const pathMatch = stripped.match(INLINE_PATH_RE);
+    if (pathMatch) {
+      const path = pathMatch[1];
+      if (isRelativeTopicPath(path)) {
+        const pathIdx = stripped.indexOf("`" + path);
+        if (pathIdx !== -1) {
+          const beforePath = stripped.slice(0, pathIdx).trim();
+          const cleaned = beforePath.replace(/\s*→\s*$/, "").trim();
+          if (cleaned) {
+            const { name, description } = splitNameDesc(cleaned);
+            const id = nameToId(name);
+            if (id && !id.startsWith("-") && !id.endsWith("-")) {
+              return { name, description, path, line: lineNum };
+            }
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+function splitNameDesc(text) {
+  const emIdx = text.indexOf("\u2014");
+  if (emIdx !== -1) {
+    return {
+      name: text.slice(0, emIdx).trim(),
+      description: text.slice(emIdx + 1).trim()
+    };
+  }
+  const hhIdx = text.indexOf("--");
+  if (hhIdx !== -1) {
+    return {
+      name: text.slice(0, hhIdx).trim(),
+      description: text.slice(hhIdx + 2).trim()
+    };
+  }
+  return { name: text.trim(), description: "" };
+}
+
+// ../memories/dist/validate.js
+import { readFileSync as readFileSync5 } from "node:fs";
+import { dirname as dirname3, resolve as resolve3 } from "node:path";
+var MAX_ID_LENGTH = 60;
+function validateMemory(analysis) {
+  const issues = [];
+  for (const path of analysis.missingFiles) {
+    issues.push({
+      severity: "error",
+      code: "MISSING_TOPIC_FILE",
+      message: `Referenced topic file not found: ${path}`,
+      hint: "Create the file or remove the reference from MEMORY.md"
+    });
+  }
+  for (const path of analysis.orphanFiles) {
+    issues.push({
+      severity: "warning",
+      code: "ORPHAN_TOPIC_FILE",
+      message: `Topic file not referenced in MEMORY.md: ${path}`,
+      hint: "Add a reference in MEMORY.md or delete the file"
+    });
+  }
+  if (analysis.refs.length === 0) {
+    issues.push({
+      severity: "warning",
+      code: "NO_REFS",
+      message: "MEMORY.md has no topic file references",
+      hint: "Add references using the format: Name \u2014 description \u2192 `path`"
+    });
+  }
+  const pathCounts = /* @__PURE__ */ new Map();
+  for (const ref of analysis.refs) {
+    pathCounts.set(ref.path, (pathCounts.get(ref.path) ?? 0) + 1);
+  }
+  for (const [path, count] of pathCounts) {
+    if (count > 1) {
+      issues.push({
+        severity: "warning",
+        code: "DUPLICATE_REF",
+        message: `Topic file referenced ${count} times: ${path}`
+      });
+    }
+  }
+  for (const ref of analysis.refs) {
+    if (!ref.name || ref.name.trim().length === 0) {
+      issues.push({
+        severity: "warning",
+        code: "EMPTY_NAME",
+        message: `Reference at line ${ref.line + 1} has no name`
+      });
+    }
+  }
+  const fileDir = dirname3(resolve3(analysis.filePath));
+  const parentDir = dirname3(fileDir);
+  for (const ref of analysis.refs) {
+    let effectiveId = nameToId(ref.name);
+    let source = "Derived";
+    const resolved = resolveRefPath(ref.path, fileDir, parentDir);
+    if (resolved) {
+      try {
+        const { frontmatter } = parseFrontmatter(readFileSync5(resolved, "utf-8"));
+        if (frontmatter && typeof frontmatter.id === "string" && frontmatter.id.length > 0) {
+          effectiveId = frontmatter.id;
+          source = "Frontmatter";
+        }
+      } catch {
+      }
+    }
+    if (effectiveId.length > MAX_ID_LENGTH) {
+      issues.push({
+        severity: "warning",
+        code: "ID_TOO_LONG",
+        message: `${source} id at line ${ref.line + 1} is ${effectiveId.length} chars (max ${MAX_ID_LENGTH}): "${effectiveId}"`,
+        hint: source === "Frontmatter" ? `Shorten the frontmatter id in ${ref.path} so it stays under ${MAX_ID_LENGTH} chars` : `Shorten the reference name so its kebab-case id stays under ${MAX_ID_LENGTH} chars`
+      });
+    }
+  }
+  return issues;
+}
+function validateMemoryIndex(index) {
+  return validateIndex(index);
+}
+
+// ../memories/dist/stats.js
+function generateStats(analysis, index) {
+  const coreCount = index.entries.filter((e) => e.priority === "core").length;
+  const domainCount = index.entries.filter((e) => e.priority === "domain").length;
+  const manualCount = index.entries.filter((e) => e.priority === "manual").length;
+  const savingsPercent = analysis.totalTokens > 0 ? Math.round(index.budget.on_demand_total_est / analysis.totalTokens * 100) : 0;
+  const topEntries = [...index.entries].sort((a, b) => b.tokens_est - a.tokens_est).slice(0, 10).map((e) => ({ id: e.id, tokens: e.tokens_est, priority: e.priority }));
+  return {
+    totalTokens: analysis.totalTokens,
+    inlineTokens: analysis.inlineTokens,
+    topicTokens: analysis.topicTokens,
+    entryCount: index.entries.length,
+    coreCount,
+    domainCount,
+    manualCount,
+    alwaysLoadedEst: index.budget.always_loaded_est,
+    onDemandTotalEst: index.budget.on_demand_total_est,
+    avgTaskLoadEst: index.budget.avg_task_load_est,
+    savingsPercent,
+    topEntries,
+    orphanCount: analysis.orphanFiles.length,
+    missingCount: analysis.missingFiles.length
+  };
+}
+function formatStats(stats) {
+  const lines = [];
+  lines.push("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  lines.push("\u2551        Memory Token Budget               \u2551");
+  lines.push("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+  lines.push("");
+  lines.push(`  Total tokens:       ${stats.totalTokens.toLocaleString()}`);
+  lines.push(`  MEMORY.md inline:   ${stats.inlineTokens.toLocaleString()}`);
+  lines.push(`  Topic files:        ${stats.topicTokens.toLocaleString()}`);
+  lines.push("");
+  lines.push(`  Entries:            ${stats.entryCount}`);
+  lines.push(`    Core:             ${stats.coreCount}`);
+  lines.push(`    Domain:           ${stats.domainCount}`);
+  lines.push(`    Manual:           ${stats.manualCount}`);
+  lines.push("");
+  lines.push(`  Always loaded:      ${stats.alwaysLoadedEst.toLocaleString()} tokens`);
+  lines.push(`  On-demand total:    ${stats.onDemandTotalEst.toLocaleString()} tokens`);
+  lines.push(`  Avg task load:      ${stats.avgTaskLoadEst.toLocaleString()} tokens`);
+  lines.push(`  Savings (lazy):     ${stats.savingsPercent}%`);
+  if (stats.topEntries.length > 0) {
+    lines.push("");
+    lines.push("  Top entries by token cost:");
+    for (const e of stats.topEntries) {
+      lines.push(`    ${e.id.padEnd(30)} ${String(e.tokens).padStart(6)} tokens  [${e.priority}]`);
+    }
+  }
+  if (stats.orphanCount > 0 || stats.missingCount > 0) {
+    lines.push("");
+    if (stats.orphanCount > 0)
+      lines.push(`  \u26A0 ${stats.orphanCount} orphan files`);
+    if (stats.missingCount > 0)
+      lines.push(`  \u2717 ${stats.missingCount} missing files`);
+  }
+  return lines.join("\n");
+}
+
+// ../rules/dist/parser.js
+var HEADING_RE = /^(#{1,6})\s+(.+)$/;
+function detectHeadings(lines) {
+  const headings = [];
+  for (let i = 0; i < lines.length; i++) {
+    const match = HEADING_RE.exec(lines[i]);
+    if (match) {
+      headings.push({
+        level: match[1].length,
+        text: match[2].trim(),
+        lineIndex: i
+      });
+    }
+  }
+  return headings;
+}
+function parseSections(content) {
+  const lines = content.split("\n");
+  const headings = detectHeadings(lines);
+  const splitHeadings = headings.filter((h) => h.level === 2 || h.level === 3);
+  if (splitHeadings.length === 0) {
+    if (lines.length === 0 || lines.length === 1 && lines[0].trim() === "") {
+      return [];
+    }
+    return [
+      {
+        heading: "(preamble)",
+        level: 0,
+        startLine: 0,
+        endLine: lines.length,
+        content,
+        lines: lines.length,
+        tokens_est: estimateTokens(content)
+      }
+    ];
+  }
+  const sections = [];
+  if (splitHeadings[0].lineIndex > 0) {
+    const preambleLines = lines.slice(0, splitHeadings[0].lineIndex);
+    const preambleContent = preambleLines.join("\n");
+    if (preambleContent.trim().length > 0) {
+      sections.push({
+        heading: "(preamble)",
+        level: 0,
+        startLine: 0,
+        endLine: splitHeadings[0].lineIndex,
+        content: preambleContent,
+        lines: preambleLines.length,
+        tokens_est: estimateTokens(preambleContent)
+      });
+    }
+  }
+  for (let i = 0; i < splitHeadings.length; i++) {
+    const h = splitHeadings[i];
+    if (h.level === 3) {
+      let ownedByParent = false;
+      for (let j = i - 1; j >= 0; j--) {
+        if (splitHeadings[j].level === 2) {
+          ownedByParent = true;
+          break;
+        }
+        if (splitHeadings[j].level < 3)
+          break;
+      }
+      if (ownedByParent)
+        continue;
+    }
+    let endLine = lines.length;
+    for (let j = i + 1; j < splitHeadings.length; j++) {
+      if (splitHeadings[j].level <= h.level) {
+        endLine = splitHeadings[j].lineIndex;
+        break;
+      }
+    }
+    while (endLine > h.lineIndex + 1 && lines[endLine - 1].trim() === "") {
+      endLine--;
+    }
+    const sectionLines = lines.slice(h.lineIndex, endLine);
+    const sectionContent = sectionLines.join("\n");
+    sections.push({
+      heading: h.text,
+      level: h.level,
+      startLine: h.lineIndex,
+      endLine,
+      content: sectionContent,
+      lines: sectionLines.length,
+      tokens_est: estimateTokens(sectionContent)
+    });
+  }
+  return sections;
+}
+var NOISE_WORDS = /* @__PURE__ */ new Set([
+  "rules",
+  "rule",
+  "non-negotiable",
+  "nonnegotiable",
+  "contract",
+  "source",
+  "of",
+  "truth",
+  "the",
+  "a",
+  "an",
+  "and",
+  "for",
+  "in",
+  "required",
+  "before",
+  "after",
+  "hard"
+]);
+function headingToId(heading) {
+  return heading.toLowerCase().replace(/\([^)]*\)/g, "").replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 0 && !NOISE_WORDS.has(w)).slice(0, 3).join("-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "unnamed";
+}
+
+// ../rules/dist/analyze.js
+import { readFileSync as readFileSync7, existsSync as existsSync6 } from "node:fs";
+import { resolve as resolve5 } from "node:path";
+
+// ../rules/dist/console.js
+var RED2 = "\x1B[31m";
+var DIM2 = "\x1B[2m";
+var RESET2 = "\x1B[0m";
+function fail2(code, message, hint, exitCode = 1) {
+  console.error(`${RED2}Error [${code}]:${RESET2} ${message}`);
+  console.error(`${DIM2}Hint: ${hint}${RESET2}`);
+  process.exit(exitCode);
+}
+
+// ../rules/dist/signals.js
+import { readFileSync as readFileSync6, existsSync as existsSync5, writeFileSync, mkdirSync } from "node:fs";
+import { resolve as resolve4, dirname as dirname4 } from "node:path";
+var DEFAULT_SIGNALS = {
+  domainSignals: [
+    "github actions",
+    "ci",
+    "workflow",
+    "runner",
+    "marketing",
+    "site",
+    "publishing",
+    "automation",
+    "shipping",
+    "publish",
+    "release",
+    "npm",
+    "ownership",
+    "repo",
+    "org",
+    "canonical",
+    "preview",
+    "verification",
+    "dev server",
+    "shipcheck",
+    "treatment",
+    "landing page",
+    "product",
+    "development",
+    "output-first",
+    "guardian",
+    "self-check",
+    "document delight"
+  ],
+  stopWords: [
+    "the",
+    "and",
+    "for",
+    "are",
+    "but",
+    "not",
+    "you",
+    "all",
+    "can",
+    "had",
+    "her",
+    "was",
+    "one",
+    "our",
+    "out",
+    "has",
+    "this",
+    "that",
+    "with",
+    "have",
+    "from",
+    "they",
+    "been",
+    "must",
+    "will",
+    "each",
+    "make",
+    "like",
+    "when",
+    "never",
+    "only",
+    "rule",
+    "rules",
+    "non",
+    "negotiable"
+  ],
+  patterns: {
+    ci_pipeline: ["ci", "workflow", "github actions"],
+    package_release: ["publish", "release", "npm"],
+    marketing_ops: ["marketing", "site", "landing page"],
+    repo_governance: ["ownership", "canonical", "repo"],
+    dev_workflow: ["preview", "dev server", "verification"],
+    quality_gate: ["shipcheck", "ship_gate", "treatment"],
+    product_dev: ["product", "output-first"]
+  }
+};
+function loadSignals(signalsPath) {
+  const effectivePath = signalsPath ?? resolve4(".claude", "signals.json");
+  if (!existsSync5(effectivePath)) {
+    return DEFAULT_SIGNALS;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync6(effectivePath, "utf8"));
+  } catch (e) {
+    return fail2("INVALID_SIGNALS", `Failed to parse signals config: ${e.message}`, `Check that ${effectivePath} is valid JSON, or run 'claude-rules init-signals' to regenerate it.`);
+  }
+  return {
+    domainSignals: Array.isArray(raw.domainSignals) ? raw.domainSignals : DEFAULT_SIGNALS.domainSignals,
+    stopWords: Array.isArray(raw.stopWords) ? raw.stopWords : DEFAULT_SIGNALS.stopWords,
+    patterns: raw.patterns && typeof raw.patterns === "object" ? raw.patterns : DEFAULT_SIGNALS.patterns
+  };
+}
+
+// ../rules/dist/analyze.js
+var CORE_THRESHOLD = 8;
+var EXTRACT_THRESHOLD = 15;
+var NON_NEGOTIABLE_RE = /non-negotiable/i;
+function extractKeywords2(section, signals = DEFAULT_SIGNALS) {
+  const words = /* @__PURE__ */ new Set();
+  const headingWords = section.heading.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2);
+  for (const w of headingWords)
+    words.add(w);
+  const contentLower = section.content.toLowerCase();
+  for (const signal of signals.domainSignals) {
+    if (contentLower.includes(signal)) {
+      for (const w of signal.split(/\s+/)) {
+        if (w.length > 2)
+          words.add(w);
+      }
+    }
+  }
+  const stopWords = new Set(signals.stopWords);
+  return [...words].filter((w) => !stopWords.has(w));
+}
+var ALWAYS_CORE_RE = /^role$/i;
+function classifyPriority(section, signals = DEFAULT_SIGNALS) {
+  if (ALWAYS_CORE_RE.test(section.heading.trim()))
+    return "core";
+  if (section.lines <= CORE_THRESHOLD)
+    return "core";
+  if (NON_NEGOTIABLE_RE.test(section.heading) && section.lines > CORE_THRESHOLD) {
+    return "domain";
+  }
+  if (section.lines >= EXTRACT_THRESHOLD)
+    return "domain";
+  const headingLower = section.heading.toLowerCase();
+  for (const signal of signals.domainSignals) {
+    if (headingLower.includes(signal))
+      return "domain";
+  }
+  return "core";
+}
+function generateSummary(section) {
+  const lines = section.content.split("\n").filter((l) => l.trim().length > 0);
+  const contentLines = lines.filter((l) => !l.startsWith("#"));
+  if (contentLines.length === 0)
+    return section.heading;
+  let summary = contentLines[0].replace(/^[-*]\s*/, "").trim();
+  if (summary.length > 117)
+    summary = summary.slice(0, 117) + "...";
+  return summary;
+}
+function suggestPatterns(section, signals = DEFAULT_SIGNALS) {
+  const result = [];
+  const lower = section.content.toLowerCase();
+  for (const [patternName, triggers] of Object.entries(signals.patterns)) {
+    if (triggers.some((t) => lower.includes(t))) {
+      result.push(patternName);
+    }
+  }
+  return result;
+}
+function analyzeFile(filePath, rulesDir, signals) {
+  const cfg = signals ?? DEFAULT_SIGNALS;
+  const content = readFileSync7(filePath, "utf8");
+  const sections = parseSections(content);
+  const totalTokens = estimateTokens(content);
+  const totalLines = content.split("\n").length;
+  const proposals = [];
+  const coreCandidate = [];
+  for (const section of sections) {
+    if (section.level === 0) {
+      coreCandidate.push(section);
+      continue;
+    }
+    if (section.lines <= 1) {
+      continue;
+    }
+    const priority = classifyPriority(section, cfg);
+    if (priority === "core") {
+      coreCandidate.push(section);
+      continue;
+    }
+    const id = headingToId(section.heading);
+    const keywords = extractKeywords2(section, cfg);
+    const patterns = suggestPatterns(section, cfg);
+    const summary = generateSummary(section);
+    proposals.push({
+      section,
+      suggestedId: id,
+      suggestedPath: `${rulesDir}/${id}.md`,
+      suggestedKeywords: keywords,
+      suggestedPatterns: patterns,
+      suggestedPriority: priority,
+      suggestedSummary: summary,
+      reason: section.lines >= EXTRACT_THRESHOLD ? `${section.lines} lines \u2014 too large to load every session` : `Domain-specific content (${keywords.slice(0, 3).join(", ")})`
+    });
+  }
+  return {
+    filePath,
+    totalLines,
+    totalTokens,
+    sections,
+    proposals,
+    coreCandidate
+  };
+}
+function resolveClaudeMd(positional) {
+  if (positional.length > 0) {
+    return resolve5(positional[0]);
+  }
+  const candidates = [
+    resolve5(".claude/CLAUDE.md"),
+    resolve5("CLAUDE.md")
+  ];
+  for (const c of candidates) {
+    if (existsSync6(c))
+      return c;
+  }
+  return candidates[0];
+}
+function resolveMemoryMd() {
+  const candidates = [
+    resolve5(".claude/MEMORY.md"),
+    resolve5("MEMORY.md")
+  ];
+  for (const c of candidates) {
+    if (existsSync6(c))
+      return c;
+  }
+  return null;
+}
+
+// ../rules/dist/split.js
+function generateRuleFile(proposal) {
+  const fm = {
+    id: proposal.suggestedId,
+    keywords: proposal.suggestedKeywords,
+    patterns: proposal.suggestedPatterns,
+    priority: proposal.suggestedPriority,
+    triggers: { ...DEFAULT_TRIGGERS }
+  };
+  const header = serializeFrontmatter(fm);
+  return `${header}
+
+${proposal.section.content}
+`;
+}
+function generateIndex2(accepted, coreTokens, lazyLoad = false) {
+  const entries = accepted.map((p) => ({
+    id: p.suggestedId,
+    path: p.suggestedPath,
+    keywords: p.suggestedKeywords,
+    patterns: p.suggestedPatterns,
+    priority: p.suggestedPriority,
+    summary: p.suggestedSummary,
+    triggers: { ...DEFAULT_TRIGGERS },
+    tokens_est: p.section.tokens_est,
+    lines: p.section.lines
+  }));
+  const onDemandTotal = entries.reduce((sum, r) => sum + r.tokens_est, 0);
+  const avgTaskLoad = entries.length > 0 ? Math.round(onDemandTotal / entries.length) : 0;
+  const budget = {
+    always_loaded_est: coreTokens,
+    on_demand_total_est: onDemandTotal,
+    avg_task_load_est: avgTaskLoad,
+    avg_task_load_observed: null
+  };
+  return {
+    version: "1.0.0",
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    entries,
+    budget,
+    ...lazyLoad ? { lazyLoad: true } : {}
+  };
+}
+function generateClaudeMd(coreSections, accepted, index, rulesDir, lazyLoad = false) {
+  const lines = [];
+  for (const section of coreSections) {
+    const cleaned = section.content.replace(/\n---\s*$/, "").trimEnd();
+    lines.push(cleaned);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("## Rules Index");
+  lines.push("");
+  lines.push(`Rules are split into topic files under \`${rulesDir}/\`.`);
+  lines.push(`The dispatch table is at \`${rulesDir}/index.json\`.`);
+  lines.push("");
+  if (lazyLoad) {
+    lines.push("**Rule files are NOT pre-loaded. When a task matches a domain rule's keywords, use the Read tool to load the rule file before planning or editing.**");
+  } else {
+    lines.push("**When a task matches a domain rule's keywords, read that rule file before planning or editing.**");
+  }
+  lines.push("");
+  lines.push("| Topic | Keywords | Priority | File |");
+  lines.push("|-------|----------|----------|------|");
+  for (let i = 0; i < index.entries.length; i++) {
+    const rule = index.entries[i];
+    const topic = accepted[i]?.section.heading ?? rule.id;
+    const kw = rule.keywords.slice(0, 4).join(", ");
+    lines.push(`| ${topic} | ${kw} | ${rule.priority} | \`${rule.path}\` |`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// ../rules/dist/validate.js
+import { readFileSync as readFileSync8, existsSync as existsSync7, readdirSync as readdirSync2 } from "node:fs";
+import { resolve as resolve6, join as join4 } from "node:path";
+var FIX_HINTS = {
+  DRIFT_ID: "frontmatter is canonical; update index.json (or re-run `claude-rules split`)",
+  DRIFT_PRIORITY: "frontmatter is canonical; update index.json (or re-run `claude-rules split`)",
+  DRIFT_KEYWORDS: "frontmatter is canonical; update index.json (or re-run `claude-rules split`)",
+  ORPHAN_FILE: "add it to index.json or delete the file",
+  DUPLICATE_ID: "rename one rule's id"
+};
+function frontmatterKeyLine(content, key) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---")
+    return void 0;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === "---")
+      break;
+    if (new RegExp(`^\\s*${key}\\s*:`).test(lines[i]))
+      return i + 1;
+  }
+  return void 0;
+}
+function validateRules(rulesDir, repoRoot) {
+  const issues = [];
+  const absRulesDir = resolve6(repoRoot, rulesDir);
+  const indexPath = join4(absRulesDir, "index.json");
+  if (!existsSync7(indexPath)) {
+    issues.push({
+      severity: "error",
+      code: "MISSING_INDEX",
+      message: `index.json not found at ${rulesDir}/index.json`,
+      file: indexPath
+    });
+    return issues;
+  }
+  let index;
+  try {
+    index = JSON.parse(readFileSync8(indexPath, "utf8"));
+  } catch (e) {
+    issues.push({
+      severity: "error",
+      code: "INVALID_INDEX",
+      message: `Failed to parse index.json: ${e.message}`,
+      file: indexPath
+    });
+    return issues;
+  }
+  if (!Array.isArray(index.entries)) {
+    issues.push({
+      severity: "error",
+      code: "INVALID_INDEX",
+      message: "index.json is missing an `entries` array \u2014 regenerate with `claude-rules split`",
+      file: indexPath
+    });
+    return issues;
+  }
+  if (index.budget === null || typeof index.budget !== "object") {
+    issues.push({
+      severity: "error",
+      code: "INVALID_INDEX",
+      message: "index.json is missing a `budget` object \u2014 regenerate with `claude-rules split`",
+      file: indexPath
+    });
+    return issues;
+  }
+  const indexedFiles = /* @__PURE__ */ new Set();
+  for (const rule of index.entries) {
+    const absPath = resolve6(repoRoot, rule.path);
+    indexedFiles.add(rule.path);
+    if (!existsSync7(absPath)) {
+      issues.push({
+        severity: "error",
+        code: "MISSING_REF",
+        message: `Rule file not found: ${rule.path}`,
+        file: absPath
+      });
+      continue;
+    }
+    const content = readFileSync8(absPath, "utf8");
+    const { frontmatter } = parseFrontmatter(content);
+    if (!frontmatter) {
+      issues.push({
+        severity: "error",
+        code: "MISSING_FRONTMATTER",
+        message: `Rule file has no valid frontmatter: ${rule.path}`,
+        file: absPath
+      });
+      continue;
+    }
+    if (frontmatter.id !== rule.id) {
+      issues.push({
+        severity: "error",
+        code: "DRIFT_ID",
+        message: `ID mismatch: index says "${rule.id}" but frontmatter says "${frontmatter.id}" in ${rule.path}`,
+        file: absPath,
+        line: frontmatterKeyLine(content, "id"),
+        hint: FIX_HINTS.DRIFT_ID
+      });
+    }
+    if (frontmatter.priority !== rule.priority) {
+      issues.push({
+        severity: "warning",
+        code: "DRIFT_PRIORITY",
+        message: `Priority mismatch: index says "${rule.priority}" but frontmatter says "${frontmatter.priority}" in ${rule.path}`,
+        file: absPath,
+        line: frontmatterKeyLine(content, "priority"),
+        hint: FIX_HINTS.DRIFT_PRIORITY
+      });
+    }
+    const indexKw = new Set(rule.keywords);
+    const fmKw = new Set(frontmatter.keywords);
+    if (indexKw.size !== fmKw.size || ![...indexKw].every((k) => fmKw.has(k))) {
+      issues.push({
+        severity: "warning",
+        code: "DRIFT_KEYWORDS",
+        message: `Keywords mismatch in ${rule.path}: index has [${rule.keywords.join(", ")}], frontmatter has [${frontmatter.keywords.join(", ")}]`,
+        file: absPath,
+        line: frontmatterKeyLine(content, "keywords"),
+        hint: FIX_HINTS.DRIFT_KEYWORDS
+      });
+    }
+    if (!rule.summary || rule.summary.length === 0) {
+      issues.push({
+        severity: "error",
+        code: "MISSING_SUMMARY",
+        message: `Rule "${rule.id}" has no summary`,
+        file: absPath
+      });
+    } else if (rule.summary.length > 120) {
+      issues.push({
+        severity: "warning",
+        code: "LONG_SUMMARY",
+        message: `Rule "${rule.id}" summary exceeds 120 chars (${rule.summary.length})`,
+        file: absPath
+      });
+    }
+    if (rule.priority === "domain" && rule.keywords.length === 0) {
+      issues.push({
+        severity: "error",
+        code: "EMPTY_KEYWORDS",
+        message: `Domain rule "${rule.id}" has no keywords \u2014 agent cannot route to it`,
+        file: absPath
+      });
+    }
+  }
+  if (existsSync7(absRulesDir)) {
+    const files = readdirSync2(absRulesDir);
+    for (const file of files) {
+      if (!file.endsWith(".md"))
+        continue;
+      const relativePath = `${rulesDir}/${file}`;
+      if (!indexedFiles.has(relativePath)) {
+        issues.push({
+          severity: "warning",
+          code: "ORPHAN_FILE",
+          message: `Rule file exists but not in index.json: ${relativePath}`,
+          file: join4(absRulesDir, file),
+          hint: FIX_HINTS.ORPHAN_FILE
+        });
+      }
+    }
+  }
+  const ids = index.entries.map((r) => r.id);
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (seen.has(id)) {
+      issues.push({
+        severity: "error",
+        code: "DUPLICATE_ID",
+        message: `Duplicate rule ID: "${id}"`,
+        hint: FIX_HINTS.DUPLICATE_ID
+      });
+    }
+    seen.add(id);
+  }
+  const kwMap = /* @__PURE__ */ new Map();
+  for (const rule of index.entries) {
+    for (const kw of rule.keywords) {
+      const existing = kwMap.get(kw) ?? [];
+      existing.push(rule.id);
+      kwMap.set(kw, existing);
+    }
+  }
+  for (const [kw, ruleIds] of kwMap) {
+    if (ruleIds.length > 1) {
+      issues.push({
+        severity: "warning",
+        code: "DUPLICATE_KEYWORD",
+        message: `Keyword "${kw}" appears in multiple rules: ${ruleIds.join(", ")}`
+      });
+    }
+  }
+  return issues;
+}
+
+// src/commands.ts
+function requireFile(path, what) {
+  const abs = resolve7(path);
+  if (!existsSync8(abs)) {
+    fail("FILE_NOT_FOUND", `${what} not found: ${path}`);
+  }
+  try {
+    if (!statSync2(abs).isFile()) {
+      fail("NOT_A_FILE", `Not a file: ${path}`, `Point at a ${what} file, not a directory.`);
+    }
+  } catch {
+    fail("FILE_NOT_FOUND", `${what} not found: ${path}`);
+  }
+  return abs;
+}
+function loadKernelIndex(path) {
+  const abs = requireFile(path, "index");
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync9(abs, "utf-8"));
+  } catch (e) {
+    fail("PARSE_ERROR", `Failed to parse index: ${path}`, e.message);
+  }
+  if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.entries)) {
+    fail(
+      "INVALID_INDEX",
+      `File is valid JSON but not a loadout index: ${path}`,
+      "Expected an object with an 'entries' array. Run 'loadout-os validate <index>' for details."
+    );
+  }
+  return parsed;
+}
+function memoriesPath(args) {
+  const pos = positionalArgs(args);
+  if (pos.length === 0) {
+    fail(
+      "MISSING_ARG",
+      "A path to MEMORY.md is required",
+      "Usage: loadout-os memories <index|validate|stats|health> <MEMORY.md>"
+    );
+  }
+  return requireFile(pos[0], "MEMORY.md");
+}
+function memoriesIndex(args) {
+  const file = memoriesPath(args);
+  const json = hasFlag(args, "json");
+  const lazyLoad = hasFlag(args, "lazy");
+  const analysis = analyzeMemoryMd(file);
+  const index = generateIndex(analysis, { lazyLoad });
+  const issues = validateMemoryIndex(index);
+  if (json) {
+    log(JSON.stringify({ index, issues, missingFiles: analysis.missingFiles }, null, 2));
+    return;
+  }
+  log(`
+${BOLD}Memory index${RESET} from ${file}
+`);
+  ok(`${index.entries.length} entries`);
+  if (analysis.missingFiles.length > 0) {
+    warn(`${analysis.missingFiles.length} unresolved ref(s) skipped \u2014 run \`memories validate\` for detail`);
+  }
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
+  for (const i of errors) warn(`[${i.code}] ${i.message}`);
+  for (const i of warnings) info(`[${i.code}] ${i.message}`);
+  log(`
+${BOLD}Budget:${RESET}`);
+  log(`  Always loaded:   ${index.budget.always_loaded_est.toLocaleString()} tokens`);
+  log(`  On-demand total: ${index.budget.on_demand_total_est.toLocaleString()} tokens`);
+  log(`  Avg task load:   ${index.budget.avg_task_load_est.toLocaleString()} tokens`);
+  if (lazyLoad) info("Lazy loading enabled");
+  log("");
+}
+function memoriesValidate(args) {
+  const file = memoriesPath(args);
+  const json = hasFlag(args, "json");
+  const analysis = analyzeMemoryMd(file);
+  const memoryIssues = validateMemory(analysis);
+  const index = generateIndex(analysis);
+  const indexIssues = validateMemoryIndex(index);
+  const all = [...memoryIssues, ...indexIssues];
+  const errors = all.filter((i) => i.severity === "error");
+  const warnings = all.filter((i) => i.severity === "warning");
+  if (json) {
+    log(
+      JSON.stringify(
+        { valid: errors.length === 0, errors: errors.length, warnings: warnings.length, issues: all },
+        null,
+        2
+      )
+    );
+    if (errors.length > 0) fail("VALIDATION_FAILED", `${errors.length} error(s)`, void 0, 1);
+    return;
+  }
+  log(`
+${BOLD}Validating${RESET} ${file}
+`);
+  if (errors.length > 0) {
+    log(`${RED}${BOLD}Errors:${RESET}`);
+    for (const i of errors) {
+      log(`  ${RED}\u2717${RESET} [${i.code}] ${i.message}`);
+      if (i.hint) log(`    ${DIM}${i.hint}${RESET}`);
+    }
+  }
+  if (warnings.length > 0) {
+    log(`${YELLOW}${BOLD}Warnings:${RESET}`);
+    for (const i of warnings) {
+      log(`  ${YELLOW}!${RESET} [${i.code}] ${i.message}`);
+      if (i.hint) log(`    ${DIM}${i.hint}${RESET}`);
+    }
+  }
+  if (all.length === 0) ok("No issues found");
+  log(`
+  ${errors.length} errors, ${warnings.length} warnings
+`);
+  if (errors.length > 0) fail("VALIDATION_FAILED", `${errors.length} error(s)`, void 0, 1);
+}
+function memoriesStats(args) {
+  const file = memoriesPath(args);
+  const json = hasFlag(args, "json");
+  const analysis = analyzeMemoryMd(file);
+  const index = generateIndex(analysis);
+  const stats = generateStats(analysis, index);
+  if (json) {
+    log(JSON.stringify(stats, null, 2));
+    return;
+  }
+  log("");
+  log(formatStats(stats));
+  log("");
+}
+function memoriesHealth(args) {
+  const json = hasFlag(args, "json");
+  const nodeMajor = parseInt(process.version.slice(1), 10);
+  const nodeOk = nodeMajor >= 20;
+  const pos = positionalArgs(args);
+  const checked = [];
+  if (pos.length > 0) {
+    const abs = resolve7(pos[0]);
+    checked.push({ label: "given path", path: abs, found: existsSync8(abs) });
+  } else {
+    for (const c of ["MEMORY.md", ".claude/MEMORY.md"]) {
+      const abs = resolve7(c);
+      checked.push({ label: c, path: abs, found: existsSync8(abs) });
+    }
+  }
+  const found = checked.some((c) => c.found);
+  if (json) {
+    log(JSON.stringify({ nodeVersion: process.version, nodeOk, checked, found }, null, 2));
+    if (!nodeOk) fail("NODE_TOO_OLD", `Node ${process.version} < 20`, void 0, 1);
+    return;
+  }
+  log(`
+${BOLD}loadout-os memories health${RESET}`);
+  log(`  Node.js: ${process.version} ${nodeOk ? `${GREEN}(OK)${RESET}` : `${RED}(requires >=20)${RESET}`}`);
+  log(`  Platform: ${process.platform} ${process.arch}`);
+  log(`
+${BOLD}MEMORY.md detection:${RESET}`);
+  for (const c of checked) {
+    if (c.found) ok(`${c.label} \u2192 ${c.path}`);
+    else info(`${c.label} \u2014 not found`);
+  }
+  if (!found) warn("No MEMORY.md detected. Provide a path when running commands.");
+  log("");
+  if (!nodeOk) fail("NODE_TOO_OLD", `Node ${process.version} < 20`, void 0, 1);
+}
+function rulesAnalyze(args) {
+  const pos = positionalArgs(args);
+  if (pos.length === 0) {
+    fail(
+      "MISSING_ARG",
+      "A path to CLAUDE.md is required",
+      "Usage: loadout-os rules analyze <CLAUDE.md> [--rules-dir <dir>]"
+    );
+  }
+  const file = requireFile(pos[0], "CLAUDE.md");
+  const rulesDir = flagValue(args, "rules-dir") ?? ".claude/rules";
+  const json = hasFlag(args, "json");
+  const report = analyzeFile(file, rulesDir);
+  if (json) {
+    log(JSON.stringify(report, null, 2));
+    return;
+  }
+  log(`
+${BOLD}Analyzing${RESET} ${file} ${DIM}(${report.totalLines} lines, ~${report.totalTokens} tokens)${RESET}
+`);
+  log(`${BOLD}Sections:${RESET} ${report.sections.length}`);
+  log(`${BOLD}Keep inline (core):${RESET} ${report.coreCandidate.length}`);
+  log(`${BOLD}Proposed extractions:${RESET} ${report.proposals.length}`);
+  for (const p of report.proposals) {
+    log(`  ${CYAN}${p.suggestedId}${RESET} \u2192 ${p.suggestedPath} ${DIM}[${p.suggestedPriority}]${RESET}`);
+    log(`    ${DIM}${p.reason}${RESET}`);
+  }
+  log("");
+}
+function rulesValidate(args) {
+  const json = hasFlag(args, "json");
+  const lazy = hasFlag(args, "lazy");
+  const rulesDir = flagValue(args, "rules-dir") ?? (lazy ? ".claude/loadout" : ".claude/rules");
+  const repoRoot = flagValue(args, "repo-root") ?? process.cwd();
+  const issues = validateRules(rulesDir, resolve7(repoRoot));
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
+  if (json) {
+    log(
+      JSON.stringify(
+        { valid: errors.length === 0, errors: errors.length, warnings: warnings.length, issues },
+        null,
+        2
+      )
+    );
+    if (errors.length > 0) fail("VALIDATION_FAILED", `${errors.length} error(s)`, void 0, 1);
+    return;
+  }
+  log(`
+${BOLD}Validating${RESET} ${rulesDir}/
+`);
+  if (issues.length === 0) {
+    ok("All rules valid. No issues found.");
+    log("");
+    return;
+  }
+  for (const i of errors) {
+    log(`  ${RED}error${RESET} [${i.code}] ${i.message}`);
+    if (i.hint) log(`      ${DIM}fix: ${i.hint}${RESET}`);
+  }
+  for (const i of warnings) {
+    log(`  ${YELLOW}warn${RESET}  [${i.code}] ${i.message}`);
+    if (i.hint) log(`      ${DIM}fix: ${i.hint}${RESET}`);
+  }
+  log(`
+  ${errors.length} error(s), ${warnings.length} warning(s)
+`);
+  if (errors.length > 0) fail("VALIDATION_FAILED", `${errors.length} error(s)`, void 0, 1);
+}
+function rulesStats(args) {
+  const pos = positionalArgs(args);
+  if (pos.length === 0) {
+    fail(
+      "MISSING_ARG",
+      "A path to CLAUDE.md is required",
+      "Usage: loadout-os rules stats <CLAUDE.md> [--rules-dir <dir>]"
+    );
+  }
+  const file = requireFile(pos[0], "CLAUDE.md");
+  const rulesDir = flagValue(args, "rules-dir") ?? ".claude/rules";
+  const json = hasFlag(args, "json");
+  const report = analyzeFile(file, rulesDir);
+  const coreTokens = report.coreCandidate.reduce((s, c) => s + c.tokens_est, 0);
+  const extractTokens = report.proposals.reduce((s, p) => s + p.section.tokens_est, 0);
+  const savingsPct = report.totalTokens > 0 ? Math.round(extractTokens / report.totalTokens * 100) : 0;
+  const stats = {
+    file: report.filePath,
+    totalLines: report.totalLines,
+    totalTokens: report.totalTokens,
+    sections: report.sections.length,
+    coreSections: report.coreCandidate.length,
+    proposedExtractions: report.proposals.length,
+    alwaysLoadedTokens: coreTokens,
+    onDemandTokens: extractTokens,
+    savingsPercent: savingsPct
+  };
+  if (json) {
+    log(JSON.stringify(stats, null, 2));
+    return;
+  }
+  log(`
+${BOLD}Rules budget${RESET} for ${report.filePath}
+`);
+  log(`  Sections:        ${stats.sections} (${stats.coreSections} core, ${stats.proposedExtractions} extractable)`);
+  log(`  Total:           ${stats.totalLines} lines, ~${stats.totalTokens} tokens`);
+  log(`  Always loaded:   ~${coreTokens} tokens`);
+  log(`  On-demand:       ~${extractTokens} tokens`);
+  log(`  ${BOLD}Savings:         ${savingsPct}% per session${RESET}`);
+  log("");
+}
+function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((res) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      res(answer.trim());
+    });
+  });
+}
+function rulesSplit(args) {
+  void runSplit(args).catch((err) => {
+    fail("RULES_SPLIT_FAILED", `split failed: ${err.message}`);
+  });
+}
+async function runSplit(args) {
+  const filePath = resolveClaudeMd(positionalArgs(args));
+  const lazyLoad = hasFlag(args, "lazy");
+  const rulesDir = flagValue(args, "rules-dir") ?? (lazyLoad ? ".claude/loadout" : ".claude/rules");
+  const dryRun = hasFlag(args, "dry-run");
+  const yesMode = hasFlag(args, "yes");
+  const signals = loadSignals(flagValue(args, "signals") ?? void 0);
+  if (!existsSync8(filePath)) {
+    fail("FILE_NOT_FOUND", `CLAUDE.md not found: ${filePath}`, "Provide a path to your CLAUDE.md.");
+  }
+  info(`Analyzing ${CYAN}${filePath}${RESET}`);
+  const report = analyzeFile(filePath, rulesDir, signals);
+  if (hasFlag(args, "memory")) {
+    const memoryPath = resolveMemoryMd();
+    if (memoryPath) {
+      info(`Also analyzing ${CYAN}${memoryPath}${RESET}`);
+      report.proposals.push(...analyzeFile(memoryPath, rulesDir, signals).proposals);
+    } else {
+      warn("No MEMORY.md found. Skipping --memory.");
+    }
+  }
+  if (report.proposals.length === 0) {
+    ok("Nothing to split \u2014 all sections are already lean enough.");
+    return;
+  }
+  log("");
+  log(
+    `${BOLD}Found ${report.proposals.length} sections to extract${RESET} ${DIM}(${report.totalLines} lines, ~${report.totalTokens} tokens)${RESET}`
+  );
+  log("");
+  const accepted = [];
+  for (let i = 0; i < report.proposals.length; i++) {
+    const p = report.proposals[i];
+    log(`${BOLD}${i + 1}/${report.proposals.length}. "${p.section.heading}"${RESET}`);
+    log(`  ${DIM}Lines ${p.section.startLine + 1}-${p.section.endLine} (${p.section.lines} lines, ~${p.section.tokens_est} tokens)${RESET}`);
+    log(`  \u2192 ${CYAN}${p.suggestedPath}${RESET}`);
+    log(`  keywords: [${p.suggestedKeywords.join(", ")}]`);
+    if (p.suggestedPatterns.length > 0) log(`  patterns: [${p.suggestedPatterns.join(", ")}]`);
+    log(`  priority: ${p.suggestedPriority}`);
+    log(`  summary: ${p.suggestedSummary}`);
+    log("");
+    if (dryRun) {
+      info("(dry run \u2014 would extract)");
+      accepted.push(p);
+      log("");
+      continue;
+    }
+    if (yesMode) {
+      accepted.push(p);
+      ok(`Accepted "${p.section.heading}"`);
+      log("");
+      continue;
+    }
+    const answer = (await confirm(`  Extract? [${GREEN}Y${RESET}/n/skip] `)).toLowerCase();
+    if (answer === "n" || answer === "skip") {
+      warn(`Skipped "${p.section.heading}"`);
+    } else {
+      accepted.push(p);
+      ok(`Accepted "${p.section.heading}"`);
+    }
+    log("");
+  }
+  if (accepted.length === 0) {
+    info("No sections accepted. Nothing to do.");
+    return;
+  }
+  const coreTokens = report.coreCandidate.reduce((sum, s) => sum + s.tokens_est, 0);
+  const index = generateIndex2(accepted, coreTokens, lazyLoad);
+  const newClaudeMd = generateClaudeMd(report.coreCandidate, accepted, index, rulesDir, lazyLoad);
+  if (dryRun) {
+    log(`${BOLD}Dry run complete.${RESET} Would generate:`);
+    log(`  ${accepted.length} rule files in ${rulesDir}/`);
+    log(`  ${rulesDir}/index.json`);
+    log(`  Rewritten ${filePath}`);
+    log("");
+    log(`${BOLD}New CLAUDE.md preview:${RESET}`);
+    log(DIM + "\u2500".repeat(60) + RESET);
+    log(newClaudeMd);
+    log(DIM + "\u2500".repeat(60) + RESET);
+    log("");
+    const after2 = estimateTokens(newClaudeMd);
+    log(`${BOLD}Budget:${RESET}`);
+    log(`  Before: ${report.totalLines} lines, ~${report.totalTokens} tokens (every session)`);
+    log(`  After:  ~${after2} tokens always loaded`);
+    log(`  Savings: ${report.totalTokens > 0 ? Math.round((report.totalTokens - after2) / report.totalTokens * 100) : 0}%`);
+    return;
+  }
+  const absRulesDir = resolve7(dirname5(filePath), "..", rulesDir);
+  const writes = [];
+  for (const p of accepted) {
+    writes.push({ dest: resolve7(dirname5(filePath), "..", p.suggestedPath), content: generateRuleFile(p) });
+  }
+  writes.push({ dest: resolve7(absRulesDir, "index.json"), content: JSON.stringify(index, null, 2) + "\n" });
+  writes.push({ dest: filePath, content: newClaudeMd });
+  const stagingDir = mkdtempSync(join5(tmpdir(), "loadout-os-split-"));
+  try {
+    for (let i = 0; i < writes.length; i++) {
+      writeFileSync2(join5(stagingDir, `file-${i}`), writes[i].content, "utf8");
+    }
+    const backupPath = resolve7(dirname5(filePath), "CLAUDE.md.bak");
+    copyFileSync(filePath, backupPath);
+    info(`Backed up ${relative2(process.cwd(), filePath)} \u2192 CLAUDE.md.bak`);
+    mkdirSync2(absRulesDir, { recursive: true });
+    for (const w of writes) mkdirSync2(dirname5(w.dest), { recursive: true });
+    for (let i = 0; i < writes.length; i++) {
+      try {
+        copyFileSync(join5(stagingDir, `file-${i}`), writes[i].dest);
+      } catch (copyErr) {
+        warn(`Split failed writing ${relative2(process.cwd(), writes[i].dest)}. Original CLAUDE.md backed up to CLAUDE.md.bak.`);
+        warn(`Error: ${copyErr.message}`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+    for (const p of accepted) ok(`${p.suggestedPath}`);
+    ok(`${rulesDir}/index.json`);
+    ok(`Rewrote ${relative2(process.cwd(), filePath)}`);
+  } finally {
+    try {
+      rmSync(stagingDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  const after = estimateTokens(newClaudeMd);
+  log("");
+  log(`${BOLD}Split complete.${RESET}`);
+  log(`  ${accepted.length} rule files created`);
+  log(`  Before: ${report.totalLines} lines, ~${report.totalTokens} tokens`);
+  log(`  After:  ~${after} tokens always loaded`);
+  log(`  Savings: ${report.totalTokens > 0 ? Math.round((report.totalTokens - after) / report.totalTokens * 100) : 0}%`);
+  log("");
+  info("Run 'loadout-os rules validate' to confirm invariants.");
+}
+function kernelResolve(args) {
+  const json = hasFlag(args, "json");
+  const result = resolveLoadout({
+    projectRoot: flagValue(args, "project"),
+    globalDir: flagValue(args, "global"),
+    orgPath: flagValue(args, "org"),
+    sessionPath: flagValue(args, "session")
+  });
+  if (json) {
+    log(
+      JSON.stringify(
+        {
+          layers: result.searched,
+          entries: result.merged.entries.map((e) => ({
+            id: e.id,
+            priority: e.priority,
+            tokens: e.tokens_est,
+            source: result.merged.provenance[e.id]
+          })),
+          conflicts: result.merged.conflicts,
+          budget: result.merged.budget
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  log(`
+${BOLD}Layer Discovery${RESET}
+`);
+  for (const s of result.searched) {
+    if (s.found) ok(`${s.name.padEnd(10)} ${DIM}${s.path}${RESET}`);
+    else if (s.malformed) warn(`${s.name.padEnd(10)} ${DIM}${s.path}${RESET} ${YELLOW}(malformed JSON \u2014 skipped)${RESET}`);
+    else log(`  ${DIM}\u2014${RESET} ${s.name.padEnd(10)} ${DIM}${s.path} (not found)${RESET}`);
+  }
+  if (result.layers.length === 0) {
+    log(`
+  ${YELLOW}No loadout indexes found.${RESET}
+`);
+    return;
+  }
+  log(`
+${BOLD}Resolved Entries${RESET} (${result.merged.entries.length} from ${result.layers.length} layer(s))
+`);
+  for (const e of result.merged.entries) {
+    const src = result.merged.provenance[e.id] ?? "?";
+    log(`  ${e.id.padEnd(30)} ${e.priority.padEnd(8)} ${String(e.tokens_est).padStart(6)}  ${src}`);
+  }
+  log("");
+}
+function kernelExplain(args) {
+  const pos = positionalArgs(args);
+  if (pos.length === 0) {
+    fail("MISSING_ARG", "Usage: loadout-os explain <entry-id>", "Run 'loadout-os resolve' to see entries.");
+  }
+  const entryId = pos[0];
+  const json = hasFlag(args, "json");
+  const { layers } = resolveLoadout({
+    projectRoot: flagValue(args, "project"),
+    globalDir: flagValue(args, "global"),
+    orgPath: flagValue(args, "org"),
+    sessionPath: flagValue(args, "session")
+  });
+  const explanation = explainEntry(entryId, layers);
+  if (!explanation) {
+    if (json) {
+      log(JSON.stringify({ error: "NOT_FOUND", entryId }, null, 2));
+      fail("NOT_FOUND", `Entry "${entryId}" not found in any layer`, void 0, 1);
+    }
+    fail("NOT_FOUND", `Entry "${entryId}" not found in any layer`, "Run 'loadout-os resolve' to see entries.");
+  }
+  if (json) {
+    log(JSON.stringify(explanation, null, 2));
+    return;
+  }
+  log(`
+${BOLD}Entry Explanation: ${CYAN}${explanation.id}${RESET}
+`);
+  log(`  Final layer: ${GREEN}${explanation.finalLayer}${RESET}`);
+  log(`  Override chain: ${explanation.overrideChain.join(" \u2192 ")}`);
+  for (const def of explanation.definitions) {
+    log(`  ${def.layer}: ${def.priority}, ${def.tokens} tokens \u2014 ${def.summary}`);
+  }
+  log("");
+}
+function kernelUsage(args) {
+  const pos = positionalArgs(args);
+  if (pos.length < 1) fail("MISSING_ARG", "Usage: loadout-os usage <jsonl>");
+  const jsonl = resolve7(pos[0]);
+  const json = hasFlag(args, "json");
+  const { events, skipped } = readUsageWithStats(jsonl);
+  if (events.length === 0) {
+    if (json) {
+      log("[]");
+      return;
+    }
+    info("No usage events found");
+    return;
+  }
+  const summary = summarizeUsage(events);
+  if (json) {
+    log(JSON.stringify(summary.map(summaryToJSON), null, 2));
+    return;
+  }
+  if (skipped > 0) warn(`Skipped ${skipped} malformed line(s)`);
+  log(`
+${BOLD}Usage Summary${RESET} (${events.length} events)
+`);
+  log(`  ${"Entry".padEnd(30)} ${"Loads".padStart(6)} ${"Tokens".padStart(8)}`);
+  for (const s of summary) {
+    log(`  ${s.entryId.padEnd(30)} ${String(s.loadCount).padStart(6)} ${String(s.totalTokens).padStart(8)}`);
+  }
+  log("");
+}
+function kernelDead(args) {
+  const pos = positionalArgs(args);
+  if (pos.length < 2) fail("MISSING_ARG", "Usage: loadout-os dead <index> <jsonl>");
+  const index = loadKernelIndex(pos[0]);
+  const events = readUsage(resolve7(pos[1]));
+  const dead = findDeadEntries(index, events);
+  const json = hasFlag(args, "json");
+  if (json) {
+    log(JSON.stringify(dead.map((d) => ({ id: d.entry.id, tokens: d.entry.tokens_est, reason: d.reason })), null, 2));
+    return;
+  }
+  if (dead.length === 0) {
+    ok("No dead entries \u2014 all entries loaded at least once");
+    return;
+  }
+  log(`
+${BOLD}Dead Entries${RESET} (${dead.length} never loaded)
+`);
+  let wasted = 0;
+  for (const d of dead) {
+    warn(`${d.entry.id} (${d.entry.tokens_est} tokens)`);
+    wasted += d.entry.tokens_est;
+  }
+  log(`
+  ${RED}${wasted.toLocaleString()} tokens${RESET} in entries never loaded
+`);
+}
+function kernelOverlaps(args) {
+  const pos = positionalArgs(args);
+  if (pos.length < 1) fail("MISSING_ARG", "Usage: loadout-os overlaps <index>");
+  const index = loadKernelIndex(pos[0]);
+  const overlaps = findKeywordOverlaps(index);
+  const json = hasFlag(args, "json");
+  if (json) {
+    log(JSON.stringify(overlaps, null, 2));
+    return;
+  }
+  if (overlaps.length === 0) {
+    ok("No keyword overlaps \u2014 routing is unambiguous");
+    return;
+  }
+  log(`
+${BOLD}Keyword Overlaps${RESET} (${overlaps.length})
+`);
+  for (const o of overlaps) log(`  ${YELLOW}${o.keyword}${RESET} \u2192 ${o.entries.join(", ")}`);
+  log("");
+}
+function kernelBudget(args) {
+  const pos = positionalArgs(args);
+  if (pos.length < 1) fail("MISSING_ARG", "Usage: loadout-os budget <index> [jsonl]");
+  const index = loadKernelIndex(pos[0]);
+  const usage = pos.length >= 2 ? summarizeUsage(readUsage(resolve7(pos[1]))) : void 0;
+  const breakdown = analyzeBudget(index, usage);
+  const json = hasFlag(args, "json");
+  if (json) {
+    log(JSON.stringify(breakdown, null, 2));
+    return;
+  }
+  log(`
+${BOLD}Token Budget Breakdown${RESET}
+`);
+  log(`  Total:  ${breakdown.totalTokens.toLocaleString()} tokens`);
+  log(`  Core:   ${breakdown.coreTokens.toLocaleString()} (${breakdown.coreEntries}) \xB7 Domain: ${breakdown.domainTokens.toLocaleString()} (${breakdown.domainEntries}) \xB7 Manual: ${breakdown.manualTokens.toLocaleString()} (${breakdown.manualEntries})`);
+  if (breakdown.observedAvg !== null) log(`  ${GREEN}Observed avg load:${RESET} ${breakdown.observedAvg.toLocaleString()} tokens/load`);
+  log("");
+}
+function kernelValidate(args) {
+  const pos = positionalArgs(args);
+  if (pos.length < 1) fail("MISSING_ARG", "Usage: loadout-os validate <index>");
+  const index = loadKernelIndex(pos[0]);
+  const issues = validateIndex(index);
+  const json = hasFlag(args, "json");
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
+  if (json) {
+    log(JSON.stringify({ valid: errors.length === 0, errors: errors.length, warnings: warnings.length, issues }, null, 2));
+    if (errors.length > 0) fail("VALIDATION_FAILED", `${errors.length} error(s)`, void 0, 1);
+    return;
+  }
+  if (issues.length === 0) {
+    ok(`Index is valid (${index.entries.length} entries)`);
+    return;
+  }
+  log(`
+${BOLD}Validation Results${RESET}
+`);
+  for (const i of errors) {
+    log(`  ${RED}\u2717 [${i.code}]${RESET} ${i.message}`);
+    if (i.hint) log(`    ${DIM}${i.hint}${RESET}`);
+  }
+  for (const i of warnings) warn(`[${i.code}] ${i.message}`);
+  log(`
+  ${errors.length} error(s), ${warnings.length} warning(s)`);
+  if (errors.length > 0) fail("VALIDATION_FAILED", `${errors.length} error(s)`, void 0, 1);
+}
+
+// src/doctor.ts
+import { readFileSync as readFileSync10, existsSync as existsSync9, statSync as statSync3 } from "node:fs";
+import { createHash } from "node:crypto";
+import { join as join6, resolve as resolve8 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+var RECENT_MS = 7 * 24 * 60 * 60 * 1e3;
+function defaultDoctorPaths(repoRoot = process.cwd()) {
+  const home = homedir2();
+  return {
+    store: resolve8(home, ".claude", "projects", "F--AI", "memory"),
+    index: resolve8(home, ".ai-loadout", "index.json"),
+    settings: resolve8(home, ".claude", "settings.json"),
+    usage: resolve8(home, ".ai-loadout", "usage.jsonl"),
+    hookSource: resolve8(repoRoot, "apps", "hook", "loadout-hook.mjs"),
+    hookMirror: resolve8(home, ".claude", "loadout-hook", "loadout-hook.mjs")
+  };
+}
+function sha256(path) {
+  return createHash("sha256").update(readFileSync10(path)).digest("hex");
+}
+function loadIndex(path) {
+  if (!existsSync9(path)) {
+    return {
+      check: {
+        id: "index-parse",
+        status: "fail",
+        message: `Global index not found: ${path}`,
+        hint: "Run the Index Freshness Ritual (loadout-os refresh, once implemented) to generate it."
+      }
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync10(path, "utf-8"));
+  } catch (e) {
+    return {
+      check: {
+        id: "index-parse",
+        status: "fail",
+        message: `Global index is not valid JSON: ${path}`,
+        hint: e.message
+      }
+    };
+  }
+  if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.entries)) {
+    return {
+      check: {
+        id: "index-parse",
+        status: "fail",
+        message: `Global index parsed but has no entries[] array: ${path}`,
+        hint: "Regenerate the index from the store."
+      }
+    };
+  }
+  return { index: parsed };
+}
+function runDoctor(paths) {
+  const checks = [];
+  const memoryMd = join6(paths.store, "MEMORY.md");
+  if (!existsSync9(memoryMd)) {
+    checks.push({
+      id: "store-validates",
+      status: "fail",
+      message: `Store MEMORY.md not found: ${memoryMd}`,
+      hint: "Point --store at the directory containing MEMORY.md."
+    });
+  } else {
+    try {
+      const analysis = analyzeMemoryMd(memoryMd);
+      const issues = validateMemory(analysis);
+      const errors = issues.filter((i) => i.severity === "error").length;
+      const warnings = issues.filter((i) => i.severity === "warning").length;
+      if (errors > 0) {
+        checks.push({
+          id: "store-validates",
+          status: "fail",
+          message: `Store MEMORY.md has ${errors} error(s), ${warnings} warning(s)`,
+          hint: "Run `loadout-os memories validate <MEMORY.md>` for detail."
+        });
+      } else if (warnings > 0) {
+        checks.push({
+          id: "store-validates",
+          status: "warn",
+          message: `Store MEMORY.md valid (0 errors) with ${warnings} warning(s)`,
+          hint: "Run `loadout-os memories validate <MEMORY.md>` for detail."
+        });
+      } else {
+        checks.push({
+          id: "store-validates",
+          status: "pass",
+          message: `Store MEMORY.md validates (0 errors, ${analysis.refs.length} refs)`
+        });
+      }
+    } catch (e) {
+      checks.push({
+        id: "store-validates",
+        status: "fail",
+        message: `Could not analyze store MEMORY.md: ${e.message}`
+      });
+    }
+  }
+  const loaded = loadIndex(paths.index);
+  let index = null;
+  if ("check" in loaded) {
+    checks.push(loaded.check);
+  } else {
+    index = loaded.index;
+    const issues = validateIndex(index);
+    const errors = issues.filter((i) => i.severity === "error").length;
+    const warnings = issues.filter((i) => i.severity === "warning").length;
+    if (errors > 0) {
+      checks.push({
+        id: "index-parse",
+        status: "fail",
+        message: `Global index has ${errors} structural error(s), ${warnings} warning(s)`,
+        hint: "Run `loadout-os validate <index>` for detail."
+      });
+    } else if (warnings > 0) {
+      checks.push({
+        id: "index-parse",
+        status: "warn",
+        message: `Global index valid (0 errors) with ${warnings} warning(s), ${index.entries.length} entries`
+      });
+    } else {
+      checks.push({
+        id: "index-parse",
+        status: "pass",
+        message: `Global index parses + validates (${index.entries.length} entries)`
+      });
+    }
+  }
+  if (!existsSync9(paths.hookSource)) {
+    checks.push({
+      id: "hook-drift",
+      status: "warn",
+      message: `Hook source not found: ${paths.hookSource}`,
+      hint: "Expected apps/hook/loadout-hook.mjs in the repo."
+    });
+  } else if (!existsSync9(paths.hookMirror)) {
+    checks.push({
+      id: "hook-drift",
+      status: "warn",
+      message: `Hook mirror not installed: ${paths.hookMirror}`,
+      hint: "The runtime hook has not been copied to ~/.claude/loadout-hook/ yet."
+    });
+  } else {
+    try {
+      const a = sha256(paths.hookSource);
+      const b = sha256(paths.hookMirror);
+      if (a === b) {
+        checks.push({
+          id: "hook-drift",
+          status: "pass",
+          message: "Hook mirror matches repo source (no drift)"
+        });
+      } else {
+        checks.push({
+          id: "hook-drift",
+          status: "fail",
+          message: "Hook mirror DRIFTS from repo source",
+          hint: "Re-copy apps/hook/loadout-hook.mjs to ~/.claude/loadout-hook/ (the live hook is stale)."
+        });
+      }
+    } catch (e) {
+      checks.push({
+        id: "hook-drift",
+        status: "warn",
+        message: `Could not hash hook files: ${e.message}`
+      });
+    }
+  }
+  try {
+    const { searched } = discoverLayers({
+      globalDir: paths.index.replace(/[/\\]index\.json$/, "")
+    });
+    const malformed = searched.filter((s) => s.malformed);
+    if (malformed.length > 0) {
+      checks.push({
+        id: "layers-malformed",
+        status: "fail",
+        message: `${malformed.length} layer(s) present but malformed: ${malformed.map((m) => m.name).join(", ")}`,
+        hint: "Fix or remove the corrupt index file(s) listed."
+      });
+    } else {
+      checks.push({
+        id: "layers-malformed",
+        status: "pass",
+        message: "No malformed layers in the resolver search path"
+      });
+    }
+  } catch (e) {
+    checks.push({
+      id: "layers-malformed",
+      status: "warn",
+      message: `Could not discover layers: ${e.message}`
+    });
+  }
+  if (index) {
+    const coreCount = index.entries.filter((e) => e.priority === "core").length;
+    if (coreCount === 0) {
+      checks.push({
+        id: "core-entries",
+        status: "warn",
+        message: "Index has 0 core entries \u2014 nothing is always-loaded",
+        hint: "Confirm this is intentional; most stores expect at least one core entry."
+      });
+    } else {
+      checks.push({
+        id: "core-entries",
+        status: "pass",
+        message: `${coreCount} core entr${coreCount === 1 ? "y" : "ies"} present`
+      });
+    }
+  } else {
+    checks.push({
+      id: "core-entries",
+      status: "warn",
+      message: "Skipped core-entries check (no readable index)"
+    });
+  }
+  if (index) {
+    const observed = index.budget?.avg_task_load_observed ?? null;
+    if (observed === null) {
+      checks.push({
+        id: "observability-loop",
+        status: "warn",
+        message: "Observability loop not wired (budget.avg_task_load_observed is null)",
+        hint: "Run `loadout-os report` once usage.jsonl has data, then fold the observed average back into the index."
+      });
+    } else {
+      checks.push({
+        id: "observability-loop",
+        status: "pass",
+        message: `Observed avg task load recorded: ${observed} tokens`
+      });
+    }
+  } else {
+    checks.push({
+      id: "observability-loop",
+      status: "warn",
+      message: "Skipped observability check (no readable index)"
+    });
+  }
+  if (!existsSync9(paths.settings)) {
+    checks.push({
+      id: "hook-wired",
+      status: "warn",
+      message: `settings.json not found: ${paths.settings}`,
+      hint: "Wire the UserPromptSubmit hook in ~/.claude/settings.json."
+    });
+  } else {
+    try {
+      const raw = readFileSync10(paths.settings, "utf-8");
+      if (/loadout-hook/.test(raw)) {
+        checks.push({
+          id: "hook-wired",
+          status: "pass",
+          message: "Hook wired in settings.json (loadout-hook command found)"
+        });
+      } else {
+        checks.push({
+          id: "hook-wired",
+          status: "fail",
+          message: "Hook NOT wired in settings.json (no loadout-hook command)",
+          hint: "Add a UserPromptSubmit hook that runs the loadout-hook entrypoint."
+        });
+      }
+    } catch (e) {
+      checks.push({
+        id: "hook-wired",
+        status: "warn",
+        message: `Could not read settings.json: ${e.message}`
+      });
+    }
+  }
+  if (!existsSync9(paths.usage)) {
+    checks.push({
+      id: "usage-growing",
+      status: "warn",
+      message: `usage.jsonl not found: ${paths.usage}`,
+      hint: "The hook writes this on first injected prompt; nothing has been recorded yet."
+    });
+  } else {
+    try {
+      const st = statSync3(paths.usage);
+      if (st.size === 0) {
+        checks.push({
+          id: "usage-growing",
+          status: "warn",
+          message: "usage.jsonl exists but is empty",
+          hint: "The hook has not injected any pointers yet."
+        });
+      } else {
+        const ageMs = Date.now() - st.mtimeMs;
+        if (ageMs > RECENT_MS) {
+          const days = Math.round(ageMs / (24 * 60 * 60 * 1e3));
+          checks.push({
+            id: "usage-growing",
+            status: "warn",
+            message: `usage.jsonl is stale (last write ${days} day(s) ago)`,
+            hint: "The hook may not be firing; check that it is wired and not disabled (AI_LOADOUT_HOOK)."
+          });
+        } else {
+          checks.push({
+            id: "usage-growing",
+            status: "pass",
+            message: `usage.jsonl is growing (${st.size.toLocaleString()} bytes, recent)`
+          });
+        }
+      }
+    } catch (e) {
+      checks.push({
+        id: "usage-growing",
+        status: "warn",
+        message: `Could not stat usage.jsonl: ${e.message}`
+      });
+    }
+  }
+  const ok3 = !checks.some((c) => c.status === "fail");
+  return { checks, ok: ok3 };
+}
+function printDoctor(result, paths) {
+  log();
+  log(`${BOLD}loadout-os doctor${RESET} ${DIM}\u2014 read-only health screen${RESET}`);
+  log();
+  log(`  ${DIM}store:    ${paths.store}${RESET}`);
+  log(`  ${DIM}index:    ${paths.index}${RESET}`);
+  log(`  ${DIM}settings: ${paths.settings}${RESET}`);
+  log(`  ${DIM}usage:    ${paths.usage}${RESET}`);
+  log();
+  for (const c of result.checks) {
+    const glyph = c.status === "pass" ? `${GREEN}\u2713${RESET}` : c.status === "warn" ? `${YELLOW}!${RESET}` : `${RED}\u2717${RESET}`;
+    log(`  ${glyph} ${c.message} ${DIM}[${c.id}]${RESET}`);
+    if (c.hint && c.status !== "pass") {
+      log(`      ${DIM}${c.hint}${RESET}`);
+    }
+  }
+  const fails = result.checks.filter((c) => c.status === "fail").length;
+  const warns = result.checks.filter((c) => c.status === "warn").length;
+  const passes = result.checks.filter((c) => c.status === "pass").length;
+  log();
+  log(
+    `  ${passes} pass, ${warns > 0 ? YELLOW : DIM}${warns} warn${RESET}, ${fails > 0 ? RED : DIM}${fails} fail${RESET} \u2014 ${result.ok ? `${GREEN}healthy${RESET}` : `${RED}needs attention${RESET}`}`
+  );
+  log();
+}
+
+// src/report.ts
+import { readFileSync as readFileSync11, existsSync as existsSync10 } from "node:fs";
+function buildScoreDistribution(events) {
+  const scored = events.filter(
+    (e) => typeof e.score === "number"
+  );
+  if (scored.length === 0) return null;
+  const buckets = [];
+  for (let lo = 0; lo < 10; lo++) {
+    const a = lo / 10;
+    const b = (lo + 1) / 10;
+    buckets.push({ label: `${a.toFixed(1)}\u2013${b.toFixed(1)}`, count: 0 });
+  }
+  for (const e of scored) {
+    let idx = Math.floor(e.score * 10);
+    if (idx < 0) idx = 0;
+    if (idx > 9) idx = 9;
+    buckets[idx].count++;
+  }
+  return buckets;
+}
+function loadIndex2(path) {
+  if (!existsSync10(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync11(path, "utf-8"));
+    if (!parsed || !Array.isArray(parsed.entries)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function buildReport(indexPath, usagePath) {
+  const base = {
+    inputs: { index: indexPath, usage: usagePath }
+  };
+  if (!existsSync10(usagePath)) {
+    return {
+      ...base,
+      events: 0,
+      skipped: 0,
+      usage: [],
+      dead: [],
+      budget: emptyBudget(),
+      scoreDistribution: null,
+      ok: false,
+      error: {
+        code: "USAGE_NOT_FOUND",
+        message: `Usage log not found: ${usagePath}`
+      }
+    };
+  }
+  const index = loadIndex2(indexPath);
+  if (!index) {
+    return {
+      ...base,
+      events: 0,
+      skipped: 0,
+      usage: [],
+      dead: [],
+      budget: emptyBudget(),
+      scoreDistribution: null,
+      ok: false,
+      error: {
+        code: "INDEX_NOT_FOUND",
+        message: `Global index missing or unreadable: ${indexPath}`
+      }
+    };
+  }
+  const { events, skipped } = readUsageWithStats(usagePath);
+  const summaries = summarizeUsage(events);
+  const dead = findDeadEntries(index, events);
+  const budget = analyzeBudget(index, summaries);
+  const scoreDistribution = buildScoreDistribution(events);
+  return {
+    ...base,
+    events: events.length,
+    skipped,
+    usage: summaries.map(summaryToJSON),
+    dead: dead.map((d) => ({
+      id: d.entry.id,
+      tokens: d.entry.tokens_est,
+      reason: d.reason
+    })),
+    budget,
+    scoreDistribution,
+    ok: true
+  };
+}
+function emptyBudget() {
+  return {
+    totalTokens: 0,
+    coreTokens: 0,
+    domainTokens: 0,
+    manualTokens: 0,
+    coreEntries: 0,
+    domainEntries: 0,
+    manualEntries: 0,
+    avgDomainSize: 0,
+    largestEntry: null,
+    smallestEntry: null,
+    observedAvg: null
+  };
+}
+function printReport(r) {
+  log();
+  log(`${BOLD}loadout-os report${RESET} ${DIM}\u2014 observability over usage.jsonl${RESET}`);
+  log(`  ${DIM}index: ${r.inputs.index}${RESET}`);
+  log(`  ${DIM}usage: ${r.inputs.usage}${RESET}`);
+  log();
+  if (r.skipped > 0) {
+    log(`  ${YELLOW}!${RESET} skipped ${r.skipped} malformed usage line(s)`);
+  }
+  log(`${BOLD}Loaded entries${RESET} (${r.events} events, ${r.usage.length} distinct)`);
+  if (r.usage.length === 0) {
+    log(`  ${DIM}(no usage events recorded)${RESET}`);
+  } else {
+    log(`  ${"Entry".padEnd(36)} ${"Loads".padStart(6)} ${"Tokens".padStart(8)}`);
+    for (const s of r.usage.slice(0, 10)) {
+      log(
+        `  ${s.entryId.slice(0, 36).padEnd(36)} ${String(s.loadCount).padStart(6)} ${String(s.totalTokens).padStart(8)}`
+      );
+    }
+  }
+  log();
+  log(`${BOLD}Dead entries${RESET} (${r.dead.length} never loaded)`);
+  if (r.dead.length === 0) {
+    log(`  ${GREEN}\u2713${RESET} every non-core entry has been loaded at least once`);
+  } else {
+    let wasted = 0;
+    for (const d of r.dead.slice(0, 15)) {
+      log(`  ${YELLOW}!${RESET} ${d.id} ${DIM}(${d.tokens} tokens)${RESET}`);
+      wasted += d.tokens;
+    }
+    if (r.dead.length > 15) log(`  ${DIM}\u2026 and ${r.dead.length - 15} more${RESET}`);
+    log(`  ${RED}${wasted.toLocaleString()} tokens${RESET} in never-loaded entries`);
+  }
+  log();
+  const b = r.budget;
+  log(`${BOLD}Budget${RESET}`);
+  log(`  Total:  ${b.totalTokens.toLocaleString()} tokens`);
+  log(`  Core:   ${b.coreTokens.toLocaleString()} (${b.coreEntries}) \xB7 Domain: ${b.domainTokens.toLocaleString()} (${b.domainEntries}) \xB7 Manual: ${b.manualTokens.toLocaleString()} (${b.manualEntries})`);
+  if (b.observedAvg !== null) {
+    log(`  ${GREEN}Observed avg load:${RESET} ${b.observedAvg.toLocaleString()} tokens/load`);
+  }
+  log();
+  if (r.scoreDistribution) {
+    log(`${BOLD}Score distribution${RESET} ${DIM}(injected events)${RESET}`);
+    const max = Math.max(1, ...r.scoreDistribution.map((s) => s.count));
+    for (const bkt of r.scoreDistribution) {
+      const barLen = Math.round(bkt.count / max * 30);
+      log(`  ${CYAN}${bkt.label}${RESET} ${"\u2588".repeat(barLen)} ${DIM}${bkt.count}${RESET}`);
+    }
+    log();
+  }
+}
+
+// src/hook.ts
+import { spawnSync } from "node:child_process";
+import {
+  existsSync as existsSync11,
+  mkdtempSync as mkdtempSync2,
+  mkdirSync as mkdirSync3,
+  copyFileSync as copyFileSync2,
+  rmSync as rmSync2
+} from "node:fs";
+import { join as join7, resolve as resolve9, dirname as dirname6 } from "node:path";
+import { tmpdir as tmpdir2, homedir as homedir3 } from "node:os";
+var DEFAULT_PROMPT = "How do I run the dogfood swarm and full-treatment on a repo before npm publish?";
+function defaultHookPath(repoRoot = process.cwd()) {
+  return resolve9(repoRoot, "apps", "hook", "loadout-hook.mjs");
+}
+function runHookTest(opts) {
+  const prompt = opts.prompt || DEFAULT_PROMPT;
+  const hookPath = opts.hookPath;
+  const liveIndex = opts.liveIndex ?? join7(homedir3(), ".ai-loadout", "index.json");
+  if (!existsSync11(hookPath)) {
+    return {
+      ran: false,
+      exitCode: null,
+      stdout: "",
+      stderr: "",
+      injected: false,
+      additionalContext: null,
+      note: `hook test runs from the loadout-os repo; apps/hook not found (${hookPath}). Clone/run from the repo to exercise the runtime hook.`
+    };
+  }
+  const sandbox = mkdtempSync2(join7(tmpdir2(), "loadout-hook-test-"));
+  try {
+    const sandboxAiLoadout = join7(sandbox, ".ai-loadout");
+    mkdirSync3(sandboxAiLoadout, { recursive: true });
+    let indexCopied = false;
+    if (existsSync11(liveIndex)) {
+      copyFileSync2(liveIndex, join7(sandboxAiLoadout, "index.json"));
+      indexCopied = true;
+    }
+    const payload = JSON.stringify({
+      prompt,
+      session_id: "loadout-os-hook-test"
+    });
+    const env = {
+      ...process.env,
+      HOME: sandbox,
+      USERPROFILE: sandbox
+    };
+    const res = spawnSync(process.execPath, [hookPath], {
+      input: payload,
+      env,
+      encoding: "utf-8",
+      cwd: dirname6(hookPath)
+    });
+    const stdout = res.stdout ?? "";
+    const stderr = res.stderr ?? "";
+    let injected = false;
+    let additionalContext = null;
+    if (stdout.trim()) {
+      try {
+        const parsed = JSON.parse(stdout);
+        additionalContext = parsed?.hookSpecificOutput?.additionalContext ?? null;
+        injected = !!additionalContext;
+      } catch {
+      }
+    }
+    const note = indexCopied ? "Ran against an isolated copy of the live index (usage.jsonl write sandboxed)." : `No live index at ${liveIndex} \u2014 hook ran but had nothing to match (expected silent).`;
+    return {
+      ran: true,
+      exitCode: res.status,
+      stdout,
+      stderr,
+      injected,
+      additionalContext,
+      note
+    };
+  } finally {
+    try {
+      rmSync2(sandbox, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function printHookTest(prompt, r) {
+  log();
+  log(`${BOLD}loadout-os hook test${RESET}`);
+  log(`  ${DIM}prompt:${RESET} ${CYAN}${prompt}${RESET}`);
+  log();
+  if (!r.ran) {
+    warn(r.note);
+    return;
+  }
+  info(r.note);
+  log(`  ${DIM}exit code: ${r.exitCode}${RESET}`);
+  log();
+  if (r.injected && r.additionalContext) {
+    ok("Hook injected pointers:");
+    for (const line of r.additionalContext.split("\n")) {
+      log(`    ${line}`);
+    }
+  } else {
+    log(`  ${YELLOW}!${RESET} Hook was silent (no pointer met the score floor for this prompt).`);
+    if (r.stderr.trim()) {
+      log(`  ${DIM}stderr:${RESET}`);
+      for (const line of r.stderr.split("\n")) {
+        if (line.trim()) log(`    ${DIM}${line}${RESET}`);
+      }
+    }
+  }
+  log();
+}
+
+// src/refresh.ts
+import {
+  writeFileSync as writeFileSync3,
+  existsSync as existsSync12,
+  statSync as statSync4,
+  copyFileSync as copyFileSync3,
+  mkdirSync as mkdirSync4
+} from "node:fs";
+import { dirname as dirname7, isAbsolute, join as join8, resolve as resolve10 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+var DEFAULT_STORE = "C:/Users/mikey/.claude/projects/F--AI/memory";
+function defaultDest() {
+  return join8(homedir4(), ".ai-loadout", "index.json");
+}
+var RefreshError = class extends Error {
+  code;
+  exitCode;
+  issues;
+  constructor(code, message, exitCode, issues) {
+    super(message);
+    this.name = "RefreshError";
+    this.code = code;
+    this.exitCode = exitCode;
+    this.issues = issues;
+  }
+};
+function rewritePathsAbsolute(index, storeRoot, memoryMd) {
+  let pathsRewritten = 0;
+  const entries = index.entries.map((e) => {
+    if (isAbsolute(e.path)) return { ...e };
+    pathsRewritten++;
+    return { ...e, path: resolve10(storeRoot, e.path) };
+  });
+  return {
+    index: { ...index, entries, source: memoryMd },
+    pathsRewritten
+  };
+}
+function runRefresh(opts) {
+  const store = resolve10(opts.store ?? DEFAULT_STORE);
+  const dest = resolve10(opts.dest ?? defaultDest());
+  const dryRun = !!opts.dryRun;
+  const memoryMd = join8(store, "MEMORY.md");
+  if (!existsSync12(store) || !statSync4(store).isDirectory()) {
+    throw new RefreshError(
+      "STORE_NOT_FOUND",
+      `Store directory not found: ${store}`,
+      2
+    );
+  }
+  if (!existsSync12(memoryMd)) {
+    throw new RefreshError(
+      "MEMORY_MD_NOT_FOUND",
+      `MEMORY.md not found in store: ${memoryMd}`,
+      2
+    );
+  }
+  const analysis = analyzeMemoryMd(memoryMd);
+  const storeIndex = generateIndex(analysis);
+  const storeIndexPath = join8(store, "index.json");
+  const gate = [
+    ...validateMemory(analysis),
+    ...validateMemoryIndex(storeIndex)
+  ];
+  const gateErrors = gate.filter((i) => i.severity === "error");
+  const gateWarnings = gate.filter((i) => i.severity === "warning");
+  if (gateErrors.length > 0) {
+    throw new RefreshError(
+      "VALIDATION_FAILED",
+      `${gateErrors.length} validation error(s) \u2014 halting, nothing written`,
+      1,
+      gateErrors
+    );
+  }
+  const { index: rewritten, pathsRewritten } = rewritePathsAbsolute(
+    storeIndex,
+    store,
+    memoryMd
+  );
+  const destJson = JSON.stringify(rewritten, null, 2) + "\n";
+  const storeJson = JSON.stringify(storeIndex, null, 2) + "\n";
+  const destIssues = validateIndex(rewritten);
+  if (dryRun) {
+    return {
+      store,
+      memoryMd,
+      storeIndexPath,
+      dest,
+      dryRun: true,
+      entryCount: rewritten.entries.length,
+      pathsRewritten,
+      gateErrors,
+      gateWarnings,
+      destIssues,
+      backupPath: null,
+      wrote: false
+    };
+  }
+  writeFileSync3(storeIndexPath, storeJson, "utf-8");
+  let backupPath = null;
+  if (existsSync12(dest)) {
+    backupPath = `${dest}.bak`;
+    copyFileSync3(dest, backupPath);
+  }
+  try {
+    const destDir = dirname7(dest);
+    if (!existsSync12(destDir)) mkdirSync4(destDir, { recursive: true });
+    writeFileSync3(dest, destJson, "utf-8");
+  } catch (e) {
+    if (backupPath && existsSync12(backupPath)) {
+      try {
+        copyFileSync3(backupPath, dest);
+      } catch {
+      }
+    }
+    if (e instanceof RefreshError) throw e;
+    throw new RefreshError(
+      "WRITE_FAILED",
+      `Failed to write dest (${dest}): ${e.message}${backupPath ? ` \u2014 restored from ${backupPath}` : ""}`,
+      1
+    );
+  }
+  return {
+    store,
+    memoryMd,
+    storeIndexPath,
+    dest,
+    dryRun: false,
+    entryCount: rewritten.entries.length,
+    pathsRewritten,
+    gateErrors,
+    gateWarnings,
+    destIssues,
+    backupPath,
+    wrote: true
+  };
+}
+function printRefresh(r) {
+  log();
+  log(`${BOLD}loadout-os refresh${RESET} ${DIM}\u2014 Index Freshness Ritual${RESET}`);
+  log(`  ${DIM}store: ${r.store}${RESET}`);
+  log(`  ${DIM}dest:  ${r.dest}${RESET}`);
+  log();
+  if (r.dryRun) {
+    info(`${BOLD}--dry-run${RESET} \u2014 nothing was written.`);
+    log(
+      `  ${CYAN}Would write${RESET} ${r.storeIndexPath} and ${r.dest}: ${r.entryCount} entr${r.entryCount === 1 ? "y" : "ies"}, ${r.pathsRewritten} relative path(s) \u2192 absolute.`
+    );
+    if (existsSync12(r.dest)) {
+      log(`  ${DIM}A live dest exists; a real run would back it up to ${r.dest}.bak first.${RESET}`);
+    } else {
+      log(`  ${DIM}No live dest yet; a real run would create it (no backup needed).${RESET}`);
+    }
+    if (r.gateWarnings.length > 0) warn(`${r.gateWarnings.length} validation warning(s) (non-blocking).`);
+    log();
+    return;
+  }
+  ok(`Wrote store index: ${r.storeIndexPath}`);
+  ok(`Wrote global index: ${r.dest} (${r.entryCount} entries, ${r.pathsRewritten} paths \u2192 absolute)`);
+  if (r.backupPath) {
+    log(`  ${DIM}compensator: backed up previous dest \u2192 ${r.backupPath}${RESET}`);
+    log(`  ${DIM}undo: copy ${r.backupPath} back over ${r.dest}${RESET}`);
+  } else {
+    log(`  ${DIM}compensator: no prior dest existed; nothing to back up (undo = delete ${r.dest})${RESET}`);
+  }
+  if (r.gateWarnings.length > 0) {
+    warn(`${r.gateWarnings.length} validation warning(s) (non-blocking):`);
+    for (const i of r.gateWarnings) log(`    ${YELLOW}![${i.code}]${RESET} ${i.message}`);
+  }
+  if (r.destIssues.length > 0) {
+    const errs = r.destIssues.filter((i) => i.severity === "error");
+    const wrns = r.destIssues.filter((i) => i.severity === "warning");
+    if (errs.length > 0) {
+      warn(`dest re-validation found ${errs.length} structural error(s) (reported, not blocking):`);
+      for (const i of errs) log(`    ${RED}\u2717[${i.code}]${RESET} ${i.message}`);
+    }
+    if (wrns.length > 0) {
+      for (const i of wrns) log(`    ${DIM}![${i.code}] ${i.message}${RESET}`);
+    }
+  }
+  log();
+  log(
+    `  ${DIM}Note: this scratch/CLI run wrote the configured --dest. A LIVE run against the canonical store + ~/.ai-loadout is deferred to a coordinator-supervised step.${RESET}`
+  );
+  log();
+}
+function printRefreshAndon(issues) {
+  log();
+  log(`${RED}${BOLD}loadout-os refresh \u2014 ANDON HALT${RESET}`);
+  log(`  ${DIM}validation failed; nothing was written downstream.${RESET}`);
+  log();
+  for (const i of issues) {
+    log(`  ${RED}\u2717 [${i.code}]${RESET} ${i.message}`);
+    if (i.hint) log(`    ${DIM}${i.hint}${RESET}`);
+  }
+  log();
+}
+function dispatchRefresh(args) {
+  const store = flagValue(args, "store") ?? DEFAULT_STORE;
+  const dest = flagValue(args, "dest") ?? defaultDest();
+  const dryRun = hasFlag(args, "dry-run");
+  try {
+    const result = runRefresh({ store, dest, dryRun });
+    printRefresh(result);
+  } catch (e) {
+    if (e instanceof RefreshError) {
+      if (e.code === "VALIDATION_FAILED" && e.issues) {
+        printRefreshAndon(e.issues);
+      } else {
+        log();
+        log(`  ${RED}\u2717 [${e.code}]${RESET} ${e.message}`);
+        log();
+      }
+      fail(e.code, e.message, void 0, e.exitCode);
+    }
+    throw e;
+  }
+}
+
+// src/help.ts
+function wantsHelp(args) {
+  return hasFlag(args, "help") || args.includes("-h");
+}
+var COMMAND_HELP = {
+  // ── memories namespace ───────────────────────────────────────
+  "memories index": {
+    synopsis: "loadout-os memories index <MEMORY.md> [--lazy] [--json]",
+    args: [["<MEMORY.md>", "path to the store's MEMORY.md (required, first)"]],
+    flags: [
+      ["--lazy", "generate a lazy-load index (on-demand topic loading)"],
+      ["--json", "machine-readable output"]
+    ],
+    example: "loadout-os memories index ~/.claude/projects/F--AI/memory/MEMORY.md",
+    exits: [["0", "index generated"], ["1", "MEMORY.md missing / unreadable"]]
+  },
+  "memories validate": {
+    synopsis: "loadout-os memories validate <MEMORY.md> [--json]",
+    args: [["<MEMORY.md>", "path to MEMORY.md to lint (required, first)"]],
+    flags: [["--json", "machine-readable output"]],
+    example: "loadout-os memories validate ./MEMORY.md",
+    exits: [["0", "no errors (warnings allowed)"], ["1", "\u22651 error-severity issue"]]
+  },
+  "memories stats": {
+    synopsis: "loadout-os memories stats <MEMORY.md> [--json]",
+    args: [["<MEMORY.md>", "path to MEMORY.md (required, first)"]],
+    flags: [["--json", "machine-readable output"]],
+    example: "loadout-os memories stats ./MEMORY.md --json",
+    exits: [["0", "stats printed"], ["1", "MEMORY.md missing"]]
+  },
+  "memories health": {
+    synopsis: "loadout-os memories health [path] [--json]",
+    args: [["[path]", "optional MEMORY.md path to probe (else auto-detects)"]],
+    flags: [["--json", "machine-readable output"]],
+    example: "loadout-os memories health",
+    exits: [["0", "Node OK"], ["1", "Node < 20"]]
+  },
+  // ── rules namespace ──────────────────────────────────────────
+  "rules analyze": {
+    synopsis: "loadout-os rules analyze <CLAUDE.md> [--rules-dir <dir>] [--json]",
+    args: [["<CLAUDE.md>", "instruction file to analyze (required, first)"]],
+    flags: [
+      ["--rules-dir <dir>", "rules directory (default .claude/rules)"],
+      ["--json", "machine-readable output"]
+    ],
+    example: "loadout-os rules analyze .claude/CLAUDE.md",
+    exits: [["0", "analysis printed"], ["1", "CLAUDE.md missing"]]
+  },
+  "rules validate": {
+    synopsis: "loadout-os rules validate [--rules-dir <dir>] [--lazy] [--repo-root <dir>] [--json]",
+    flags: [
+      ["--rules-dir <dir>", "rules directory (default .claude/rules, or .claude/loadout with --lazy)"],
+      ["--lazy", "validate a lazy-load layout"],
+      ["--repo-root <dir>", "repo root the rule paths resolve against (default cwd)"],
+      ["--json", "machine-readable output"]
+    ],
+    example: "loadout-os rules validate --rules-dir .claude/rules",
+    exits: [["0", "no errors"], ["1", "\u22651 error-severity issue"]]
+  },
+  "rules stats": {
+    synopsis: "loadout-os rules stats <CLAUDE.md> [--rules-dir <dir>] [--json]",
+    args: [["<CLAUDE.md>", "instruction file (required, first)"]],
+    flags: [
+      ["--rules-dir <dir>", "rules directory (default .claude/rules)"],
+      ["--json", "machine-readable output"]
+    ],
+    example: "loadout-os rules stats .claude/CLAUDE.md",
+    exits: [["0", "stats printed"], ["1", "CLAUDE.md missing"]]
+  },
+  "rules split": {
+    synopsis: "loadout-os rules split [CLAUDE.md] [--yes] [--dry-run] [...]",
+    args: [["[CLAUDE.md]", "instruction file to split (default .claude/CLAUDE.md)"]],
+    flags: [
+      ["--dry-run", "show the proposed split without writing"],
+      ["--yes", "extract all proposed sections without prompting"]
+    ],
+    example: "loadout-os rules split .claude/CLAUDE.md --dry-run",
+    note: "Interactive: this passes through to the `claude-rules split` bin with inherited stdio so the readline prompt works. All args/flags are forwarded verbatim.",
+    exits: [["0", "split completed (or dry-run printed)"], ["\u22600", "forwarded from the claude-rules bin"]]
+  },
+  // ── flat kernel verbs ────────────────────────────────────────
+  resolve: {
+    synopsis: "loadout-os resolve [--project <dir>] [--global <dir>] [--org <p>] [--session <p>] [--json]",
+    flags: [
+      ["--project <dir>", "project root to discover .claude layers under"],
+      ["--global <dir>", "global resolver dir (default ~/.ai-loadout)"],
+      ["--org <p>", "org-level index path"],
+      ["--session <p>", "session-level index path"],
+      ["--json", "machine-readable output"]
+    ],
+    example: "loadout-os resolve --json",
+    exits: [["0", "layers resolved (even if none found)"]]
+  },
+  explain: {
+    synopsis: "loadout-os explain <entry-id> [--project <dir>] [--global <dir>] [--json]",
+    args: [["<entry-id>", "the entry id to trace across layers (required, first)"]],
+    flags: [["--json", "machine-readable output"]],
+    example: "loadout-os explain shipcheck",
+    exits: [["0", "explanation printed"], ["1", "entry id not found in any layer"]]
+  },
+  usage: {
+    synopsis: "loadout-os usage <jsonl> [--json]",
+    args: [["<jsonl>", "path to a usage.jsonl event log (required, first)"]],
+    flags: [["--json", "machine-readable output"]],
+    example: "loadout-os usage ~/.ai-loadout/usage.jsonl",
+    exits: [["0", "summary printed (empty log allowed)"], ["1", "missing arg"]]
+  },
+  dead: {
+    synopsis: "loadout-os dead <index> <jsonl> [--json]",
+    args: [
+      ["<index>", "the loadout index (FIRST positional)"],
+      ["<jsonl>", "the usage.jsonl event log (SECOND positional)"]
+    ],
+    flags: [["--json", "machine-readable output"]],
+    note: "Order matters: <index> comes BEFORE <jsonl>. Swapping them ('dead usage.jsonl index.json') makes the kernel try to read the index as an event log and the log as an index \u2014 a quiet foot-gun, so the order is fixed and documented here.",
+    example: "loadout-os dead ~/.ai-loadout/index.json ~/.ai-loadout/usage.jsonl",
+    exits: [["0", "dead-entry report printed"], ["1", "missing arg / bad index"]]
+  },
+  overlaps: {
+    synopsis: "loadout-os overlaps <index> [--json]",
+    args: [["<index>", "the loadout index to scan for keyword overlaps (required, first)"]],
+    flags: [["--json", "machine-readable output"]],
+    example: "loadout-os overlaps ~/.ai-loadout/index.json",
+    exits: [["0", "overlaps printed (none = unambiguous routing)"], ["1", "bad index"]]
+  },
+  budget: {
+    synopsis: "loadout-os budget <index> [jsonl] [--json]",
+    args: [
+      ["<index>", "the loadout index (required, FIRST)"],
+      ["[jsonl]", "optional usage.jsonl to fold in observed averages (SECOND)"]
+    ],
+    flags: [["--json", "machine-readable output"]],
+    example: "loadout-os budget ~/.ai-loadout/index.json ~/.ai-loadout/usage.jsonl",
+    exits: [["0", "budget printed"], ["1", "bad index"]]
+  },
+  validate: {
+    synopsis: "loadout-os validate <index> [--json]",
+    args: [["<index>", "the loadout index to STRUCTURE-validate via the kernel (required, first)"]],
+    flags: [["--json", "machine-readable output"]],
+    note: "This is the KERNEL index-structure validator. For linting a MEMORY.md or rules dir use 'memories validate' / 'rules validate' instead \u2014 that flat-vs-namespaced split is how the name collision is resolved.",
+    example: "loadout-os validate ~/.ai-loadout/index.json",
+    exits: [["0", "no structural errors"], ["1", "\u22651 error-severity issue"]]
+  },
+  // ── rituals ──────────────────────────────────────────────────
+  doctor: {
+    synopsis: "loadout-os doctor [--store <dir>] [--index <p>] [--settings <p>] [--usage <p>] [--repo-root <dir>] [--json]",
+    flags: [
+      ["--store <dir>", "memory store dir (default canonical store)"],
+      ["--index <p>", "global resolver index (default ~/.ai-loadout/index.json)"],
+      ["--settings <p>", "Claude Code settings.json (default ~/.claude/settings.json)"],
+      ["--usage <p>", "usage.jsonl path (default ~/.ai-loadout/usage.jsonl)"],
+      ["--repo-root <dir>", "repo root for the hook-drift check (default cwd)"],
+      ["--json", "machine-readable output"]
+    ],
+    note: "Read-only: doctor NEVER writes. Every check delegates to a library validator.",
+    example: "loadout-os doctor",
+    exits: [["0", "healthy (no fail checks)"], ["1", "\u22651 fail check"]]
+  },
+  report: {
+    synopsis: "loadout-os report [--index <p>] [--jsonl <p>] [--json]",
+    flags: [
+      ["--index <p>", "global index (default ~/.ai-loadout/index.json)"],
+      ["--jsonl <p>", "usage log (default ~/.ai-loadout/usage.jsonl)"],
+      ["--json", "machine-readable output"]
+    ],
+    note: "Read-only observability over usage.jsonl.",
+    example: "loadout-os report --json",
+    exits: [["0", "report printed"], ["2", "a required input (index/usage) is missing"]]
+  },
+  "hook test": {
+    synopsis: 'loadout-os hook test [--prompt "<text>"] [--repo-root <dir>] [--json]',
+    flags: [
+      ['--prompt "<text>"', "prompt to drive the hook with (default a sample)"],
+      ["--repo-root <dir>", "repo root holding apps/hook/loadout-hook.mjs (default cwd)"],
+      ["--json", "machine-readable output"]
+    ],
+    note: "Runs in an isolated HOME so the live usage.jsonl is never written.",
+    example: 'loadout-os hook test --prompt "scaffold a new game"',
+    exits: [["0", "hook ran"], ["1", "hook binary not found"]]
+  },
+  refresh: {
+    synopsis: "loadout-os refresh [--store <dir>] [--dest <path>] [--dry-run]",
+    flags: [
+      ["--store <dir>", "memory store dir (default canonical store)"],
+      ["--dest <path>", "global index to write (default ~/.ai-loadout/index.json)"],
+      ["--dry-run", "compute everything, write NOTHING, print what WOULD change"]
+    ],
+    note: "Folds the Index Freshness Ritual (index \u2192 validate \u2192 copy) into one command. ANDON HALT: any validation error writes nothing. COMPENSATOR: an existing --dest is backed up to <dest>.bak before overwrite and restored on write failure.",
+    example: "loadout-os refresh --dry-run",
+    exits: [
+      ["0", "index written (or dry-run printed)"],
+      ["1", "validation error (andon) or write failure"],
+      ["2", "store / MEMORY.md missing"]
+    ]
+  }
+};
+function renderCommandHelp(key) {
+  const e = COMMAND_HELP[key];
+  if (!e) {
+    return `
+${BOLD}loadout-os ${key}${RESET}
+  (no per-command help registered)
+`;
+  }
+  const lines = [];
+  lines.push("");
+  lines.push(`${BOLD}loadout-os ${key}${RESET}`);
+  lines.push("");
+  lines.push(`${BOLD}Synopsis:${RESET}`);
+  lines.push(`  ${e.synopsis}`);
+  if (e.args && e.args.length > 0) {
+    lines.push("");
+    lines.push(`${BOLD}Arguments:${RESET}`);
+    for (const [name, role] of e.args) lines.push(`  ${name.padEnd(14)} ${DIM}${role}${RESET}`);
+  }
+  if (e.flags && e.flags.length > 0) {
+    lines.push("");
+    lines.push(`${BOLD}Flags:${RESET}`);
+    for (const [flag, role] of e.flags) lines.push(`  ${flag.padEnd(22)} ${DIM}${role}${RESET}`);
+  }
+  if (e.note) {
+    lines.push("");
+    lines.push(`  ${DIM}${e.note}${RESET}`);
+  }
+  lines.push("");
+  lines.push(`${BOLD}Example:${RESET}`);
+  lines.push(`  ${e.example}`);
+  lines.push("");
+  lines.push(`${BOLD}Exit codes:${RESET}`);
+  for (const [code, meaning] of e.exits) lines.push(`  ${code.padEnd(4)} ${DIM}${meaning}${RESET}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function interceptHelp(key, args) {
+  if (!wantsHelp(args)) return false;
+  if (!(key in COMMAND_HELP)) return false;
+  log(renderCommandHelp(key));
+  return true;
+}
+
+// src/cli.ts
+function getVersion() {
+  try {
+    const here = dirname8(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync12(join9(here, "..", "package.json"), "utf-8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function topLevelHelp() {
+  return `
+${BOLD}loadout-os${RESET} v${getVersion()} \u2014 unified Knowledge OS CLI
+
+${BOLD}Namespaces (wrapped library surfaces):${RESET}
+  loadout-os memories <index|validate|stats|health> <MEMORY.md>
+  loadout-os rules    <analyze|validate|stats|split> [CLAUDE.md]
+
+${BOLD}Flat verbs (knowledge router / kernel):${RESET}
+  loadout-os resolve                 Resolve layered loadouts (global \u2192 org \u2192 project \u2192 session)
+  loadout-os explain <entry-id>      Explain how an entry resolved across layers
+  loadout-os usage <jsonl>           Usage summary from the event log
+  loadout-os dead <index> <jsonl>    Entries never loaded
+  loadout-os overlaps <index>        Keyword routing ambiguities
+  loadout-os budget <index> [jsonl]  Token budget breakdown
+  loadout-os validate <index>        Validate index STRUCTURE (kernel)
+
+${BOLD}Rituals:${RESET}
+  loadout-os doctor [--json]                       Read-only health screen
+  loadout-os report [--index <p>] [--jsonl <p>]    Observability over usage.jsonl
+  loadout-os hook test [--prompt "<text>"]         Drive the runtime hook on a sample prompt
+  loadout-os refresh [--store <d>] [--dest <p>] [--dry-run]   Index Freshness Ritual (index \u2192 validate \u2192 write global)
+
+${BOLD}Options:${RESET}
+  --json       Machine-readable output (doctor/report/most verbs)
+  --help       Show this help (or per-namespace: 'loadout-os memories --help')
+  --version    Show version
+
+${BOLD}Examples:${RESET}
+  loadout-os memories validate ~/.claude/projects/F--AI/memory/MEMORY.md
+  loadout-os rules analyze .claude/CLAUDE.md
+  loadout-os validate ~/.ai-loadout/index.json
+  loadout-os doctor
+  loadout-os report --json
+  loadout-os hook test --prompt "scaffold a new game"
+`;
+}
+function memoriesHelp() {
+  return `
+${BOLD}loadout-os memories${RESET} \u2014 wraps @mcptoolshop/claude-memories
+
+  loadout-os memories index <MEMORY.md> [--lazy] [--json]
+  loadout-os memories validate <MEMORY.md> [--json]
+  loadout-os memories stats <MEMORY.md> [--json]
+  loadout-os memories health [path] [--json]
+`;
+}
+function rulesHelp() {
+  return `
+${BOLD}loadout-os rules${RESET} \u2014 wraps @mcptoolshop/claude-rules
+
+  loadout-os rules analyze <CLAUDE.md> [--rules-dir <dir>] [--json]
+  loadout-os rules validate [--rules-dir <dir>] [--lazy] [--repo-root <dir>] [--json]
+  loadout-os rules stats <CLAUDE.md> [--rules-dir <dir>] [--json]
+  loadout-os rules split [CLAUDE.md] [--yes] [--dry-run]   (interactive \u2014 passes through to claude-rules)
+`;
+}
+function dispatchMemories(args) {
+  const firstIsSub = args.length > 0 && !args[0].startsWith("-");
+  if (args.length === 0 || hasFlag(args, "help") && !firstIsSub) {
+    log(memoriesHelp());
+    return;
+  }
+  const sub = args[0];
+  const rest = args.slice(1);
+  if (interceptHelp(`memories ${sub}`, rest)) return;
+  switch (sub) {
+    case "index":
+      return memoriesIndex(rest);
+    case "validate":
+      return memoriesValidate(rest);
+    case "stats":
+      return memoriesStats(rest);
+    case "health":
+      return memoriesHealth(rest);
+    default:
+      throw new CliError(
+        "UNKNOWN_COMMAND",
+        `Unknown memories subcommand: ${sub}`,
+        "Expected one of: index, validate, stats, health. Run 'loadout-os memories --help'."
+      );
+  }
+}
+function dispatchRules(args) {
+  const firstIsSub = args.length > 0 && !args[0].startsWith("-");
+  if (args.length === 0 || hasFlag(args, "help") && !firstIsSub) {
+    log(rulesHelp());
+    return;
+  }
+  const sub = args[0];
+  const rest = args.slice(1);
+  if (interceptHelp(`rules ${sub}`, rest)) return;
+  switch (sub) {
+    case "analyze":
+      return rulesAnalyze(rest);
+    case "validate":
+      return rulesValidate(rest);
+    case "stats":
+      return rulesStats(rest);
+    case "split":
+      return rulesSplit(rest);
+    default:
+      throw new CliError(
+        "UNKNOWN_COMMAND",
+        `Unknown rules subcommand: ${sub}`,
+        "Expected one of: analyze, validate, stats, split. Run 'loadout-os rules --help'."
+      );
+  }
+}
+function dispatchDoctor(args) {
+  const repoRoot = flagValue(args, "repo-root") ?? process.cwd();
+  const paths = defaultDoctorPaths(resolve11(repoRoot));
+  const store = flagValue(args, "store");
+  const index = flagValue(args, "index");
+  const settings = flagValue(args, "settings");
+  const usage = flagValue(args, "usage");
+  if (store) paths.store = resolve11(store);
+  if (index) paths.index = resolve11(index);
+  if (settings) paths.settings = resolve11(settings);
+  if (usage) paths.usage = resolve11(usage);
+  const result = runDoctor(paths);
+  if (hasFlag(args, "json")) {
+    log(JSON.stringify(result, null, 2));
+  } else {
+    printDoctor(result, paths);
+  }
+  if (!result.ok) {
+    process.exitCode = 1;
+  }
+}
+function dispatchReport(args) {
+  const home = homedir5();
+  const indexPath = resolve11(flagValue(args, "index") ?? join9(home, ".ai-loadout", "index.json"));
+  const usagePath = resolve11(flagValue(args, "jsonl") ?? join9(home, ".ai-loadout", "usage.jsonl"));
+  const result = buildReport(indexPath, usagePath);
+  if (hasFlag(args, "json")) {
+    log(JSON.stringify(result, null, 2));
+  } else if (!result.ok && result.error) {
+    log();
+    log(`  ${RED}\u2717 [${result.error.code}]${RESET} ${result.error.message}`);
+    log();
+  } else {
+    printReport(result);
+  }
+  if (!result.ok) {
+    process.exitCode = 2;
+  }
+}
+function dispatchHook(args) {
+  const sub = args[0];
+  if (interceptHelp("hook test", args)) return;
+  if (sub !== "test") {
+    throw new CliError(
+      "UNKNOWN_COMMAND",
+      `Unknown hook subcommand: ${sub ?? "(none)"}`,
+      "Only 'loadout-os hook test' is available."
+    );
+  }
+  const rest = args.slice(1);
+  const prompt = flagValue(rest, "prompt") ?? "";
+  const repoRoot = flagValue(rest, "repo-root") ?? process.cwd();
+  const result = runHookTest({
+    prompt,
+    hookPath: defaultHookPath(resolve11(repoRoot))
+  });
+  if (hasFlag(rest, "json")) {
+    log(JSON.stringify(result, null, 2));
+  } else {
+    printHookTest(prompt || "(default sample prompt)", result);
+  }
+  if (!result.ran) {
+    process.exitCode = 1;
+  }
+}
+var FLAT_KERNEL = /* @__PURE__ */ new Set([
+  "resolve",
+  "explain",
+  "usage",
+  "dead",
+  "overlaps",
+  "budget",
+  "validate"
+]);
+function dispatch(args) {
+  if (hasFlag(args, "version") && args[0] !== "memories" && args[0] !== "rules") {
+    log(getVersion());
+    return;
+  }
+  const firstIsCmd = args.length > 0 && !args[0].startsWith("-");
+  if (args.length === 0 || hasFlag(args, "help") && !firstIsCmd) {
+    log(topLevelHelp());
+    return;
+  }
+  const cmd = args[0];
+  const rest = args.slice(1);
+  if (cmd !== "memories" && cmd !== "rules" && cmd !== "hook" && interceptHelp(cmd, rest)) {
+    return;
+  }
+  switch (cmd) {
+    case "memories":
+      return dispatchMemories(rest);
+    case "rules":
+      return dispatchRules(rest);
+    case "doctor":
+      return dispatchDoctor(rest);
+    case "report":
+      return dispatchReport(rest);
+    case "hook":
+      return dispatchHook(rest);
+    case "refresh":
+      return dispatchRefresh(rest);
+    case "resolve":
+      return kernelResolve(rest);
+    case "explain":
+      return kernelExplain(rest);
+    case "usage":
+      return kernelUsage(rest);
+    case "dead":
+      return kernelDead(rest);
+    case "overlaps":
+      return kernelOverlaps(rest);
+    case "budget":
+      return kernelBudget(rest);
+    case "validate":
+      return kernelValidate(rest);
+    default:
+      if (FLAT_KERNEL.has(cmd)) {
+        throw new CliError("INTERNAL", `Unrouted flat verb: ${cmd}`);
+      }
+      throw new CliError(
+        "UNKNOWN_COMMAND",
+        `Unknown command: ${cmd}`,
+        "Run 'loadout-os --help' for the command tree."
+      );
+  }
+}
+function isEntrypoint() {
+  try {
+    return process.argv[1] === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+}
+if (isEntrypoint()) {
+  try {
+    dispatch(process.argv.slice(2));
+  } catch (err) {
+    if (err instanceof CliError) {
+      console.error(`${RED}\u2717 [${err.code}]${RESET} ${err.message}`);
+      if (err.hint) console.error(`  ${DIM}${err.hint}${RESET}`);
+      process.exit(err.exitCode);
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`${RED}\u2717 [RUNTIME_FATAL]${RESET} ${message}`);
+    process.exit(1);
+  }
+}
+export {
+  dispatch,
+  getVersion,
+  topLevelHelp
+};