imprnt 0.1.1

package/dist/cli.js

@@ -0,0 +1,2339 @@
+#!/usr/bin/env node
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// scripts/lib/resolve.ts
+import { existsSync, readdirSync, readFileSync, appendFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+function personResolved(vault, slug, displayName) {
+  const dir = join(vault, "people");
+  if (existsSync(join(dir, `${slug}.md`)))
+    return true;
+  if (!existsSync(dir))
+    return false;
+  const needle = displayName.toLowerCase();
+  for (const f of readdirSync(dir)) {
+    if (!f.endsWith(".md"))
+      continue;
+    const fm = readFileSync(join(dir, f), "utf8").match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1] ?? "";
+    const aliases = (fm.match(/aliases:\s*\[(.*?)\]/i)?.[1] ?? "").toLowerCase();
+    if (aliases.split(",").some((a) => a.trim().replace(/["']/g, "") === needle))
+      return true;
+  }
+  return false;
+}
+function flagNeedsReview(vault, line) {
+  const p = join(vault, "_needs-review.md");
+  if (!existsSync(p))
+    writeFileSync(p, `---
+type: needs-review
+---
+
+# Needs review
+
+`);
+  const want = line.replace(/\n$/, "");
+  const present = readFileSync(p, "utf8").split(/\r?\n/).some((l) => l === want);
+  if (present)
+    return;
+  appendFileSync(p, line.endsWith(`
+`) ? line : line + `
+`);
+}
+function openNeedsReview(vault) {
+  const p = join(vault, "_needs-review.md");
+  if (!existsSync(p))
+    return [];
+  return readFileSync(p, "utf8").split(/\r?\n/).filter((l) => l.trim().startsWith("- [ ]"));
+}
+var init_resolve = () => {};
+
+// scripts/lib/plugins.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, statSync } from "node:fs";
+import { join as join2, relative, resolve, sep } from "node:path";
+function entryFor(spec) {
+  if (spec.includes("/"))
+    return `plugins/${spec}`;
+  return `plugins/${spec}/agent.md`;
+}
+function specError(root, spec) {
+  const norm = spec.endsWith("/") ? spec.slice(0, -1) : spec;
+  const base = resolve(root, "plugins");
+  const target = resolve(base, norm);
+  if (target === base || !target.startsWith(base + sep)) {
+    return `invalid plugin spec "${spec}" - must name something inside plugins/`;
+  }
+  const canonical = relative(base, target).split(sep).join("/");
+  if (norm !== canonical) {
+    return `invalid plugin spec "${spec}" - use the canonical form "${canonical}" (no ./ or ..)`;
+  }
+  return;
+}
+function canonicalSpec(root, spec) {
+  const slash = spec.indexOf("/");
+  const dirName = slash === -1 ? spec : spec.slice(0, slash);
+  const rest = slash === -1 ? "" : spec.slice(slash);
+  const base = join2(root, "plugins");
+  let entries;
+  try {
+    entries = readdirSync2(base);
+  } catch {
+    return spec;
+  }
+  const target = dirName.toLowerCase();
+  const hit = entries.find((e) => e.toLowerCase() === target);
+  return hit ? hit + rest : spec;
+}
+function localPath(root) {
+  return join2(root, "CLAUDE.local.md");
+}
+function entryExists(root, entry) {
+  const p = join2(root, entry);
+  try {
+    return statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function importLine(entry) {
+  return `@${entry}`;
+}
+function lineTarget(rawLine) {
+  const line = rawLine.trim();
+  if (!line.startsWith("@"))
+    return "";
+  const m = line.match(/^(@\S+)/);
+  return m ? m[1] : "";
+}
+function listPluginDirs(root) {
+  const dir = join2(root, "plugins");
+  if (!existsSync2(dir))
+    return [];
+  return readdirSync2(dir).filter((name) => !name.startsWith("_") && !name.startsWith(".")).filter((name) => {
+    try {
+      return statSync(join2(dir, name)).isDirectory();
+    } catch {
+      return false;
+    }
+  }).sort();
+}
+function readLocal(root) {
+  try {
+    return readFileSync2(localPath(root), "utf8");
+  } catch {
+    return "";
+  }
+}
+function lineEnding(content) {
+  const crlf = content.split(`\r
+`).length - 1;
+  const lf = content.split(`
+`).length - 1 - crlf;
+  return crlf > lf ? `\r
+` : `
+`;
+}
+function liveImportLines(root) {
+  const out = [];
+  let inFence = false;
+  for (const raw of readLocal(root).split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line.startsWith("```") || line.startsWith("~~~")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence && line.startsWith("@"))
+      out.push(line);
+  }
+  return out;
+}
+function importTargets(root) {
+  return liveImportLines(root).map((l) => l.slice(1));
+}
+function isEnabled(root, name) {
+  const prefix = `@plugins/${name}/`;
+  return liveImportLines(root).some((l) => l.startsWith(prefix));
+}
+function addPlugin(root, spec) {
+  const invalid = specError(root, spec);
+  if (invalid)
+    return { entry: entryFor(spec), added: false, error: invalid };
+  spec = canonicalSpec(root, spec);
+  const entry = entryFor(spec);
+  if (!entryExists(root, entry)) {
+    return {
+      entry,
+      added: false,
+      error: `no such plugin entry: ${entry}; expected an agent.md or a <name>/<file>.md`
+    };
+  }
+  const line = importLine(entry);
+  const p = localPath(root);
+  try {
+    let content = existsSync2(p) ? readFileSync2(p, "utf8") : HEADER;
+    const already = content.split(/\r?\n/).some((l) => lineTarget(l) === line);
+    if (already)
+      return { entry, added: false };
+    const eol = lineEnding(content);
+    if (!content.endsWith(`
+`))
+      content += eol;
+    content += line + eol;
+    writeFileSync2(p, content);
+    return { entry, added: true };
+  } catch (e) {
+    return { entry, added: false, error: `cannot update ${p}: ${e instanceof Error ? e.message : String(e)}` };
+  }
+}
+function rmPlugin(root, spec) {
+  const p = localPath(root);
+  if (!existsSync2(p))
+    return 0;
+  if (spec.endsWith("/"))
+    spec = spec.slice(0, -1);
+  const target = spec.includes("/") ? importLine(entryFor(spec)) : "";
+  const gone = spec.includes("/") ? (l) => lineTarget(l) === target : (l) => l.trim().startsWith(`@plugins/${spec}/`);
+  const content = readFileSync2(p, "utf8");
+  const lines = content.split(/\r?\n/);
+  const kept = lines.filter((l) => !gone(l));
+  const removed = lines.length - kept.length;
+  if (removed)
+    writeFileSync2(p, kept.join(lineEnding(content)));
+  return removed;
+}
+var HEADER = `# Personal plugin toggles (this machine only)
+
+> Gitignored. Claude Code auto-loads this right after CLAUDE.md, so whatever you @import here is
+> wired into the agent every session. This is the on/off switch: add a line to enable a plugin,
+> delete or comment it to disable. Managed by \`imprnt plugin add/rm\`, or hand-edit it.
+
+`;
+var init_plugins = () => {};
+
+// scripts/lib/install.ts
+import { existsSync as existsSync3, mkdtempSync, cpSync, rmSync, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join3, basename, resolve as resolve2 } from "node:path";
+import { spawnSync } from "node:child_process";
+function coreChannel(pkgRoot) {
+  try {
+    const v = JSON.parse(readFileSync3(join3(pkgRoot, "package.json"), "utf8")).version;
+    return typeof v === "string" && v.includes("-edge.") ? "edge" : "latest";
+  } catch {
+    return "latest";
+  }
+}
+function npmPack(spec, tmp) {
+  const pack = spawnSync("npm", ["pack", spec, "--pack-destination", tmp], { encoding: "utf8" });
+  if (pack.status !== 0) {
+    const errLines = (pack.stderr || "").split(/\r?\n/).filter((l) => /^npm (error|ERR!)/.test(l) && !l.includes("complete log")).map((l) => l.replace(/^npm (error|ERR!) ?/, "")).filter(Boolean);
+    const why = errLines.join(`
+`) || (pack.stderr || "").trim() || (pack.error ? String(pack.error.message) : `exit ${pack.status}`);
+    return { error: `npm pack failed for ${spec}: ${why}` };
+  }
+  const tgz = pack.stdout.trim().split(/\r?\n/).filter(Boolean).pop();
+  return tgz ? { tgz } : { error: `npm pack produced no tarball for ${spec}` };
+}
+function installPlugin(projectRoot, name, opts = {}) {
+  const invalid = specError(projectRoot, name);
+  if (invalid)
+    return { copied: false, dest: join3(projectRoot, "plugins"), error: invalid };
+  name = canonicalSpec(projectRoot, name);
+  const dest = join3(projectRoot, "plugins", name);
+  if (existsSync3(join3(dest, "agent.md")) && !opts.force)
+    return { copied: false, dest, skipped: true };
+  if (opts.from && !existsSync3(resolve2(opts.from))) {
+    return { copied: false, dest, error: `--from path not found: ${resolve2(opts.from)}` };
+  }
+  const base = `imprnt-plugin-${name}`;
+  const specs = opts.from ? [resolve2(opts.from)] : opts.channel === "edge" ? [`${base}@edge`, base] : [base];
+  const tmp = mkdtempSync(join3(tmpdir(), "imprnt-pkg-"));
+  try {
+    let tgz;
+    let lastErr;
+    for (const spec of specs) {
+      const r = npmPack(spec, tmp);
+      if (r.tgz) {
+        tgz = r.tgz;
+        break;
+      }
+      lastErr = r.error;
+    }
+    if (!tgz)
+      return { copied: false, dest, error: lastErr ?? `npm pack produced no tarball for ${base}` };
+    const ex = spawnSync("tar", ["-xzf", join3(tmp, tgz), "-C", tmp], { encoding: "utf8" });
+    if (ex.status !== 0)
+      return { copied: false, dest, error: `tar extract failed: ${(ex.stderr || "").trim()}` };
+    const src = join3(tmp, "package");
+    if (!existsSync3(join3(src, "agent.md"))) {
+      return { copied: false, dest, error: `${name} has no agent.md — not an imprnt plugin?` };
+    }
+    if (opts.force)
+      rmSync(dest, { recursive: true, force: true });
+    cpSync(src, dest, { recursive: true, force: true, filter: (s) => basename(s) !== "package.json" });
+    return { copied: true, dest };
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+function purgePlugin(projectRoot, name) {
+  if (specError(projectRoot, name))
+    return false;
+  if (name.includes("/"))
+    return false;
+  if (name.startsWith("_"))
+    return false;
+  const dir = join3(projectRoot, "plugins", name);
+  if (!existsSync3(dir))
+    return false;
+  if (!statSync2(dir).isDirectory())
+    return false;
+  rmSync(dir, { recursive: true, force: true });
+  return true;
+}
+var OFFICIAL;
+var init_install = __esm(() => {
+  init_plugins();
+  OFFICIAL = ["anti-slop", "character", "whenful", "guard"];
+});
+
+// scripts/lib/roots.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { dirname, join as join4 } from "node:path";
+function projectRoot(start = process.cwd()) {
+  const override = process.env.IMPRNT_ROOT ?? process.env.IMPRINT_ROOT;
+  if (override)
+    return override;
+  let dir = start;
+  for (;; ) {
+    if (existsSync4(join4(dir, "vault")) || existsSync4(join4(dir, "CLAUDE.local.md")))
+      return dir;
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return start;
+}
+var init_roots = () => {};
+
+// scripts/lib/moc.ts
+import { lstatSync, readdirSync as readdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join5, relative as relative2 } from "node:path";
+function stripCode(raw) {
+  const blank = (s) => s.replace(/[^\n]/g, " ");
+  const lines = raw.split(`
+`);
+  const out = [];
+  let fence = null;
+  for (const line of lines) {
+    if (fence) {
+      out.push(blank(line));
+      if (line.trim().startsWith(fence))
+        fence = null;
+      continue;
+    }
+    const m = line.match(FENCE);
+    if (m) {
+      fence = m[2];
+      out.push(blank(line));
+      continue;
+    }
+    out.push(line.replace(/`[^`\n]*`/g, blank));
+  }
+  return out.join(`
+`);
+}
+function stripBom(raw) {
+  return raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+}
+function frontmatter(raw) {
+  return stripBom(raw).match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1] ?? "";
+}
+function stripQuotes(v) {
+  const m = v.match(/^(["'])([\s\S]*)\1$/);
+  return m ? m[2] : v;
+}
+function fmScalar(fm, key) {
+  const lines = fm.split(/\r?\n/);
+  const keyRe = new RegExp(`^${key}:\\s*(.*)$`, "i");
+  for (const [i, line] of lines.entries()) {
+    const m = line.match(keyRe);
+    if (!m)
+      continue;
+    const rest = m[1].trim();
+    if (rest === "|" || rest === ">") {
+      const block = [];
+      for (let j = i + 1;j < lines.length; j++) {
+        const cont = lines[j].match(/^(\s+)(.*\S)\s*$/);
+        if (!cont)
+          break;
+        block.push(cont[2]);
+      }
+      return block.join(" ");
+    }
+    return stripQuotes(rest);
+  }
+  return "";
+}
+function fmList(fm, key) {
+  const lines = fm.split(/\r?\n/);
+  const keyRe = new RegExp(`^${key}:\\s*(.*)$`, "i");
+  for (const [i, line] of lines.entries()) {
+    const m = line.match(keyRe);
+    if (!m)
+      continue;
+    const rest = m[1].trim();
+    if (rest.startsWith("[")) {
+      const inner = rest.match(/^\[(.*)\]/)?.[1] ?? "";
+      return inner.split(",").map((s) => stripQuotes(s.trim())).filter(Boolean);
+    }
+    if (rest !== "")
+      return [];
+    const items = [];
+    for (let j = i + 1;j < lines.length; j++) {
+      const item = lines[j].match(/^\s*-(?:\s+(.*\S))?\s*$/);
+      if (!item)
+        break;
+      const v = stripQuotes((item[1] ?? "").trim());
+      if (v)
+        items.push(v);
+    }
+    return items;
+  }
+  return [];
+}
+function walk(vault, dir) {
+  const out = [];
+  for (const entry of readdirSync3(dir)) {
+    if (entry.startsWith(".") || entry.startsWith("_"))
+      continue;
+    const p = join5(dir, entry);
+    let st;
+    try {
+      st = lstatSync(p);
+    } catch {
+      continue;
+    }
+    if (st.isSymbolicLink())
+      continue;
+    if (st.isDirectory())
+      out.push(...walk(vault, p));
+    else if (entry.endsWith(".md")) {
+      const rel = relative2(vault, p);
+      if (!rel.includes("/") && !rel.includes("\\") && CONTROL.has(rel))
+        continue;
+      out.push(p);
+    }
+  }
+  return out;
+}
+function collectNotes(vault) {
+  const notes = [];
+  for (const path of walk(vault, vault)) {
+    const raw = readFileSync4(path, "utf8");
+    const fm = frontmatter(raw);
+    const rel = relative2(vault, path).split("\\").join("/");
+    const folder = rel.includes("/") ? rel.slice(0, rel.indexOf("/")) : ".";
+    const slug = rel.replace(/\.md$/, "");
+    const title = stripCode(raw).match(/^#[ \t]+(\S.*)$/m)?.[1]?.trim() ?? slug;
+    const summary = fmScalar(fm, "summary") || title;
+    notes.push({ path, folder, slug, title, summary, type: fmScalar(fm, "type"), tags: fmList(fm, "tags") });
+  }
+  return notes;
+}
+function folderRank(f) {
+  const i = FOLDER_ORDER.indexOf(f);
+  return i < 0 ? FOLDER_ORDER.length : i;
+}
+function generateIndex(vault) {
+  const notes = collectNotes(vault);
+  const byFolder = new Map;
+  for (const n of notes) {
+    if (!byFolder.has(n.folder))
+      byFolder.set(n.folder, []);
+    byFolder.get(n.folder).push(n);
+  }
+  const folders = [...byFolder.keys()].sort((a, b) => folderRank(a) - folderRank(b) || a.localeCompare(b));
+  const lines = [
+    "---",
+    "type: index",
+    "---",
+    "",
+    "# Index",
+    "",
+    `> Generated by \`imprnt check\` — do not edit by hand. ${notes.length} notes across ${folders.length} folders.`,
+    ""
+  ];
+  for (const f of folders) {
+    const items = byFolder.get(f).sort((a, b) => a.slug.localeCompare(b.slug));
+    lines.push(`## ${f}/  (${items.length})`, "");
+    for (const n of items) {
+      const tags = n.tags.length ? `  \`${n.tags.join("` `")}\`` : "";
+      lines.push(`- [[${n.slug}]] — ${n.summary}${tags}`);
+    }
+    lines.push("");
+  }
+  writeFileSync3(join5(vault, "index.md"), lines.join(`
+`) + `
+`);
+  return { count: notes.length, folders: folders.length };
+}
+var CONTROL, FOLDER_ORDER, FENCE;
+var init_moc = __esm(() => {
+  CONTROL = new Set(["index.md", "hot.md", "log.md", "_tags.md"]);
+  FOLDER_ORDER = [
+    "people",
+    "orgs",
+    "holdings",
+    "identity",
+    "health",
+    "finances",
+    "work",
+    "life",
+    "projects",
+    "events",
+    "mistakes"
+  ];
+  FENCE = /^(\s*)(```+|~~~+)/;
+});
+
+// scripts/lib/registry.ts
+import { existsSync as existsSync5, mkdirSync, readFileSync as readFileSync5, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join6, resolve as resolve3 } from "node:path";
+function configPath() {
+  const base = process.env.XDG_CONFIG_HOME || join6(homedir(), ".config");
+  return join6(base, "imprnt", "config.json");
+}
+function readRegistry() {
+  try {
+    const raw = JSON.parse(readFileSync5(configPath(), "utf8"));
+    const vaults = {};
+    for (const [k, v] of Object.entries(raw?.vaults ?? {}))
+      if (typeof v === "string")
+        vaults[k] = v;
+    return { default: typeof raw?.default === "string" ? raw.default : undefined, vaults };
+  } catch {
+    return { vaults: {} };
+  }
+}
+function liveDefault(reg) {
+  const name = reg.default ?? Object.keys(reg.vaults)[0];
+  const path = name ? reg.vaults[name] : undefined;
+  return path && isVaultProject(path) ? path : undefined;
+}
+function registeredRoot() {
+  return liveDefault(readRegistry());
+}
+function registerVault(path, opts = {}) {
+  const reg = readRegistry();
+  const current = liveDefault(reg);
+  if (current === path)
+    return { status: "already", current: path };
+  if (current && !opts.force)
+    return { status: "kept", current };
+  const name = opts.name ?? "personal";
+  reg.vaults[name] = path;
+  reg.default = name;
+  const p = configPath();
+  try {
+    mkdirSync(dirname2(p), { recursive: true });
+    writeFileSync4(p, JSON.stringify(reg, null, 2) + `
+`);
+  } catch (e) {
+    return { status: "error", current: path, error: e instanceof Error ? e.message : String(e) };
+  }
+  return { status: "registered", current: path };
+}
+function isVaultProject(dir) {
+  const vault = join6(dir, "vault");
+  try {
+    return statSync3(vault).isDirectory() && existsSync5(join6(vault, "index.md")) && existsSync5(join6(vault, "_tags.md"));
+  } catch {
+    return false;
+  }
+}
+function vaultProjectRoot(start = process.cwd()) {
+  const rootEnv = process.env.IMPRNT_ROOT ?? process.env.IMPRINT_ROOT;
+  if (rootEnv)
+    return resolve3(start, rootEnv);
+  const vaultEnv = process.env.IMPRNT_VAULT ?? process.env.IMPRINT_VAULT;
+  if (vaultEnv)
+    return dirname2(resolve3(start, vaultEnv));
+  let dir = start;
+  for (;; ) {
+    if (isVaultProject(dir))
+      return dir;
+    const parent = dirname2(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return registeredRoot();
+}
+var init_registry = () => {};
+
+// scripts/lib/launch.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, realpathSync, statSync as statSync4 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { isAbsolute, join as join7, resolve as resolve4, sep as sep2 } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+function importPath(root, target) {
+  if (target.startsWith("~/"))
+    return join7(homedir2(), target.slice(2));
+  if (isAbsolute(target))
+    return target;
+  return join7(root, target);
+}
+function castFragment(root) {
+  const parts = [];
+  for (const target of importTargets(root)) {
+    const p = importPath(root, target);
+    if (!existsSync6(p)) {
+      console.error(`imp: skipping missing import @${target}`);
+      continue;
+    }
+    try {
+      parts.push(readFileSync6(p, "utf8").trim());
+    } catch {
+      console.error(`imp: skipping unreadable import @${target}`);
+    }
+  }
+  return parts.join(`
+
+`);
+}
+function pointerFragment(pkgRoot, vaultProject) {
+  const tpl = readFileSync6(join7(pkgRoot, "templates", "pointer.md"), "utf8");
+  return tpl.replaceAll("{{VAULT_PROJECT}}", () => vaultProject);
+}
+function realResolve(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return resolve4(p);
+  }
+}
+function isInside(child, parent) {
+  const c = realResolve(child);
+  const p = realResolve(parent);
+  return c === p || c.startsWith(p + sep2);
+}
+function isDir(p) {
+  try {
+    return statSync4(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function childEnv(vaultProject) {
+  return process.env.IMPRNT_VAULT || process.env.IMPRINT_VAULT ? process.env : { ...process.env, IMPRNT_VAULT: join7(vaultProject, "vault") };
+}
+function buildLaunch(opts) {
+  const pass = [...opts.passthrough ?? []];
+  if (!opts.vaultProject)
+    return { args: pass, env: process.env };
+  if (!isDir(opts.vaultProject)) {
+    console.error(`imp: vault project not found at ${opts.vaultProject} - launching plain claude (re-run \`imprnt init\` there, or fix IMPRNT_ROOT)`);
+    return { args: pass, env: process.env };
+  }
+  if (isInside(opts.cwd, opts.vaultProject))
+    return { args: pass, env: childEnv(opts.vaultProject) };
+  const fragment = [castFragment(opts.vaultProject), pointerFragment(opts.pkgRoot, opts.vaultProject)].filter(Boolean).join(`
+
+`);
+  const args = [...pass];
+  const firstTerm = args.indexOf("--");
+  const scanEnd = firstTerm >= 0 ? firstTerm - 1 : args.length - 1;
+  let merged = false;
+  for (let i = scanEnd;i >= 0 && !merged; i--) {
+    const prev = args[i - 1];
+    const inValuePosition = prev === "-p" || prev === "--print" || prev === "--append-system-prompt" || prev === "--system-prompt" || prev === "--add-dir";
+    if (args[i] === "--append-system-prompt" && args[i + 1] !== undefined) {
+      args[i + 1] += `
+
+` + fragment;
+      merged = true;
+    } else if (!inValuePosition && args[i].startsWith("--append-system-prompt=")) {
+      args[i] += `
+
+` + fragment;
+      merged = true;
+    }
+  }
+  const term = args.indexOf("--");
+  const inject = merged ? ["--add-dir", opts.vaultProject] : ["--append-system-prompt", fragment, "--add-dir", opts.vaultProject];
+  if (term >= 0)
+    args.splice(term, 0, ...inject);
+  else
+    args.push(...inject);
+  return { args, env: childEnv(opts.vaultProject) };
+}
+function launchClaude(cwd, args, env = process.env) {
+  if (!isDir(cwd)) {
+    console.error(`imp: vault project not found at ${cwd} — re-run \`imprnt init\` in its new location (add --register to switch the default)`);
+    return 1;
+  }
+  const r = spawnSync2("claude", args, { cwd, stdio: "inherit", env });
+  if (r.error) {
+    const code = r.error.code;
+    console.error(code === "ENOENT" ? "imp: `claude` not found on PATH. Install Claude Code first: npm i -g @anthropic-ai/claude-code" : `imp: failed to launch claude: ${r.error.message}`);
+    return 1;
+  }
+  return r.status ?? 1;
+}
+var init_launch = __esm(() => {
+  init_plugins();
+});
+
+// scripts/lib/manifest.ts
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, renameSync, existsSync as existsSync7 } from "node:fs";
+import { join as join8 } from "node:path";
+function manifestPath(vault) {
+  return join8(vault, ".manifest.json");
+}
+function loadManifest(vault) {
+  const p = manifestPath(vault);
+  if (!existsSync7(p))
+    return {};
+  try {
+    return JSON.parse(readFileSync7(p, "utf8"));
+  } catch {
+    let n = 0;
+    let backup = `${p}.corrupt-${n}`;
+    while (existsSync7(backup))
+      backup = `${p}.corrupt-${++n}`;
+    renameSync(p, backup);
+    throw new Error(`manifest is corrupt and could not be parsed: ${p}
+  backed up to ${backup} — inspect it, then retry. provenance was not lost.`);
+  }
+}
+function saveManifest(vault, m) {
+  const p = manifestPath(vault);
+  const tmp = `${p}.tmp.${process.pid}.${Date.now()}`;
+  writeFileSync5(tmp, JSON.stringify(m, null, 2) + `
+`);
+  renameSync(tmp, p);
+}
+var init_manifest = () => {};
+
+// scripts/ingest.ts
+var exports_ingest = {};
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, mkdirSync as mkdirSync2, existsSync as existsSync8, copyFileSync, readdirSync as readdirSync4, rmSync as rmSync2, statSync as statSync5 } from "node:fs";
+import { createHash } from "node:crypto";
+import { basename as basename2, extname, join as join9, relative as relative3 } from "node:path";
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
+}
+function deriveSlug(candidates) {
+  for (const c of candidates) {
+    const s = slugify(c);
+    if (!s)
+      continue;
+    if (/^[\d-]+$/.test(s) && /\p{L}/u.test(c))
+      continue;
+    return s;
+  }
+  return "";
+}
+function looksLikePath(arg) {
+  if (/\s/.test(arg))
+    return false;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(arg))
+    return false;
+  if (arg.includes("/") || arg.includes("\\"))
+    return true;
+  if (PATH_EXTS.has(extname(arg).toLowerCase()))
+    return true;
+  return false;
+}
+function looksLikeTranscript(speakers, turnCount, contentLines, recurringSpeaker) {
+  if (speakers.size < 2)
+    return false;
+  if (recurringSpeaker)
+    return true;
+  return speakers.size === 2 && turnCount === 2 && contentLines === 2;
+}
+function frontmatter2(raw) {
+  return raw.match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1] ?? "";
+}
+function fmScalar2(fm, key) {
+  return (fm.match(new RegExp(`^${key}:\\s*(.+)$`, "im"))?.[1] ?? "").trim().replace(/^["']|["']$/g, "");
+}
+function fmList2(fm, key) {
+  const line = fm.match(new RegExp(`^${key}:\\s*\\[(.*)\\]`, "im"))?.[1] ?? "";
+  return line.split(",").map((s) => s.trim().replace(/^["'\[]+|["'\]]+$/g, "")).filter(Boolean);
+}
+function linkSlug(s) {
+  return s.trim().replace(/^\[\[/, "").replace(/\]\]$/, "").replace(/#.*$/, "").replace(/\|.*$/, "").replace(/\.md$/, "").trim();
+}
+function injectSource(text, target) {
+  return text.replace(/^(---\r?\n[\s\S]*?)(\r?\n)(---)/, `$1$2source: "[[${target}]]"$2$3`);
+}
+function targetFolder(type, domain) {
+  if (Object.hasOwn(TYPE_FOLDER, type))
+    return TYPE_FOLDER[type];
+  if (type === "principle" || type === "note") {
+    return DOMAIN_FOLDERS.has(domain) ? domain : null;
+  }
+  return null;
+}
+function applyStaged(staged, vault) {
+  if (!existsSync8(staged)) {
+    console.error(`no such staged note: ${staged}`);
+    return "error";
+  }
+  if (statSync5(staged).isDirectory()) {
+    console.error(`  ✗ ${staged}: is a directory - --apply takes a single staged note file`);
+    return "error";
+  }
+  const text = readFileSync8(staged, "utf8").replace(/^/, "");
+  const fm = frontmatter2(text);
+  const type = fmScalar2(fm, "type");
+  const domain = fmScalar2(fm, "domain");
+  if (!type) {
+    console.error(`  ✗ ${staged}: no \`type:\` in frontmatter — can't file a note with no type`);
+    return "error";
+  }
+  const folder = targetFolder(type, domain);
+  if (!folder) {
+    console.error(`  ✗ ${staged}: type \`${type}\`${domain ? ` / domain \`${domain}\`` : ""} maps to no vault folder`);
+    console.error(`     entities: person|org|holding · forms: event|mistake · project · a principle/note needs a valid domain:`);
+    return "error";
+  }
+  const title = text.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? "";
+  const slug = deriveSlug([fmScalar2(fm, "slug"), title, basename2(staged, ".md")]);
+  if (!slug) {
+    console.error(`  ✗ ${staged}: can't derive a slug - slug:, the H1 title, and the filename all slugify to nothing`);
+    return "error";
+  }
+  const hash = createHash("sha256").update(text).digest("hex").slice(0, 16);
+  const noteRel = `${folder}/${slug}`;
+  const notePath = join9(vault, `${noteRel}.md`);
+  const stagedSource = fmScalar2(fm, "source");
+  const manifest = loadManifest(vault);
+  const priorSnapshot = Object.values(manifest).find((e) => e.hash === hash && e.raw && existsSync8(e.raw))?.raw;
+  const rawDir = join9(vault, "..", "raw", "proposed");
+  let rawPath = "";
+  let rawEntry;
+  let sourceTarget;
+  if (stagedSource) {
+    rawEntry = linkSlug(stagedSource);
+    sourceTarget = rawEntry;
+  } else if (priorSnapshot) {
+    rawPath = priorSnapshot;
+    rawEntry = rawPath;
+    sourceTarget = "raw/" + relative3(join9(vault, "..", "raw"), rawPath).split("\\").join("/").replace(/\.md$/, "");
+  } else {
+    rawPath = join9(rawDir, `${slug}-${hash}.md`);
+    rawEntry = rawPath;
+    sourceTarget = `raw/proposed/${slug}-${hash}`;
+  }
+  const finalText = stagedSource ? text : injectSource(text, sourceTarget);
+  const fileHash = createHash("sha256").update(finalText).digest("hex").slice(0, 16);
+  if (existsSync8(notePath)) {
+    const existingHash = createHash("sha256").update(readFileSync8(notePath, "utf8")).digest("hex").slice(0, 16);
+    if (existingHash === fileHash) {
+      console.log(`  = ${noteRel} already filed, identical content (hash ${fileHash}) — no-op`);
+      rmSync2(staged);
+      return "noop";
+    }
+    console.error(`  ! ${noteRel} exists with DIFFERENT content — not overwriting (contradiction discipline)`);
+    flagNeedsReview(vault, `- [ ] proposed note conflicts with existing [[${noteRel}]] — staged at \`${staged}\` (hash ${fileHash} vs ${existingHash}); reconcile or stamp \`> superseded by\``);
+    return "conflict";
+  }
+  const manifestKey = `apply:sha256:${hash}:${noteRel}`;
+  if (!stagedSource && !priorSnapshot) {
+    mkdirSync2(rawDir, { recursive: true });
+    if (!existsSync8(rawPath))
+      writeFileSync6(rawPath, text);
+  }
+  manifest[manifestKey] = { hash, note: notePath, ingested: new Date().toISOString(), raw: rawEntry };
+  saveManifest(vault, manifest);
+  mkdirSync2(join9(vault, folder), { recursive: true });
+  writeFileSync6(notePath, finalText);
+  const participantsList = fmList2(fm, "participants");
+  const participantsScalar = participantsList.length ? "" : fmScalar2(fm, "participants");
+  const participants = (participantsScalar ? [participantsScalar] : participantsList).map(linkSlug);
+  const owner = linkSlug(fmScalar2(fm, "owner"));
+  const peopleLinks = [...participants, ...owner ? [owner] : []].filter((l) => l.startsWith("people/")).map((l) => l.slice("people/".length));
+  let unresolved = 0;
+  for (const personSlug of new Set(peopleLinks)) {
+    if (!personResolved(vault, personSlug, personSlug.replace(/-/g, " "))) {
+      unresolved++;
+      flagNeedsReview(vault, `- [ ] unresolved person \`people/${personSlug}\` — from [[${noteRel}]] (applied from \`${staged}\`)`);
+    }
+  }
+  rmSync2(staged);
+  console.log(`  ✓ filed ${noteRel}  (type: ${type}${domain ? `, domain: ${domain}` : ""})`);
+  if (stagedSource)
+    console.log(`     source -> ${rawEntry}  (note's own source: kept - no redundant snapshot)`);
+  else
+    console.log(`     snapshot -> ${rawPath}${priorSnapshot ? "  (reused — identical bytes already snapshotted)" : ""}`);
+  console.log(`     staged copy removed: ${staged}`);
+  if (unresolved)
+    console.log(`     ⚠ ${unresolved} unresolved person link(s) -> needs-review`);
+  return "filed";
+}
+var PATH_EXTS, TYPE_FOLDER, DOMAIN_FOLDERS, args, vault, inlineText, useStdin = false, slugHint = "", positional, src, text, srcBytes, isFile = false, hash, manifestKey, manifest, prior, fname, dateMatch, date, lines, META_KEYS, META, EMAIL_HEADER_KEYS, EMAIL_HEADER, SPEAKER, speakers, turnsBySpeaker, subject = "", turnCount = 0, contentLines = 0, recurringSpeaker, isTranscript, slugBasis, subjectSlug, noteSlug, rawDir, priorSnapshot, rawPath, title, people, rawRel, fm, PENDING = "<!-- semantic-clean: pending — the agent fills this. The only paid LLM step. -->", body, note, dir, effectiveSlug, notePath, unresolved;
+var init_ingest = __esm(() => {
+  init_manifest();
+  init_resolve();
+  init_roots();
+  PATH_EXTS = new Set([".txt", ".md", ".markdown", ".csv", ".json", ".log", ".pdf", ".rtf", ".html", ".htm", ".vtt", ".srt"]);
+  TYPE_FOLDER = {
+    person: "people",
+    org: "orgs",
+    holding: "holdings",
+    project: "projects",
+    event: "events",
+    mistake: "mistakes"
+  };
+  DOMAIN_FOLDERS = new Set(["identity", "health", "finances", "work", "life"]);
+  {
+    const a = process.argv.slice(2);
+    let applyVault = process.env.IMPRNT_VAULT ?? process.env.IMPRINT_VAULT ?? "./vault";
+    for (let i = 0;i < a.length; i++)
+      if (a[i] === "--vault") {
+        const v = a[++i];
+        if (v === undefined) {
+          console.error("--vault requires a directory argument");
+          process.exit(1);
+        }
+        applyVault = v;
+      }
+    if (a.includes("--apply-all")) {
+      if (!existsSync8(applyVault)) {
+        console.error(`no vault at ${applyVault} — run \`imprnt init\` first`);
+        process.exit(1);
+      }
+      try {
+        loadManifest(applyVault);
+      } catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        process.exit(1);
+      }
+      const pluginsDir = join9(projectRoot(), "plugins");
+      const staged = [];
+      if (existsSync8(pluginsDir)) {
+        for (const entry of readdirSync4(pluginsDir)) {
+          const proposed = join9(pluginsDir, entry, "proposed");
+          if (!existsSync8(proposed) || !statSync5(proposed).isDirectory())
+            continue;
+          for (const f of readdirSync4(proposed))
+            if (f.endsWith(".md"))
+              staged.push(join9(proposed, f));
+        }
+      }
+      staged.sort();
+      console.log(`ingest --apply-all — ${staged.length} staged note(s) across plugins/*/proposed/`);
+      let filed = 0, noop = 0, conflict = 0, error = 0;
+      for (const s of staged) {
+        let r;
+        try {
+          r = applyStaged(s, applyVault);
+        } catch (e) {
+          console.error(`  ✗ ${s}: ${e instanceof Error ? e.message : String(e)}`);
+          r = "error";
+        }
+        if (r === "filed")
+          filed++;
+        else if (r === "noop")
+          noop++;
+        else if (r === "conflict")
+          conflict++;
+        else
+          error++;
+      }
+      console.log(`
+${filed} filed, ${noop} no-op, ${conflict} conflict, ${error} error.`);
+      process.exit(conflict + error ? 1 : 0);
+    }
+    const applyIdx = a.indexOf("--apply");
+    if (applyIdx >= 0) {
+      const file = a[applyIdx + 1];
+      if (!file || file.startsWith("--")) {
+        console.error("usage: imprnt ingest --apply <file> [--vault DIR]");
+        process.exit(1);
+      }
+      if (!existsSync8(applyVault)) {
+        console.error(`no vault at ${applyVault} — run \`imprnt init\` first`);
+        process.exit(1);
+      }
+      console.log(`ingest --apply ${file}`);
+      const r = applyStaged(file, applyVault);
+      process.exit(r === "conflict" || r === "error" ? 1 : 0);
+    }
+  }
+  args = process.argv.slice(2);
+  vault = process.env.IMPRNT_VAULT ?? process.env.IMPRINT_VAULT ?? "./vault";
+  positional = [];
+  for (let i = 0;i < args.length; i++) {
+    if (args[i] === "--vault") {
+      const v = args[++i];
+      if (v === undefined) {
+        console.error("--vault requires a directory argument");
+        process.exit(1);
+      }
+      vault = v;
+    } else if (args[i] === "--text")
+      inlineText = args[++i];
+    else if (args[i] === "--stdin")
+      useStdin = true;
+    else if (args[i] === "--slug")
+      slugHint = args[++i];
+    else
+      positional.push(args[i]);
+  }
+  if (useStdin) {
+    srcBytes = readFileSync8(0);
+    text = srcBytes.toString("utf8");
+    src = "<stdin>";
+  } else if (inlineText !== undefined) {
+    text = inlineText;
+    srcBytes = Buffer.from(text, "utf8");
+    src = "<text>";
+  } else {
+    const arg = positional[0];
+    if (!arg) {
+      console.error('usage: imprnt ingest <file|text> [--text "<bytes>"] [--stdin] [--slug S] [--vault DIR]');
+      process.exit(1);
+    }
+    if (existsSync8(arg)) {
+      if (statSync5(arg).isDirectory()) {
+        console.error(`${arg} is a directory - ingest takes a single file; mirror a tree with \`imprnt snapshot ${arg} --dest <name>\``);
+        process.exit(1);
+      }
+      srcBytes = readFileSync8(arg);
+      text = srcBytes.toString("utf8");
+      src = arg;
+      isFile = true;
+    } else if (looksLikePath(arg)) {
+      console.error(`no such file: ${arg}`);
+      process.exit(1);
+    } else {
+      text = arg;
+      srcBytes = Buffer.from(text, "utf8");
+      src = "<text>";
+    }
+  }
+  if (!text.trim()) {
+    console.error("empty source — nothing to ingest");
+    process.exit(1);
+  }
+  hash = createHash("sha256").update(srcBytes).digest("hex").slice(0, 16);
+  manifestKey = isFile ? src : `bytes:sha256:${hash}`;
+  manifest = loadManifest(vault);
+  prior = manifest[manifestKey];
+  if (prior?.hash === hash && (!prior.note || existsSync8(prior.note)) && (!prior.raw || existsSync8(prior.raw))) {
+    console.log(`unchanged (hash ${hash}) — skipping ${src}. note: ${prior.note}`);
+    process.exit(0);
+  }
+  fname = basename2(src);
+  dateMatch = fname.match(/(\d{4}-\d{2}-\d{2})/) || text.match(/^\s*date:\s*(\d{4}-\d{2}-\d{2})/im);
+  date = dateMatch ? dateMatch[1] : new Date().toISOString().slice(0, 10);
+  lines = text.split(/\r?\n/);
+  META_KEYS = new Set(["date", "subject", "topic", "note", "notes", "attendees", "participants"]);
+  META = /^([A-Za-z][A-Za-z]*):\s*(.*)$/;
+  EMAIL_HEADER_KEYS = new Set(["from", "to", "cc", "bcc", "reply-to", "sent"]);
+  EMAIL_HEADER = /^([A-Za-z][A-Za-z-]*):\s/;
+  SPEAKER = /^([A-Z][A-Za-z.'-]+(?: [A-Z][A-Za-z.'-]+){0,2}):\s+\S.*$/;
+  speakers = new Set;
+  turnsBySpeaker = new Map;
+  for (const line of lines) {
+    const meta = line.match(META);
+    if (meta && META_KEYS.has(meta[1].trim().toLowerCase())) {
+      const key = meta[1].trim().toLowerCase();
+      if ((key === "subject" || key === "topic") && !subject)
+        subject = meta[2].trim();
+      continue;
+    }
+    const eh = line.match(EMAIL_HEADER);
+    if (eh && EMAIL_HEADER_KEYS.has(eh[1].toLowerCase()))
+      continue;
+    if (line.trim())
+      contentLines++;
+    const m = line.match(SPEAKER);
+    if (!m)
+      continue;
+    const who = m[1].trim();
+    speakers.add(who);
+    turnsBySpeaker.set(who, (turnsBySpeaker.get(who) ?? 0) + 1);
+    turnCount++;
+  }
+  recurringSpeaker = [...turnsBySpeaker.values()].some((n) => n >= 2);
+  isTranscript = isFile && looksLikeTranscript(speakers, turnCount, contentLines, recurringSpeaker);
+  slugBasis = slugHint || subject || [...speakers].join("-") || (isFile ? basename2(src, extname(src)) : text.slice(0, 60));
+  subjectSlug = slugify(slugBasis) || "source";
+  noteSlug = `${date}-${subjectSlug}`;
+  rawDir = join9(vault, "..", "raw", isTranscript ? "transcripts" : "adhoc");
+  priorSnapshot = Object.values(manifest).find((e) => e.hash === hash && e.raw && existsSync8(e.raw))?.raw;
+  if (priorSnapshot) {
+    rawPath = priorSnapshot;
+  } else {
+    const ext = isFile ? extname(src) || ".txt" : ".md";
+    const rawName = isFile ? `${date}-${subjectSlug}-${hash}${ext}` : `${subjectSlug}-${hash}${ext}`;
+    rawPath = join9(rawDir, rawName);
+    try {
+      mkdirSync2(rawDir, { recursive: true });
+      if (!existsSync8(rawPath)) {
+        if (isFile)
+          copyFileSync(src, rawPath);
+        else
+          writeFileSync6(rawPath, text);
+      }
+    } catch (e) {
+      console.error(`cannot write snapshot ${rawPath}: ${e instanceof Error ? e.message : e}`);
+      process.exit(1);
+    }
+  }
+  if (!isTranscript) {
+    manifest[manifestKey] = { hash, note: "", ingested: new Date().toISOString(), raw: rawPath };
+    saveManifest(vault, manifest);
+    flagNeedsReview(vault, `- [ ] unclassified source \`${rawPath}\` — snapshotted, needs TYPE + note`);
+    console.log(`snapshotted ${src}`);
+    console.log(`  snapshot -> ${rawPath}${priorSnapshot ? "  (reused — identical bytes already snapshotted)" : "  (immutable)"}`);
+    console.log(`  no skeleton written — not a confident transcript. next (the one LLM step):`);
+    console.log(`  read ${rawPath}, then file it: an entity -> people/ orgs/ holdings/; a held position ->`);
+    console.log(`  identity/; else by domain (health/ finances/ work/ life/). Write type + summary + tags`);
+    console.log(`  (from vault/_tags.md) + kind, and link >=1 existing entity. Then \`imprnt check\`.`);
+    process.exit(0);
+  }
+  title = subject || `1:1 — ${[...speakers].join(", ")}`;
+  people = [...speakers].map((s) => `"[[people/${slugify(s)}]]"`);
+  rawRel = "raw/" + relative3(join9(vault, "..", "raw"), rawPath).split("\\").join("/").replace(/\.md$/, "");
+  fm = [
+    "---",
+    "type: event",
+    `date: ${date}`,
+    `participants: [${people.join(", ")}]`,
+    "summary:                      # LLM writes one line — `imprnt check` reads it to build index.md",
+    "tags: []                      # LLM fills the best-fit tag (vault/_tags.md); coin a new one if none fits, check syncs it",
+    "project:                      # LLM links the project this event touched",
+    `source: "[[${rawRel}]]"`,
+    `source_hash: ${hash}`,
+    "status: draft-deterministic   # -> 'enriched' after the LLM semantic pass",
+    `ingested: ${new Date().toISOString()}`,
+    "---"
+  ].join(`
+`);
+  body = `# ${title}
+
+> ${turnCount} turns · ${speakers.size} participants · parsed deterministically. No LLM was used to produce this skeleton.
+
+## Summary
+${PENDING}
+
+## Decisions
+${PENDING}
+
+## Action items
+${PENDING}
+
+## Open questions
+${PENDING}
+
+## Participants
+${[...speakers].map((s) => `- [[people/${slugify(s)}]]`).join(`
+`) || "_none detected_"}
+
+## Source
+Snapshot: \`${rawPath}\` (sha256:${hash}), copied verbatim from \`${src}\`. Immutable — do not edit; re-ingest instead.
+`;
+  note = `${fm}
+
+${body}`;
+  dir = join9(vault, "events");
+  mkdirSync2(dir, { recursive: true });
+  effectiveSlug = noteSlug;
+  notePath = join9(dir, `${noteSlug}.md`);
+  if (existsSync8(notePath)) {
+    const existingFm = frontmatter2(readFileSync8(notePath, "utf8"));
+    const existingSourceHash = fmScalar2(existingFm, "source_hash");
+    if (existingSourceHash && existingSourceHash === hash) {
+      manifest[manifestKey] = { hash, note: notePath, ingested: new Date().toISOString(), raw: rawPath };
+      saveManifest(vault, manifest);
+      console.log(`= ${src}: event note already filed from identical bytes (hash ${hash}) — no-op`);
+      console.log(`  note kept   -> ${notePath}`);
+      process.exit(0);
+    }
+    effectiveSlug = `${noteSlug}-${hash.slice(0, 8)}`;
+    notePath = join9(dir, `${effectiveSlug}.md`);
+    flagNeedsReview(vault, `- [ ] slug collision: existing [[events/${noteSlug}]] vs new [[events/${effectiveSlug}]] (hash ${hash}); two different sources mapped to the same date+subject slug — reconcile`);
+    console.log(`! ${src}: slug \`events/${noteSlug}\` already holds a different source -> filing new note under \`events/${effectiveSlug}\``);
+    console.log(`  existing note kept untouched -> ${join9(dir, `${noteSlug}.md`)}`);
+    let counter = 1;
+    while (existsSync8(notePath)) {
+      const existingDisambigHash = fmScalar2(frontmatter2(readFileSync8(notePath, "utf8")), "source_hash");
+      if (existingDisambigHash === hash) {
+        manifest[manifestKey] = { hash, note: notePath, ingested: new Date().toISOString(), raw: rawPath };
+        saveManifest(vault, manifest);
+        console.log(`  disambiguated note already exists from identical bytes -> ${notePath}  (no-op)`);
+        process.exit(0);
+      }
+      counter++;
+      effectiveSlug = `${noteSlug}-${hash.slice(0, 8)}-${counter}`;
+      notePath = join9(dir, `${effectiveSlug}.md`);
+      console.log(`  hash8 collision with a distinct source -> trying \`events/${effectiveSlug}\` instead`);
+    }
+  }
+  writeFileSync6(notePath, note);
+  manifest[manifestKey] = { hash, note: notePath, ingested: new Date().toISOString(), raw: rawPath };
+  saveManifest(vault, manifest);
+  unresolved = [...speakers].filter((name) => !personResolved(vault, slugify(name), name));
+  for (const name of unresolved) {
+    flagNeedsReview(vault, `- [ ] unresolved person \`${name}\` — from [[events/${effectiveSlug}]] (${date})`);
+  }
+  console.log(`ingested ${src}`);
+  console.log(`  snapshot -> ${rawPath}${priorSnapshot ? "  (reused — identical bytes already snapshotted)" : "  (immutable)"}`);
+  console.log(`  note     -> ${notePath}  (${speakers.size} participants, ${turnCount} turns)`);
+  if (unresolved.length)
+    console.log(`  ⚠ ${unresolved.length} unresolved participant(s) -> needs-review: ${unresolved.join(", ")}`);
+  console.log(`  deterministic skeleton only. next (the one LLM step): the agent fills`);
+  console.log(`  summary + Summary/Decisions/Actions/Questions, assigns tags from vault/_tags.md,`);
+  console.log(`  and links people + projects (resolving the flagged participants). Then \`imprnt check\`.`);
+});
+
+// scripts/lib/tags.ts
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, existsSync as existsSync9 } from "node:fs";
+import { join as join10 } from "node:path";
+function section(text2, name) {
+  return text2.match(new RegExp(`##\\s*${name}\\s*\\n([\\s\\S]*?)(?:\\n##\\s|\\s*$)`, "i"))?.[1] ?? "";
+}
+function tagTokens(line) {
+  return line.split(",").map((s) => s.trim().normalize("NFC")).filter((s) => TAG_TOKEN.test(s));
+}
+function isTagLine(line) {
+  const t = line.trim();
+  if (t === "" || t.startsWith("##") || t.startsWith("<!--"))
+    return false;
+  const segs = t.split(",").map((s) => s.trim()).filter((s) => s !== "");
+  if (segs.length === 0)
+    return false;
+  const valid = segs.filter((s) => TAG_TOKEN.test(s)).length;
+  return valid * 2 > segs.length;
+}
+function kebab(tag) {
+  const t = tag.trim().normalize("NFC").toLowerCase().replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return TAG_TOKEN.test(t) ? t : "";
+}
+function loadTags(vault2) {
+  const approved = new Set;
+  const synonyms = new Map;
+  const p = join10(vault2, "_tags.md");
+  if (!existsSync9(p))
+    return { approved, synonyms };
+  const text2 = readFileSync9(p, "utf8");
+  for (const line of section(text2, "Tags").split(/\r?\n/)) {
+    for (const t of tagTokens(line))
+      approved.add(t.toLowerCase());
+  }
+  for (const line of section(text2, "Synonyms").split(/\r?\n/)) {
+    const m = line.match(/^(.*?)\s*->\s*(.+?)\s*$/);
+    if (!m)
+      continue;
+    const canon = kebab(m[2]);
+    if (!canon)
+      continue;
+    for (const raw of m[1].split(",")) {
+      const syn = kebab(raw);
+      if (syn)
+        synonyms.set(syn, canon);
+    }
+  }
+  return { approved, synonyms };
+}
+function normalize(vocab, term) {
+  let cur = kebab(term) || term.toLowerCase();
+  const seen = new Set([cur]);
+  for (;; ) {
+    const next = vocab.synonyms.get(cur);
+    if (next === undefined || seen.has(next))
+      return cur;
+    seen.add(next);
+    cur = next;
+  }
+}
+function appendTags(vault2, newTags) {
+  const p = join10(vault2, "_tags.md");
+  if (!existsSync9(p) || newTags.length === 0)
+    return [];
+  const { approved } = loadTags(vault2);
+  const tags = [];
+  for (const raw of newTags) {
+    const t = kebab(raw);
+    if (t && !approved.has(t) && !tags.includes(t))
+      tags.push(t);
+  }
+  if (tags.length === 0)
+    return [];
+  const text2 = readFileSync9(p, "utf8");
+  const lines2 = text2.split(`
+`);
+  const h = lines2.findIndex((l) => /^##\s*Tags\s*$/i.test(l.trim()));
+  if (h < 0) {
+    const base = text2.replace(/\s+$/, "");
+    const sec = `## Tags
+${tags.join(", ")}
+`;
+    writeFileSync7(p, base === "" ? sec : `${base}
+
+${sec}`);
+    return tags;
+  }
+  let last = -1;
+  for (let i = h + 1;i < lines2.length; i++) {
+    if (lines2[i].trim().startsWith("##"))
+      break;
+    if (isTagLine(lines2[i]))
+      last = i;
+  }
+  if (last < 0)
+    lines2.splice(h + 1, 0, tags.join(", "));
+  else
+    lines2[last] = `${lines2[last].replace(/\s+$/, "")}, ${tags.join(", ")}`;
+  writeFileSync7(p, lines2.join(`
+`));
+  return tags;
+}
+var TAG_TOKEN;
+var init_tags = __esm(() => {
+  TAG_TOKEN = /^[\p{L}\p{N}-]+$/u;
+});
+
+// scripts/recall.ts
+var exports_recall = {};
+import { lstatSync as lstatSync2, readdirSync as readdirSync5, readFileSync as readFileSync10 } from "node:fs";
+import { basename as basename3, join as join11, relative as relative4 } from "node:path";
+function walk2(dir2) {
+  const out = [];
+  for (const entry of readdirSync5(dir2)) {
+    if (entry.startsWith(".") || entry.startsWith("_"))
+      continue;
+    const p = join11(dir2, entry);
+    const rel = relative4(vault2, p);
+    if (!rel.includes("/") && !rel.includes("\\") && CONTROL2.has(rel))
+      continue;
+    try {
+      const st = lstatSync2(p);
+      if (st.isSymbolicLink())
+        continue;
+      if (st.isDirectory())
+        out.push(...walk2(p));
+      else if (entry.endsWith(".md"))
+        out.push(p);
+    } catch {
+      continue;
+    }
+  }
+  return out;
+}
+var args2, vault2, limit = 15, positional2, query, vocab, MAX_SYNONYM_NGRAM, STOPWORDS, tokenize = (text2) => text2.normalize("NFC").toLowerCase().replace(/['’]/gu, "").split(/[^\p{L}\p{N}]+/u).filter(Boolean), phraseSynonymTokens = (q) => {
+  const out = [];
+  const words = q.normalize("NFC").toLowerCase().split(/[\s-]+/).map((w) => w.replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, "")).filter(Boolean);
+  for (let n = Math.min(words.length, MAX_SYNONYM_NGRAM);n >= 2; n--) {
+    for (let i = 0;i + n <= words.length; i++) {
+      const span = words.slice(i, i + n);
+      for (const key of new Set([span.join(" "), span.join("-")])) {
+        const canon = normalize(vocab, key);
+        if (canon !== key)
+          out.push(...tokenize(canon));
+      }
+    }
+  }
+  return out;
+}, rawTerms, contentTerms, baseTerms, queryTerms, CONTROL2, files, TITLE_BOOST = 3, TAG_BOOST = 2, BODY_BOOST = 1, docs, df, N, avgdl, K1 = 1.5, B = 0.75, idf = (term) => {
+  const n = df.get(term) ?? 0;
+  return Math.max(0, Math.log(1 + (N - n + 0.5) / (n + 0.5)));
+}, bm25Term = (tf, dl, termIdf) => {
+  if (tf <= 0)
+    return 0;
+  return termIdf * (tf * (K1 + 1)) / (tf + K1 * (1 - B + B * (dl / avgdl)));
+}, variantIdf, hits, scoringGroups, shown, expanded;
+var init_recall = __esm(() => {
+  init_tags();
+  init_moc();
+  args2 = process.argv.slice(2);
+  vault2 = process.env.IMPRNT_VAULT ?? process.env.IMPRINT_VAULT ?? "./vault";
+  positional2 = [];
+  for (let i = 0;i < args2.length; i++) {
+    if (args2[i] === "--vault") {
+      const v = args2[++i];
+      if (v === undefined) {
+        console.error("--vault requires a directory argument");
+        process.exit(1);
+      }
+      vault2 = v;
+    } else if (args2[i] === "--limit") {
+      const tok = args2[++i];
+      if (tok === undefined || !/^[0-9]+$/.test(tok)) {
+        console.error("--limit must be a positive integer");
+        process.exit(1);
+      }
+      const n = parseInt(tok, 10);
+      if (!Number.isFinite(n) || n <= 0) {
+        console.error("--limit must be a positive integer");
+        process.exit(1);
+      }
+      limit = n;
+    } else
+      positional2.push(args2[i]);
+  }
+  query = positional2.join(" ").trim();
+  if (!query) {
+    console.error('usage: imprnt recall "<query>" [--vault DIR] [--limit N]');
+    process.exit(1);
+  }
+  vocab = loadTags(vault2);
+  MAX_SYNONYM_NGRAM = Math.max(1, ...[...vocab.synonyms.keys()].map((k) => k.trim().split(/[\s-]+/).filter(Boolean).length));
+  STOPWORDS = new Set([
+    "what",
+    "where",
+    "how",
+    "when",
+    "which",
+    "who",
+    "whom",
+    "whose",
+    "why",
+    "a",
+    "an",
+    "the",
+    "this",
+    "that",
+    "these",
+    "those",
+    "i",
+    "me",
+    "my",
+    "mine",
+    "myself",
+    "we",
+    "us",
+    "our",
+    "ours",
+    "you",
+    "your",
+    "yours",
+    "he",
+    "him",
+    "his",
+    "she",
+    "her",
+    "hers",
+    "it",
+    "its",
+    "they",
+    "them",
+    "their",
+    "theirs",
+    "and",
+    "or",
+    "but",
+    "nor",
+    "so",
+    "than",
+    "if",
+    "then",
+    "of",
+    "to",
+    "in",
+    "on",
+    "for",
+    "with",
+    "from",
+    "by",
+    "at",
+    "as",
+    "into",
+    "onto",
+    "about",
+    "over",
+    "under",
+    "between",
+    "through",
+    "be",
+    "am",
+    "is",
+    "are",
+    "was",
+    "were",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "done",
+    "can",
+    "could",
+    "will",
+    "would",
+    "shall",
+    "should",
+    "may",
+    "might",
+    "must",
+    "not",
+    "no",
+    "yes",
+    "there",
+    "here",
+    "think",
+    "know",
+    "believe"
+  ]);
+  rawTerms = tokenize(query);
+  contentTerms = rawTerms.filter((w) => !STOPWORDS.has(w));
+  baseTerms = contentTerms.length ? contentTerms : rawTerms;
+  queryTerms = baseTerms.map((w) => [...new Set([w, ...tokenize(normalize(vocab, w))])]);
+  for (const t of phraseSynonymTokens(query)) {
+    if (!STOPWORDS.has(t))
+      queryTerms.push([t]);
+  }
+  if (!queryTerms.length) {
+    console.error("empty query after tokenizing");
+    process.exit(1);
+  }
+  CONTROL2 = new Set(["index.md", "hot.md", "log.md", "_tags.md"]);
+  files = [];
+  try {
+    files = walk2(vault2);
+  } catch {
+    console.error(`no vault at ${vault2} — run \`imprnt init\` first`);
+    process.exit(1);
+  }
+  docs = [];
+  df = new Map;
+  for (const path of files) {
+    const raw = stripBom(readFileSync10(path, "utf8"));
+    const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    const fm2 = fmMatch?.[1] ?? "";
+    const body2 = fmMatch ? raw.slice(fmMatch.index + fmMatch[0].length) : raw;
+    const titleText = stripCode(body2).match(/^#[ \t]+(\S.*)$/m)?.[1] ?? "";
+    const aliases = fmList(fm2, "aliases").join(" ");
+    const tags = fmList(fm2, "tags").map((t) => normalize(vocab, t));
+    const tf = new Map;
+    const add = (tokens, weight) => {
+      for (const t of tokens)
+        tf.set(t, (tf.get(t) ?? 0) + weight);
+    };
+    add([...tokenize(titleText), ...tokenize(basename3(path, ".md"))], TITLE_BOOST);
+    add(tokenize(aliases), TITLE_BOOST);
+    add(tags.flatMap(tokenize), TAG_BOOST);
+    add(tokenize(body2), BODY_BOOST);
+    let len = 0;
+    for (const c of tf.values())
+      len += c;
+    docs.push({ path, tf, len });
+    for (const term of tf.keys())
+      df.set(term, (df.get(term) ?? 0) + 1);
+  }
+  N = docs.length || 1;
+  avgdl = docs.reduce((s, d) => s + d.len, 0) / N || 1;
+  variantIdf = new Map;
+  for (const group of queryTerms)
+    for (const v of group)
+      if (!variantIdf.has(v))
+        variantIdf.set(v, idf(v));
+  hits = [];
+  scoringGroups = [...queryTerms].sort((a, b) => a.length - b.length);
+  for (const d of docs) {
+    let score = 0;
+    const scored = new Set;
+    for (const group of scoringGroups) {
+      let best = 0;
+      let bestVariant = "";
+      for (const v of group) {
+        if (scored.has(v))
+          continue;
+        const s = bm25Term(d.tf.get(v) ?? 0, d.len, variantIdf.get(v) ?? 0);
+        if (s > best) {
+          best = s;
+          bestVariant = v;
+        }
+      }
+      if (best > 0) {
+        score += best;
+        scored.add(bestVariant);
+      }
+    }
+    if (score > 0)
+      hits.push({ path: relative4(vault2, d.path), score: Math.round(score * 100) / 100 });
+  }
+  hits.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
+  if (!hits.length) {
+    console.log(`no matches for "${query}" in ${vault2}`);
+    process.exit(0);
+  }
+  shown = hits.slice(0, limit);
+  expanded = queryTerms.map((g) => g.join("|")).join(" ");
+  console.log(`recall "${query}" [${expanded}] — ${hits.length} match(es)${hits.length > shown.length ? `, showing top ${shown.length}` : ""}, BM25-ranked:
+`);
+  for (const h of shown)
+    console.log(`  [${h.score.toFixed(2)}] ${h.path}`);
+  if (hits.length > shown.length) {
+    console.log(`
+  … ${hits.length - shown.length} lower-ranked hit(s) hidden. Raise with --limit if needed; usually you don't.`);
+  }
+});
+
+// scripts/snapshot.ts
+var exports_snapshot = {};
+import { readdirSync as readdirSync6, readFileSync as readFileSync11, copyFileSync as copyFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync10, statSync as statSync6, lstatSync as lstatSync3 } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import { join as join12, relative as relative5, basename as basename4, extname as extname2, resolve as resolve5, sep as sep3 } from "node:path";
+function destWithinRaw(rawRoot, dest) {
+  const rootResolved = resolve5(rawRoot);
+  const destResolved = resolve5(rootResolved, dest);
+  if (destResolved !== rootResolved && !destResolved.startsWith(rootResolved + sep3))
+    return null;
+  return destResolved;
+}
+function collect(p, base) {
+  let skippedLinks = 0;
+  const st = statSync6(p);
+  if (st.isFile())
+    return { files: [{ abs: p, rel: basename4(p) }], skippedLinks };
+  const out = [];
+  const walk3 = (dir2) => {
+    for (const entry of readdirSync6(dir2)) {
+      if (SKIP.has(entry))
+        continue;
+      const f = join12(dir2, entry);
+      const ls = lstatSync3(f);
+      if (ls.isSymbolicLink()) {
+        let target;
+        try {
+          target = statSync6(f);
+        } catch {
+          skippedLinks++;
+          continue;
+        }
+        if (target.isFile())
+          out.push({ abs: f, rel: relative5(base, f) });
+        else
+          skippedLinks++;
+        continue;
+      }
+      if (ls.isDirectory())
+        walk3(f);
+      else if (ls.isFile())
+        out.push({ abs: f, rel: relative5(base, f) });
+    }
+  };
+  walk3(p);
+  return { files: out, skippedLinks };
+}
+var args3, vault3, dest = "", positional3, src2, rawRoot, destRoot, manifest2, SKIP, files2, skippedLinks, copied = 0, unchanged = 0, disambiguated = 0;
+var init_snapshot = __esm(() => {
+  init_manifest();
+  args3 = process.argv.slice(2);
+  vault3 = process.env.IMPRNT_VAULT ?? process.env.IMPRINT_VAULT ?? "./vault";
+  positional3 = [];
+  for (let i = 0;i < args3.length; i++) {
+    if (args3[i] === "--vault") {
+      const v = args3[++i];
+      if (v === undefined) {
+        console.error("--vault requires a directory argument");
+        process.exit(1);
+      }
+      vault3 = v;
+    } else if (args3[i] === "--dest") {
+      const d = args3[++i];
+      if (d === undefined) {
+        console.error("--dest requires a path argument");
+        process.exit(1);
+      }
+      dest = d;
+    } else
+      positional3.push(args3[i]);
+  }
+  src2 = positional3[0];
+  if (!src2 || !dest) {
+    console.error("usage: imprnt snapshot <src> --dest <relpath> [--vault DIR]");
+    process.exit(1);
+  }
+  if (!existsSync10(src2)) {
+    console.error(`no such source: ${src2}`);
+    process.exit(1);
+  }
+  rawRoot = join12(vault3, "..", "raw");
+  destRoot = destWithinRaw(rawRoot, dest);
+  if (!destRoot) {
+    console.error(`refusing --dest '${dest}': it escapes raw/ (resolves outside ${resolve5(rawRoot)}). raw/ is immutable — pick a dest inside it.`);
+    process.exit(1);
+  }
+  manifest2 = loadManifest(vault3);
+  SKIP = new Set([".git", ".DS_Store", "node_modules", ".manifest.json"]);
+  ({ files: files2, skippedLinks } = collect(src2, src2));
+  for (const { abs, rel } of files2) {
+    const srcBytes2 = readFileSync11(abs);
+    const hash2 = createHash2("sha256").update(srcBytes2).digest("hex").slice(0, 16);
+    let rawPath2 = join12(destRoot, rel);
+    let key = join12("raw", dest, rel);
+    if (manifest2[key]?.hash === hash2 && existsSync10(rawPath2)) {
+      unchanged++;
+      continue;
+    }
+    if (existsSync10(rawPath2)) {
+      if (Buffer.compare(readFileSync11(rawPath2), srcBytes2) === 0) {
+        manifest2[key] = { hash: hash2, note: manifest2[key]?.note ?? "", ingested: new Date().toISOString(), raw: key, src: abs };
+        unchanged++;
+        continue;
+      }
+      const ext = extname2(rel);
+      const stem = rel.slice(0, rel.length - ext.length);
+      let relD = `${stem}-${hash2.slice(0, 8)}${ext}`;
+      let n = 2;
+      while (existsSync10(join12(destRoot, relD)) && Buffer.compare(readFileSync11(join12(destRoot, relD)), srcBytes2) !== 0) {
+        relD = `${stem}-${hash2.slice(0, 8)}-${n}${ext}`;
+        n++;
+      }
+      rawPath2 = join12(destRoot, relD);
+      key = join12("raw", dest, relD);
+      if (existsSync10(rawPath2)) {
+        manifest2[key] = { hash: hash2, note: manifest2[key]?.note ?? "", ingested: new Date().toISOString(), raw: key, src: abs };
+        unchanged++;
+        continue;
+      }
+      console.log(`  ! raw/${join12(dest, rel)} already holds different bytes - immutable, writing raw/${join12(dest, relD)} instead`);
+      disambiguated++;
+    }
+    mkdirSync3(join12(rawPath2, ".."), { recursive: true });
+    copyFileSync2(abs, rawPath2);
+    manifest2[key] = { hash: hash2, note: "", ingested: new Date().toISOString(), raw: key, src: abs };
+    copied++;
+  }
+  saveManifest(vault3, manifest2);
+  console.log(`snapshot ${src2} → raw/${dest}/`);
+  console.log(`  ${copied} copied, ${unchanged} unchanged (immutable). ${files2.length} file(s) total.`);
+  if (disambiguated)
+    console.log(`  ${disambiguated} filed under a disambiguated name - an existing raw/ snapshot is never overwritten.`);
+  if (skippedLinks)
+    console.log(`  ${skippedLinks} symlink(s) skipped (dangling or directory links).`);
+  if (copied)
+    console.log(`  next: the LLM reads raw/${dest}/ and fans sources out into vault notes (source: raw/${dest}/...).`);
+});
+
+// scripts/check.ts
+var exports_check = {};
+import { readdirSync as readdirSync7, readFileSync as readFileSync12, statSync as statSync7, existsSync as existsSync11, writeFileSync as writeFileSync8 } from "node:fs";
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { join as join13, relative as relative6, dirname as dirname3 } from "node:path";
+function resolves(target) {
+  const t = target.trim().replace(/^\.\//, "").replace(/\.md$/, "");
+  if (!t)
+    return false;
+  if (t.includes("/"))
+    return allSlugs.has(t);
+  return byBasename.has(t);
+}
+function targetFolders(target) {
+  const t = target.trim().replace(/^\.\//, "").replace(/\.md$/, "");
+  if (!t)
+    return [];
+  if (t.includes("/")) {
+    const f = folderOf.get(t);
+    return f ? [f] : [];
+  }
+  return (byBasename.get(t) ?? []).map((s) => folderOf.get(s)).filter((f) => !!f);
+}
+function linksEntity(target) {
+  return targetFolders(target).some((f) => ENTITY_FOLDERS.has(f));
+}
+function syncNeedsReview(lines2) {
+  const p = join13(vault4, "_needs-review.md");
+  const exists = existsSync11(p);
+  if (!exists && lines2.length === 0)
+    return "none";
+  const prev = exists ? readFileSync12(p, "utf8") : `---
+type: needs-review
+---
+
+# Needs review
+
+`;
+  const b = prev.indexOf(REVIEW_BEGIN);
+  const e = b !== -1 ? prev.indexOf(REVIEW_END, b + REVIEW_BEGIN.length) : -1;
+  const section2 = `${REVIEW_BEGIN}
+${lines2.join(`
+`)}
+${REVIEW_END}
+`;
+  let next;
+  if (b !== -1) {
+    const before = prev.slice(0, b);
+    let after;
+    if (e !== -1) {
+      after = prev.slice(e + REVIEW_END.length).replace(/^\n/, "");
+    } else {
+      after = prev.slice(b + REVIEW_BEGIN.length).replace(/^\n/, "");
+    }
+    next = before + (lines2.length ? section2 : "") + after;
+  } else {
+    if (lines2.length === 0)
+      return "none";
+    next = (prev.endsWith(`
+`) ? prev : prev + `
+`) + section2;
+  }
+  if (next !== prev || !exists)
+    writeFileSync8(p, next);
+  return lines2.length ? "written" : "cleared";
+}
+var args4, vault4, all = false, ENTITY_FOLDERS, DOMAIN_FOLDERS2, LINK, notes, allSlugs, folderOf, byBasename, orphans, disconnected, domainIssues, untagged, review, referencedRaw, tagVocab, hasRealTag = (tags) => tags.some((t) => /[\p{L}\p{N}]/u.test(normalize(tagVocab, t))), hasTagsFile, addedTags, dupPairs, manifest3, rawEntries, norm = (p) => p.replace(/^\.\//, "").replace(/^.*\/raw\//, "raw/").replace(/\.md$/, ""), refNorm, uncovered, REVIEW_BEGIN = "<!-- imprnt-check:begin (regenerated by `imprnt check` - do not edit between the markers) -->", REVIEW_END = "<!-- imprnt-check:end -->", cap = (xs, n = 25) => xs.slice(0, n).concat(xs.length > n ? [`  … +${xs.length - n} more`] : []), count, folders, synced, issues;
+var init_check = __esm(() => {
+  init_roots();
+  init_moc();
+  init_tags();
+  init_manifest();
+  args4 = process.argv.slice(2);
+  vault4 = process.env.IMPRNT_VAULT ?? process.env.IMPRINT_VAULT ?? "./vault";
+  for (let i = 0;i < args4.length; i++) {
+    if (args4[i] === "--vault") {
+      const v = args4[++i];
+      if (v === undefined) {
+        console.error("--vault requires a directory argument");
+        process.exit(1);
+      }
+      vault4 = v;
+    } else if (args4[i] === "--all")
+      all = true;
+  }
+  if (!existsSync11(vault4)) {
+    console.error(`no vault at ${vault4} — run \`imprnt init\` first`);
+    process.exit(1);
+  }
+  ENTITY_FOLDERS = new Set(["people", "orgs", "holdings"]);
+  DOMAIN_FOLDERS2 = new Set(["identity", "health", "finances", "work", "life"]);
+  LINK = /\[\[([^\]|#]+)(?:#[^\]|]+)?(?:\|[^\]]+)?\]\]/g;
+  notes = collectNotes(vault4);
+  allSlugs = new Set(notes.map((n) => n.slug));
+  folderOf = new Map(notes.map((n) => [n.slug, n.folder]));
+  byBasename = new Map;
+  for (const n of notes) {
+    const base = n.slug.includes("/") ? n.slug.slice(n.slug.lastIndexOf("/") + 1) : n.slug;
+    (byBasename.get(base) ?? byBasename.set(base, []).get(base)).push(n.slug);
+  }
+  orphans = [];
+  disconnected = [];
+  domainIssues = [];
+  untagged = [];
+  review = [];
+  referencedRaw = new Set;
+  tagVocab = loadTags(vault4);
+  for (const n of notes) {
+    const raw = readFileSync12(n.path, "utf8");
+    const fm2 = frontmatter(raw);
+    const links = [...stripCode(raw).matchAll(LINK)].map((m) => m[1].trim()).filter((l) => !l.startsWith("raw/"));
+    for (const l of links)
+      if (!resolves(l)) {
+        orphans.push(`  ${n.slug}  →  [[${l}]]`);
+        review.push(`- [ ] orphan link [[${l}]] — from [[${n.slug}]], target note missing`);
+      }
+    if (!ENTITY_FOLDERS.has(n.folder) && !links.some(linksEntity)) {
+      disconnected.push(`  ${n.slug}`);
+      review.push(`- [ ] disconnected note [[${n.slug}]] — links no entity`);
+    }
+    if (!hasRealTag(n.tags)) {
+      untagged.push(`  ${n.slug}`);
+      review.push(`- [ ] untagged note [[${n.slug}]] — empty tags, findable by body/title only`);
+    }
+    const domainRaw = (fm2.match(/^domain:\s*(.+)$/m)?.[1] ?? "").trim();
+    const domain = stripQuotes(/^["']/.test(domainRaw) ? domainRaw : domainRaw.replace(/\s+#.*$/, "").trim());
+    if (DOMAIN_FOLDERS2.has(n.folder) && domain !== n.folder) {
+      domainIssues.push(`  ${n.slug}  — in ${n.folder}/ but domain: ${domain || "(missing)"}`);
+      review.push(`- [ ] domain mismatch [[${n.slug}]] — in ${n.folder}/ but domain: ${domain || "(missing)"}`);
+    }
+    const src3 = fm2.match(/^source:\s*["']?(.+?)["']?\s*$/im)?.[1]?.trim().replace(/^\[\[/, "").replace(/\]\]$/, "");
+    if (src3)
+      referencedRaw.add(src3.replace(/^\.\//, ""));
+    for (const s of fmList(fm2, "sources"))
+      referencedRaw.add(s.replace(/^\[\[/, "").replace(/\]\]$/, "").replace(/^\.\//, ""));
+  }
+  hasTagsFile = existsSync11(join13(vault4, "_tags.md"));
+  addedTags = [];
+  dupPairs = [];
+  if (hasTagsFile) {
+    const vocab2 = loadTags(vault4);
+    const usedCanon = new Set;
+    for (const n of notes)
+      for (const t of n.tags) {
+        const c = normalize(vocab2, t);
+        if (c)
+          usedCanon.add(c);
+      }
+    const newTags = [...usedCanon].filter((c) => !vocab2.approved.has(c)).sort();
+    addedTags = appendTags(vault4, newTags);
+    const lev = (a, b) => {
+      const d = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+      for (let j = 0;j <= b.length; j++)
+        d[0][j] = j;
+      for (let i = 1;i <= a.length; i++)
+        for (let j = 1;j <= b.length; j++)
+          d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+      return d[a.length][b.length];
+    };
+    const DIGIT = /[0-9]/;
+    const digitOnlyEdit = (short, long) => {
+      if (short.length === long.length) {
+        const k2 = [...short].findIndex((c, i) => c !== long[i]);
+        return k2 >= 0 && DIGIT.test(short[k2]) && DIGIT.test(long[k2]);
+      }
+      let k = 0;
+      while (k < short.length && short[k] === long[k])
+        k++;
+      return DIGIT.test(long[k]);
+    };
+    const tagArr = [...new Set([...vocab2.approved, ...addedTags])].sort();
+    const byLen = new Map;
+    for (let i = 0;i < tagArr.length; i++)
+      (byLen.get(tagArr[i].length) ?? byLen.set(tagArr[i].length, []).get(tagArr[i].length)).push(i);
+    for (let i = 0;i < tagArr.length; i++) {
+      const a = tagArr[i];
+      const cand = [];
+      for (let L = a.length - 3;L <= a.length + 3; L++) {
+        const bucket = byLen.get(L);
+        if (!bucket)
+          continue;
+        for (const j of bucket)
+          if (j > i)
+            cand.push(j);
+      }
+      cand.sort((x, y) => x - y);
+      for (const j of cand) {
+        const b = tagArr[j];
+        if (normalize(vocab2, a) === normalize(vocab2, b))
+          continue;
+        const short = a.length <= b.length ? a : b, long = a.length <= b.length ? b : a;
+        const prefixDup = short.length >= 4 && long.startsWith(short) && long.length - short.length <= 3;
+        const near = short.length >= 4 && Math.abs(a.length - b.length) <= 1 && lev(a, b) <= 1 && !digitOnlyEdit(short, long);
+        if (prefixDup || near)
+          dupPairs.push(`  ${a} ~ ${b}`);
+      }
+    }
+  }
+  manifest3 = loadManifest(vault4);
+  rawEntries = Object.values(manifest3).map((e) => e.raw).filter(Boolean);
+  refNorm = new Set([...referencedRaw].map(norm));
+  uncovered = [...new Set(rawEntries.map(norm))].filter((r) => !refNorm.has(r)).sort();
+  for (const r of uncovered)
+    review.push(`- [ ] unclassified snapshot \`${r}\` — no vault note points back`);
+  console.log(`imprnt check — ${notes.length} notes in ${vault4}
+`);
+  if (orphans.length) {
+    console.log(`⚠ orphan links (${orphans.length}) — target note missing:`);
+    console.log(cap(orphans).join(`
+`), `
+`);
+  } else
+    console.log("✓ no orphan links");
+  if (disconnected.length) {
+    console.log(`⚠ disconnected notes (${disconnected.length}) — domain/form note links no entity:`);
+    console.log(cap(disconnected).join(`
+`), `
+`);
+  } else
+    console.log("✓ every domain/form note links the graph");
+  if (domainIssues.length) {
+    console.log(`⚠ domain mismatches (${domainIssues.length}) — folder ≠ domain: field:`);
+    console.log(cap(domainIssues).join(`
+`), `
+`);
+  } else
+    console.log("✓ every domain note's folder matches its domain: field");
+  if (untagged.length) {
+    console.log(`⚠ untagged notes (${untagged.length}) — no tags, findable by body/title only:`);
+    console.log(cap(untagged).join(`
+`), `
+`);
+  } else
+    console.log("✓ every note carries at least one tag");
+  if (hasTagsFile) {
+    if (addedTags.length)
+      console.log(`↑ synced ${addedTags.length} new tag(s) into _tags.md: ${addedTags.join(", ")}`);
+    else
+      console.log("✓ tag vocabulary in sync");
+    if (dupPairs.length) {
+      console.log(`⚠ candidate duplicate tags (${dupPairs.length}) — add a synonym in _tags.md to merge:`);
+      console.log(cap(dupPairs).join(`
+`), `
+`);
+    }
+  }
+  if (rawEntries.length) {
+    if (uncovered.length) {
+      console.log(`⚠ uncovered snapshots (${uncovered.length}/${new Set(rawEntries.map(norm)).size}) — raw source no note points back to:`);
+      console.log(cap(uncovered).join(`
+`), `
+`);
+    } else
+      console.log("✓ every raw snapshot has a derived note");
+  }
+  ({ count, folders } = generateIndex(vault4));
+  console.log(`↻ regenerated index.md — ${count} notes across ${folders} folders`);
+  synced = syncNeedsReview(review);
+  if (synced === "written")
+    console.log(`↻ ${review.length} finding(s) → _needs-review.md (run \`imprnt hot\` to see them)`);
+  else if (synced === "cleared")
+    console.log("↻ cleared resolved findings from _needs-review.md");
+  issues = orphans.length + disconnected.length + domainIssues.length + untagged.length + uncovered.length + dupPairs.length;
+  console.log(issues ? `
+${issues} thing(s) to look at above.` : `
+clean.`);
+  if (all) {
+    const pluginsDir = join13(projectRoot(), "plugins");
+    const checks = [];
+    if (existsSync11(pluginsDir)) {
+      for (const entry of readdirSync7(pluginsDir)) {
+        let isDir2 = false;
+        try {
+          isDir2 = statSync7(join13(pluginsDir, entry)).isDirectory();
+        } catch {
+          continue;
+        }
+        const p = join13(pluginsDir, entry, "check.js");
+        if (isDir2 && existsSync11(p))
+          checks.push(p);
+      }
+    }
+    checks.sort();
+    console.log(`
+— plugins (${checks.length}) —`);
+    if (checks.length === 0)
+      console.log("  (no plugins/*/check.js found)");
+    let failed = 0;
+    for (const checkPath of checks) {
+      const name = relative6(pluginsDir, dirname3(checkPath)).split("\\").join("/");
+      const proc = spawnSync3(process.execPath, [checkPath], { stdio: "inherit" });
+      const code = proc.status ?? 1;
+      const ok = code === 0;
+      if (!ok)
+        failed++;
+      console.log(`  ${ok ? "✓" : "✗"} plugins/${name}/check.js → exit ${code}`);
+    }
+    if (failed)
+      console.log(`
+${failed} plugin check(s) failed.`);
+    else if (checks.length)
+      console.log(`
+all plugin checks passed.`);
+    if (failed || issues)
+      process.exit(1);
+  } else if (issues) {
+    process.exit(1);
+  }
+});
+
+// scripts/cli.ts
+var exports_cli = {};
+import { cpSync as cpSync2, mkdirSync as mkdirSync4, existsSync as existsSync12, readFileSync as readFileSync13 } from "node:fs";
+import { join as join14, dirname as dirname4 } from "node:path";
+import { fileURLToPath } from "node:url";
+function vaultArg() {
+  const i = rest.indexOf("--vault");
+  if (i >= 0) {
+    const val = rest[i + 1];
+    if (val === undefined) {
+      console.error("usage: --vault <dir> (missing directory after --vault)");
+      process.exit(1);
+    }
+    return val;
+  }
+  return process.env.IMPRNT_VAULT || process.env.IMPRINT_VAULT || "./vault";
+}
+function requireVaultHome() {
+  const home = vaultProjectRoot();
+  if (!home) {
+    console.error("no vault project found — run `imprnt init` in your vault project first");
+    process.exit(1);
+  }
+  return home;
+}
+var here, pkgRoot, cmd, rest, asImp;
+var init_cli = __esm(async () => {
+  init_resolve();
+  init_plugins();
+  init_install();
+  init_roots();
+  init_moc();
+  init_registry();
+  init_launch();
+  here = dirname4(fileURLToPath(import.meta.url));
+  pkgRoot = join14(here, "..");
+  [cmd, ...rest] = process.argv.slice(2);
+  asImp = globalThis.__IMPRNT_IMP__ === true;
+  if (["ingest", "recall", "snapshot", "check"].includes(cmd))
+    process.argv.splice(2, 1);
+  switch (cmd) {
+    case "ingest":
+      await Promise.resolve().then(() => (init_ingest(), exports_ingest));
+      break;
+    case "recall":
+      await Promise.resolve().then(() => (init_recall(), exports_recall));
+      break;
+    case "snapshot":
+      await Promise.resolve().then(() => (init_snapshot(), exports_snapshot));
+      break;
+    case "check":
+      await Promise.resolve().then(() => (init_check(), exports_check));
+      break;
+    case "hot": {
+      const vault5 = vaultArg();
+      const review2 = openNeedsReview(vault5);
+      if (review2.length) {
+        console.log(`⚠ NEEDS REVIEW (${review2.length}) — clear these:`);
+        for (const r of review2)
+          console.log(r);
+        console.log("");
+      }
+      const p = join14(vault5, "hot.md");
+      if (!existsSync12(p)) {
+        console.error(`no hot.md at ${p} — run \`imprnt init\``);
+        process.exit(1);
+      }
+      console.log(readFileSync13(p, "utf8"));
+      break;
+    }
+    case "lair": {
+      const home = requireVaultHome();
+      process.exit(launchClaude(home, rest, childEnv(home)));
+    }
+    case "context": {
+      const home = requireVaultHome();
+      const contract = join14(home, "CLAUDE.md");
+      if (!existsSync12(contract)) {
+        console.error(`no CLAUDE.md at ${home} — run \`imprnt init\` there to drop the contract`);
+        process.exit(1);
+      }
+      process.stdout.write(readFileSync13(contract, "utf8"));
+      break;
+    }
+    case "plugin": {
+      const proj = projectRoot();
+      const [sub, ...specs] = rest;
+      if (sub === "list") {
+        const dirs = listPluginDirs(proj);
+        console.log("plugins:");
+        if (!dirs.length)
+          console.log("  (none installed under plugins/)");
+        for (const name of dirs)
+          console.log(`  ${isEnabled(proj, name) ? "[on] " : "[off]"} ${name}`);
+        const available = OFFICIAL.filter((o) => !dirs.includes(o));
+        if (available.length)
+          console.log(`
+available to add: ${available.join(", ")}`);
+        console.log(`
+enable: imprnt plugin add <name>   disable: imprnt plugin rm <name> [--purge]`);
+        break;
+      }
+      if (sub === "add") {
+        let from;
+        let force = false;
+        const names = [];
+        for (let i = 0;i < specs.length; i++) {
+          if (specs[i] === "--from") {
+            from = specs[++i];
+            if (from === undefined) {
+              console.error("usage: --from <dir> (missing directory after --from)");
+              process.exit(1);
+            }
+          } else if (specs[i] === "--force")
+            force = true;
+          else
+            names.push(specs[i]);
+        }
+        if (!names.length) {
+          console.error("usage: imprnt plugin add <name> [--from <dir>] [--force] | <name>/<file.md>");
+          process.exit(1);
+        }
+        if (from !== undefined && names.length > 1) {
+          console.error(`--from installs one local plugin - name exactly one (got: ${names.join(", ")})`);
+          process.exit(1);
+        }
+        const channel = coreChannel(pkgRoot);
+        let failed = false;
+        for (const name of names) {
+          try {
+            if (name.includes("/")) {
+              const { entry: entry2, added: added2, error: error2 } = addPlugin(proj, name);
+              if (error2) {
+                console.error(`${name}: ${error2}`);
+                failed = true;
+                continue;
+              }
+              console.log(added2 ? `wired @${entry2}` : `already wired @${entry2}`);
+              continue;
+            }
+            const r = installPlugin(proj, name, { from, force, channel });
+            if (r.error) {
+              console.error(`${name}: ${r.error}`);
+              failed = true;
+              continue;
+            }
+            if (r.copied)
+              console.log(`installed ${name} → plugins/${name}/`);
+            else if (r.skipped)
+              console.log(`plugins/${name}/ already present (use --force to refresh)`);
+            const { entry, added, error } = addPlugin(proj, name);
+            if (error) {
+              console.error(`${name}: ${error}${r.copied ? ` (plugins/${name}/ is installed but not wired)` : ""}`);
+              failed = true;
+              continue;
+            }
+            console.log(added ? `wired @${entry}` : `already wired @${entry}`);
+          } catch (e) {
+            console.error(`${name}: ${e instanceof Error ? e.message : String(e)}`);
+            failed = true;
+          }
+        }
+        if (failed)
+          process.exit(1);
+        break;
+      }
+      if (sub === "rm") {
+        let purge = false;
+        const names = [];
+        for (const s of specs) {
+          if (s === "--purge")
+            purge = true;
+          else
+            names.push(s);
+        }
+        if (!names.length) {
+          console.error("usage: imprnt plugin rm <name> [--purge] [<name> ...]");
+          process.exit(1);
+        }
+        let failed = false;
+        for (const name of names) {
+          try {
+            const invalid = specError(proj, name);
+            if (invalid) {
+              console.error(`${name}: ${invalid}`);
+              failed = true;
+              continue;
+            }
+            const removed = rmPlugin(proj, name);
+            let msg = removed ? `unwired ${name} (${removed} line${removed === 1 ? "" : "s"})` : `${name} was not wired`;
+            if (purge)
+              msg += purgePlugin(proj, name) ? `, purged plugins/${name}/` : `, nothing to purge`;
+            console.log(msg);
+          } catch (e) {
+            console.error(`${name}: ${e instanceof Error ? e.message : String(e)}`);
+            failed = true;
+          }
+        }
+        if (failed)
+          process.exit(1);
+        break;
+      }
+      console.error("usage: imprnt plugin list | add <name> [--from <dir>] [--force] | rm <name> [--purge]");
+      process.exit(1);
+    }
+    case "init": {
+      const enclosing = projectRoot();
+      if (enclosing !== process.cwd() && isVaultProject(enclosing)) {
+        console.error(`refusing to init: this directory is inside the vault project at ${enclosing} - run \`imprnt init\` there instead`);
+        process.exit(1);
+      }
+      const entities = ["people", "orgs", "holdings"];
+      const domains = ["identity", "health", "finances", "work", "life", "projects"];
+      const forms = ["events", "mistakes"];
+      const vaultDirs = [...entities, ...domains, ...forms];
+      const vaultPath = join14(process.cwd(), "vault");
+      const vaultExisted = existsSync12(vaultPath);
+      let createdDirs = 0;
+      for (const d of ["vault", ...vaultDirs.map((t) => `vault/${t}`), "raw"]) {
+        const abs = join14(process.cwd(), d);
+        if (!existsSync12(abs))
+          createdDirs++;
+        try {
+          mkdirSync4(abs, { recursive: true });
+        } catch (e) {
+          console.error(`cannot create ./${d}: ${e instanceof Error ? e.message : String(e)}`);
+          process.exit(1);
+        }
+      }
+      const added = [];
+      for (const f of ["index.md", "hot.md", "log.md", "_tags.md"]) {
+        const dst = join14(vaultPath, f);
+        if (!existsSync12(dst)) {
+          cpSync2(join14(pkgRoot, "templates", f), dst);
+          added.push(`vault/${f}`);
+        }
+      }
+      const claudeMd = join14(process.cwd(), "CLAUDE.md");
+      if (!existsSync12(claudeMd) && existsSync12(join14(pkgRoot, "CLAUDE.md"))) {
+        cpSync2(join14(pkgRoot, "CLAUDE.md"), claudeMd);
+        added.push("CLAUDE.md");
+      }
+      const reg = registerVault(process.cwd(), { force: rest.includes("--register") });
+      if (reg.status === "registered")
+        console.log(`registered as imp's default vault project (${configPath()})`);
+      else if (reg.status === "kept")
+        console.log(`kept the existing default vault project (${reg.current}) — run \`imprnt init --register\` here to switch`);
+      else if (reg.status === "error")
+        console.error(`could not register as imp's default vault project (${configPath()}): ${reg.error} — the vault still works via ./vault or IMPRNT_VAULT`);
+      if (!vaultExisted) {
+        console.log("initialized vault at ./vault");
+        console.log(`  entities: ${entities.join(", ")}`);
+        console.log(`  domains:  ${domains.join(", ")}`);
+        console.log(`  forms:    ${forms.join(", ")}`);
+        console.log("  + raw/ for immutable by-source snapshots");
+        console.log("next: type `imp` to talk, or ingest a source (`imprnt ingest <file>`), then `imprnt check`.");
+      } else {
+        const noteCount = collectNotes(vaultPath).length;
+        console.log(`found existing vault at ./vault — ${noteCount} note${noteCount === 1 ? "" : "s"}, left untouched`);
+        if (added.length)
+          console.log(`  added missing control file${added.length === 1 ? "" : "s"}: ${added.join(", ")}`);
+        else if (createdDirs)
+          console.log(`  added ${createdDirs} missing folder${createdDirs === 1 ? "" : "s"}`);
+        else
+          console.log("  already initialized — nothing to add");
+        console.log("run `imprnt check` to validate the graph.");
+      }
+      break;
+    }
+    default: {
+      const isHelp = cmd === "help" || cmd === "--help" || cmd === "-h";
+      const bare = cmd === undefined;
+      const wantsLaunch = asImp && !isHelp && (bare || cmd.startsWith("-"));
+      if (wantsLaunch && (!bare || process.stdin.isTTY && process.stdout.isTTY)) {
+        const home = vaultProjectRoot();
+        if (!home) {
+          console.error("imp: no vault registered yet — run `imprnt init` in your vault project to give your assistant a memory. Launching plain claude.");
+        }
+        const { args: args5, env } = buildLaunch({ cwd: process.cwd(), vaultProject: home, pkgRoot, passthrough: bare ? [] : [cmd, ...rest] });
+        process.exit(launchClaude(process.cwd(), args5, env));
+      }
+      console.log(`imprnt — deterministic-first markdown knowledge vault
+
+the front door (the \`imp\` bin):
+  imp                                      open your assistant HERE: claude + your cast + the vault pointer
+  imp lair                                 open it in your vault project — full contract, resumable history
+  imp -c | --resume | <claude flags>       flags pass through to claude
+
+engine (same subcommands under \`imp\` or \`imprnt\`):
+  imprnt init [--register]                 scaffold ./vault (entities/domains/forms) and ./raw, register as imp's default vault
+  imprnt snapshot <src> --dest <relpath>   mirror a file/dir into raw/<relpath> (immutable, hashed) — the migration's deterministic half
+  imprnt ingest <file|text> [--vault D]    snapshot a source -> raw/; a transcript file also gets an event skeleton (no LLM)
+  imprnt recall "<query>" [--vault D]      synonym-aware BM25 ranking over the vault
+  imprnt context                           print the vault contract — agents run this before writing any note
+  imprnt check [--all] [--vault D]         integrity (orphan links, disconnected notes, uncovered snapshots) + regenerate index.md; --all also runs each plugins/*/check.js
+  imprnt ingest --apply <file> [--vault D] file a pre-enriched staged note from a plugin into the vault (snapshot + resolve); --apply-all globs plugins/*/proposed/
+  imprnt hot [--vault D]                   needs-review + the session primer
+  imprnt plugin list                       show installed plugins (on/off) + official ones available to add
+  imprnt plugin add <name> [--from D]      fetch imprnt-plugin-<name>, copy into plugins/, wire it (idempotent; --force refreshes)
+  imprnt plugin rm <name> [--purge]        unwire a plugin; --purge also deletes plugins/<name>/
+
+layout: entities (people · orgs · holdings) · domains (identity · health · finances · work · life · projects) · forms (events · mistakes)
+the vault is plain markdown. an agent greps it directly — no MCP, no DB.`);
+      if (cmd && !isHelp)
+        process.exit(1);
+    }
+  }
+});
+await init_cli();