@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.2

package/dist/chunk-T6AIP7H5.js

@@ -0,0 +1,3851 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  dotInt8,
+  textSha
+} from "./chunk-CNUKCS2T.js";
+import {
+  Question,
+  RECORD_KINDS,
+  RecordId,
+  changesDirOf,
+  deserializeRecord,
+  identifierWords,
+  knowledgeDirOf,
+  knowledgeKindOf,
+  layoutOf,
+  orgPackDirOf,
+  parseRecord,
+  questionsDirOf,
+  recordReferences,
+  require_dist,
+  serializeRecord,
+  specsDirOf,
+  specsRelOf,
+  splitForms,
+  stateDirOf,
+  toCanonicalYaml
+} from "./chunk-S2A7YC3Q.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/index/dist/query.js
+var QueryError = class extends Error {
+  at;
+  constructor(message, at) {
+    super(message);
+    this.at = at;
+    this.name = "QueryError";
+  }
+};
+var FIELD = /^[A-Za-z][A-Za-z0-9]*(\.[A-Za-z][A-Za-z0-9]*)*$/;
+var KINDS = new Map(RECORD_KINDS.map((k) => [k.toLowerCase(), k]));
+function kindNamed(value) {
+  return KINDS.get(value.toLowerCase());
+}
+function tokens(text) {
+  const out = [];
+  let i = 0;
+  while (i < text.length) {
+    while (i < text.length && /\s/.test(text[i]))
+      i++;
+    if (i >= text.length)
+      break;
+    const at = i;
+    let quoted = false;
+    let t = "";
+    while (i < text.length && (quoted || !/\s/.test(text[i]))) {
+      if (text[i] === '"')
+        quoted = !quoted;
+      t += text[i];
+      i++;
+    }
+    if (quoted)
+      throw new QueryError(`A quoted value starting at ${at + 1} has no closing quote`, at);
+    out.push({ text: t, at });
+  }
+  return out;
+}
+function values(raw) {
+  const out = [];
+  let quoted = false;
+  let cur = "";
+  for (const c of raw) {
+    if (c === '"')
+      quoted = !quoted;
+    else if (c === "," && !quoted) {
+      out.push(cur);
+      cur = "";
+    } else
+      cur += c;
+  }
+  out.push(cur);
+  return out.filter((v) => v !== "");
+}
+function parseQuery(text) {
+  const terms = [];
+  for (const tok of tokens(text)) {
+    let t = tok.text;
+    const neg = t.startsWith("-");
+    if (neg)
+      t = t.slice(1);
+    if (t === "")
+      throw new QueryError(`There is nothing after "-" at ${tok.at + 1}`, tok.at);
+    const colon = t.startsWith('"') ? -1 : t.indexOf(":");
+    if (colon < 0) {
+      terms.push({ neg, type: "text", values: values(t) });
+      continue;
+    }
+    const name = t.slice(0, colon);
+    const rest = t.slice(colon + 1);
+    if (name === "has" || name === "missing") {
+      if (rest === "")
+        throw new QueryError(`"${name}:" needs a field, e.g. ${name}:owner`, tok.at);
+      if (!FIELD.test(rest))
+        throw new QueryError(`"${rest}" is not a field: field names are letters and digits, with "." for nested fields`, tok.at);
+      terms.push({ neg, type: name, field: rest });
+      continue;
+    }
+    const vs = values(rest);
+    if (vs.length === 0)
+      throw new QueryError(`"${name}:" needs a value, e.g. ${name}:something`, tok.at);
+    if (name === "refs" || name === "refby") {
+      terms.push({ neg, type: name, values: vs });
+      continue;
+    }
+    if (!FIELD.test(name))
+      throw new QueryError(`"${name}" is not a field: field names are letters and digits, with "." for nested fields`, tok.at);
+    if (name === "kind") {
+      for (const v of vs)
+        if (!v.includes("*") && !kindNamed(v))
+          throw new QueryError(`Unknown kind "${v}". Kinds: ${RECORD_KINDS.join(", ")}`, tok.at);
+    }
+    terms.push({ neg, type: "field", field: name, values: vs });
+  }
+  return terms;
+}
+function glob(v) {
+  return v.toLowerCase().replace(/[[?]/g, (c) => `[${c}]`);
+}
+var VALUE = `lower(CASE je.type WHEN 'true' THEN 'true' WHEN 'false' THEN 'false' ELSE CAST(je.value AS TEXT) END)`;
+function compileQuery(terms) {
+  const parts = [];
+  const params = [];
+  for (const t of terms) {
+    let sql;
+    if (t.type === "field" && t.field === "kind") {
+      const ors = t.values.map((v) => {
+        params.push(glob(v));
+        return "lower(r.kind) GLOB ?";
+      });
+      sql = `(${ors.join(" OR ")})`;
+    } else if (t.type === "field" && t.field === "system") {
+      const ors = t.values.map((v) => {
+        params.push(glob(v));
+        return "lower(coalesce(r.system, '')) GLOB ?";
+      });
+      sql = `(${ors.join(" OR ")})`;
+    } else if (t.type === "field") {
+      params.push(`$.${t.field}`);
+      const ors = t.values.map((v) => {
+        params.push(glob(v));
+        return `${VALUE} GLOB ?`;
+      });
+      sql = `EXISTS (SELECT 1 FROM json_each(r.json, ?) je WHERE ${ors.join(" OR ")})`;
+    } else if (t.type === "has" || t.type === "missing") {
+      params.push(`$.${t.field}`);
+      sql = `EXISTS (SELECT 1 FROM json_each(r.json, ?) je WHERE je.type <> 'null')`;
+      if (t.type === "missing")
+        sql = `NOT ${sql}`;
+    } else if (t.type === "refs") {
+      sql = `EXISTS (SELECT 1 FROM refs x WHERE x.from_kind = r.kind AND x.from_id = r.id AND x.to_id IN (${t.values.map(() => "?").join(", ")}))`;
+      params.push(...t.values);
+    } else if (t.type === "refby") {
+      sql = `EXISTS (SELECT 1 FROM refs x WHERE x.to_id = r.id AND x.from_id IN (${t.values.map(() => "?").join(", ")}))`;
+      params.push(...t.values);
+    } else {
+      const ors = t.values.map((v) => {
+        params.push(`%${v.toLowerCase()}%`, `%${v.toLowerCase()}%`);
+        return "(lower(r.id) LIKE ? OR lower(r.name) LIKE ?)";
+      });
+      sql = `(${ors.join(" OR ")})`;
+    }
+    parts.push(t.neg ? `NOT ${sql}` : sql);
+  }
+  return { where: parts.length > 0 ? parts.join(" AND ") : "1", params };
+}
+
+// packages/index/dist/select.js
+import { createHash as createHash2 } from "node:crypto";
+
+// packages/index/dist/sources.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile, stat } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+
+// packages/index/dist/gaps.js
+var GAP_STEP = "context-gap";
+function gapQuestion(name) {
+  return `The change names "${name}", and nothing Atticus has read says what it is: no catalog record, knowledge item, flow, wiki section or answered question. What is ${name}, who owns it, and where is it described?`;
+}
+function gapNameOf(q) {
+  if (q.askedBy.step !== GAP_STEP)
+    return void 0;
+  return /^The change names "([^"]+)"/.exec(q.question)?.[1];
+}
+
+// packages/index/dist/sources.js
+var toPosix = (p) => p.split(sep).join("/");
+var rel = (root, abs) => toPosix(relative(root, abs));
+var str = (v) => typeof v === "string" && v.trim() ? v : void 0;
+var arr = (v) => Array.isArray(v) ? v : [];
+var foldName = (s) => s.replace(/[‘’]/g, "'").replace(/\s+/g, " ").trim().toLowerCase();
+function endpointName(method, path) {
+  const p = path.replace(/\?.*$/, "").replace(/\{[^}]*\}/g, "{}").replace(/(.)\/$/, "$1");
+  return `${method.toLowerCase()} ${p.toLowerCase()}`;
+}
+async function walk(dir, test, out, skipDirs = /* @__PURE__ */ new Set()) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const full = join(dir, e.name);
+    if (e.isDirectory()) {
+      if (!skipDirs.has(e.name))
+        await walk(full, test, out, skipDirs);
+    } else if (test(e.name))
+      out.push(full);
+  }
+}
+var YAML = (n) => /\.ya?ml$/.test(n);
+var CATALOG_DIRS = ["catalog/generated", "catalog/curated"];
+var INPUTS_SOURCE = "inputs";
+async function inputsSkipped(kdir) {
+  const dir = join(kdir, "snapshots", INPUTS_SOURCE);
+  const newest = (await readdir(dir).catch(() => [])).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().at(-1);
+  if (!newest)
+    return /* @__PURE__ */ new Set();
+  try {
+    const m = (0, import_yaml.parse)(await readFile(join(dir, newest, "snapshot.yaml"), "utf8"));
+    return new Set((m?.skipped ?? []).map((x) => typeof x?.page === "string" ? x.page.replace(/\\/g, "/") : "").filter(Boolean).map((p) => p.startsWith("inputs/") ? p : `inputs/${p}`));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function scannedPages(kdir) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const r = (0, import_yaml.parse)(await readFile(join(kdir, "scan.yaml"), "utf8"));
+    for (const s of r?.snapshots ?? [])
+      if (typeof s?.source === "string" && s.hashes && typeof s.hashes === "object")
+        out.set(s.source, new Set(Object.keys(s.hashes)));
+  } catch {
+  }
+  return out;
+}
+async function wikiPagesToIndex(dir, source, scanned) {
+  let pages;
+  try {
+    const m = (0, import_yaml.parse)(await readFile(join(dir, "snapshot.yaml"), "utf8"));
+    pages = (m?.pages ?? []).flatMap((p) => typeof p?.page === "string" && typeof p.file === "string" ? [
+      {
+        page: p.page,
+        file: p.file.replace(/\\/g, "/"),
+        ...typeof p.in === "string" && /^\d{4}-\d{2}-\d{2}$/.test(p.in) ? { in: p.in } : {}
+      }
+    ] : []);
+  } catch {
+    return void 0;
+  }
+  const read = scanned.get(source);
+  const out = [];
+  for (const p of pages) {
+    if (read && !read.has(p.page))
+      continue;
+    const f = join(p.in ? join(dir, "..", p.in) : dir, ...p.file.split("/"));
+    if (await stat(f).catch(() => void 0))
+      out.push(f);
+  }
+  return out;
+}
+async function listSources(root) {
+  const found = [];
+  const add = (source) => (files) => found.push(...files.map((abs) => ({ abs, source })));
+  const catalog = layoutOf(root).catalog;
+  for (const d of CATALOG_DIRS) {
+    const files = [];
+    await walk(join(root, ...d.replace(/^catalog\//, `${catalog}/`).split("/")), YAML, files);
+    add("catalog")(files);
+  }
+  const kdir = knowledgeDirOf(root);
+  {
+    const files = [];
+    await walk(join(kdir, "items"), YAML, files);
+    add("knowledge")(files);
+  }
+  {
+    const files = [];
+    await walk(join(kdir, "reviews"), YAML, files);
+    add("review")(files);
+  }
+  {
+    const files = [];
+    await walk(specsDirOf(root), (n) => YAML(n) && n !== "spec.yaml" && n !== "findings.yaml", files);
+    add("flow")(files.filter((f) => dirname(f) !== specsDirOf(root)));
+  }
+  {
+    const dir = changesDirOf(root);
+    const ids = (await readdir(dir, { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory() && d.name !== "archive").map((d) => d.name);
+    for (const id of ids) {
+      const files = [];
+      for (const f of ["change.yaml", "brief.md", "proposal.md", "feature.yaml", "needs.yaml"])
+        files.push(join(dir, id, f));
+      await walk(join(dir, id, "target-flows"), YAML, files);
+      await walk(join(dir, id, "inputs", "read"), (n) => n.endsWith(".md"), files);
+      const exist = [];
+      for (const f of files)
+        if (await stat(f).catch(() => void 0))
+          exist.push(f);
+      add("change")(exist);
+    }
+    const archive = join(dir, "archive");
+    for (const d of await readdir(archive, { withFileTypes: true }).catch(() => [])) {
+      if (!d.isDirectory())
+        continue;
+      for (const f of ["brief.md", "proposal.md"])
+        if (await stat(join(archive, d.name, f)).catch(() => void 0)) {
+          add("change")([join(archive, d.name, f)]);
+          break;
+        }
+    }
+  }
+  {
+    const files = [];
+    await walk(questionsDirOf(root), YAML, files);
+    add("question")(files);
+  }
+  {
+    const sdir = join(kdir, "snapshots");
+    const scanned = await scannedPages(kdir);
+    const sources = (await readdir(sdir, { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory());
+    for (const s of sources) {
+      if (s.name === INPUTS_SOURCE)
+        continue;
+      const dates = (await readdir(join(sdir, s.name), { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(d.name)).map((d) => d.name).sort();
+      const newest = dates.at(-1);
+      if (!newest)
+        continue;
+      const dir = join(sdir, s.name, newest);
+      const listed = await wikiPagesToIndex(dir, s.name, scanned);
+      if (listed)
+        add("wiki")(listed);
+      else {
+        const files = [];
+        await walk(dir, (n) => /\.(md|markdown)$/i.test(n), files);
+        add("wiki")(files);
+      }
+    }
+  }
+  {
+    const files = [];
+    await walk(join(orgPackDirOf(root), "profiles"), (n) => n === "profile.yaml" || n === "repos.manifest.yaml", files);
+    add("profile")(files);
+  }
+  {
+    const files = [];
+    await walk(join(root, "inputs"), (n) => DOCUMENT_EXTENSIONS.test(n), files);
+    const skipped = await inputsSkipped(kdir);
+    add("document")(files.filter((f) => !skipped.has(rel(root, f))));
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of found) {
+    const path = rel(root, f.abs);
+    if (seen.has(path))
+      continue;
+    seen.add(path);
+    const s = await stat(f.abs).catch(() => void 0);
+    if (!s)
+      continue;
+    out.push({ path, source: f.source, size: s.size, mtimeMs: Math.floor(s.mtimeMs) });
+  }
+  return out.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+function labelOf(r) {
+  for (const f of ["name", "title", "term", "pathOrTopic", "key", "raw"])
+    if (typeof r[f] === "string" && r[f])
+      return r[f];
+  if (r.kind === "Interface")
+    return `${String(r.from)} \u2192 ${String(r.to)}${r.method ? ` ${String(r.method)}` : ""} ${String(r.normalizedPath ?? "")}`.trim();
+  return String(r.id);
+}
+function prose(v, out = [], depth = 0) {
+  if (depth > 6 || out.length > 400)
+    return out;
+  if (typeof v === "string")
+    out.push(v);
+  else if (Array.isArray(v))
+    for (const x of v)
+      prose(x, out, depth + 1);
+  else if (v && typeof v === "object") {
+    for (const [k, x] of Object.entries(v))
+      if (!["evidence", "sha256", "hash", "schemaVersion", "status", "confidence"].includes(k))
+        prose(x, out, depth + 1);
+  }
+  return out;
+}
+var idWords = (id) => `${id} ${id.replace(/[^A-Za-z0-9]+/g, " ")}`;
+function cites(r) {
+  for (const e of arr(r.evidence)) {
+    const p = str(e.path);
+    if (p)
+      return `${e.repo ? `${String(e.repo)}/` : ""}${p}${typeof e.line === "number" ? `:${e.line}` : ""}`;
+  }
+  const q = r.quote;
+  if (q && str(q.page))
+    return `${String(q.source)}/${String(q.page)}${q.section ? `#${String(q.section)}` : ""}`;
+  return void 0;
+}
+var NAMED_KINDS = /* @__PURE__ */ new Set(["System", "Component", "Party", "Product", "DataStore", "Capability"]);
+function recordLine(r, label) {
+  const k = String(r.kind);
+  const id = String(r.id);
+  let s;
+  if (k === "System")
+    s = `system ${id} "${label}"${str(r.boundary) ? ` (${String(r.boundary)})` : ""}${str(r.owner) ? `, owner ${String(r.owner)}` : ""}`;
+  else if (k === "Component")
+    s = `component ${id}: system ${str(r.system) ?? "?"}${str(r.repo) ? `, repo ${String(r.repo)}` : ""}${str(r.type) ? `, ${String(r.type)}` : ""}`;
+  else if (k === "Endpoint")
+    s = `endpoint ${id}: ${str(r.component) ?? "?"} serves ${str(r.method) ?? ""} ${str(r.pathOrTopic) ?? ""}`;
+  else if (k === "Interface")
+    s = `interface ${id}: ${String(r.from)} calls ${String(r.to)}${str(r.method) ? ` ${String(r.method)}` : ""} ${str(r.normalizedPath) ?? ""}${str(r.via) ? ` via ${String(r.via)}` : ""}`;
+  else {
+    const kk = knowledgeKindOf(r);
+    if (kk)
+      s = `${kk} ${id} "${label}"${str(r.appliesWhen) ? `: applies when ${String(r.appliesWhen)}` : ""}`;
+    else
+      s = `${k.toLowerCase()} ${id}${label !== id ? ` "${label}"` : ""}`;
+  }
+  const c = cites(r);
+  return `${s.replace(/ {2,}/g, " ").trim()}${c ? ` [${c}]` : ""}`;
+}
+function recordNode(r, file, grp) {
+  const x = r;
+  const label = labelOf(x);
+  const key = `${grp}:${r.kind}:${r.id}`;
+  const names = [{ name: foldName(r.id), id: r.id, kind: r.kind, how: "id" }];
+  const aliases = arr(x.aliases).filter((a) => typeof a === "string");
+  if (label !== r.id && (NAMED_KINDS.has(r.kind) || grp === "knowledge"))
+    names.push({ name: foldName(label), id: r.id, kind: r.kind, how: `name:${grp}` });
+  for (const a of aliases)
+    names.push({ name: foldName(a), id: r.id, kind: r.kind, how: `alias:${grp}` });
+  if (r.kind === "Endpoint" && str(x.method) && str(x.pathOrTopic))
+    names.push({
+      name: endpointName(String(x.method), String(x.pathOrTopic)),
+      id: r.id,
+      kind: r.kind,
+      how: "endpoint"
+    });
+  if (r.kind === "Interface" && str(x.method) && str(x.normalizedPath))
+    names.push({
+      name: endpointName(String(x.method), String(x.normalizedPath)),
+      id: r.id,
+      kind: r.kind,
+      how: "call"
+    });
+  const links = [];
+  for (const ref of recordReferences(r))
+    links.push({ from: key, to: ref.id, by: "id", type: "ref", how: `field:${ref.field}` });
+  if (r.kind === "GlossaryTerm") {
+    if (str(x.term) && foldName(String(x.term)) !== foldName(r.id))
+      names.push({ name: foldName(String(x.term)), id: r.id, kind: r.kind, how: `name:${grp}` });
+    for (const f of arr(x.fields))
+      if (typeof f === "string")
+        links.push({ from: key, to: f, by: "id", type: "defines", how: "field:fields" });
+  }
+  if (r.kind === "CuratedDecision" && x.action === "alias") {
+    for (const v of typeof x.value === "string" ? [x.value] : arr(x.value))
+      if (typeof v === "string" && v.trim())
+        names.push({ name: foldName(v), id: String(x.target), kind: "", how: "alias:curated" });
+  }
+  if (grp === "knowledge") {
+    for (const s of arr(x.systems))
+      if (typeof s === "string")
+        links.push({ from: key, to: s, by: "id", type: "names", how: "field:systems" });
+    const l = x.links;
+    if (l) {
+      for (const f of ["systems", "interfaces"])
+        for (const s of arr(l[f]))
+          if (typeof s === "string")
+            links.push({ from: key, to: s, by: "id", type: "names", how: `field:links.${f}` });
+    }
+    const quotes = [x.quote, ...arr(x.alsoOn)];
+    quotes.forEach((q, i) => {
+      if (q && str(q.source) && str(q.page))
+        links.push({
+          from: key,
+          to: sectionId(String(q.source), pageFile(String(q.page)), str(q.section) ?? ""),
+          by: "id",
+          type: "quotes",
+          how: i === 0 ? "field:quote" : "field:alsoOn"
+        });
+    });
+  }
+  const body = prose(x).filter((s) => s !== r.id && s !== label).join("\n").slice(0, 6e3);
+  return {
+    nodes: [
+      {
+        key,
+        kind: r.kind,
+        id: r.id,
+        grp,
+        name: label,
+        file,
+        verified: r.confidence === "verified",
+        line: recordLine(x, label),
+        detail: serializeRecord(r),
+        names: [label, ...aliases].join("\n"),
+        ids: idWords(r.id),
+        body,
+        mentions: grp === "knowledge",
+        json: JSON.stringify(r)
+      }
+    ],
+    names,
+    links
+  };
+}
+var pageFile = (page) => /\.(md|markdown)$/i.test(page) ? page : `${page}.md`;
+var sectionId = (source, page, heading) => `${source}/${page}#${heading}`;
+function flowNodes(text, file) {
+  let data;
+  try {
+    data = (0, import_yaml.parse)(text);
+  } catch (e) {
+    return { nodes: [], names: [], links: [], problem: e.message.split("\n")[0] };
+  }
+  const r = parseRecord(data);
+  if (!r.ok)
+    return {
+      nodes: [],
+      names: [],
+      links: [],
+      problem: r.issues.map((i) => `${i.path || "(top)"}: ${i.message}`).join("; ")
+    };
+  if (r.record.kind !== "Flow")
+    return { nodes: [], names: [], links: [], problem: `is a ${r.record.kind}, not a Flow` };
+  const f = r.record;
+  const key = `flow:Flow:${f.id}`;
+  const nodes = [];
+  const links = [
+    { from: key, to: f.component, by: "id", type: "ref", how: "field:component" }
+  ];
+  if (f.trigger.ref)
+    links.push({ from: key, to: f.trigger.ref, by: "id", type: "ref", how: "field:trigger.ref" });
+  if (f.trigger.caller?.ref)
+    links.push({
+      from: key,
+      to: f.trigger.caller.ref,
+      by: "id",
+      type: "ref",
+      how: "field:trigger.caller.ref"
+    });
+  const stepLines = [];
+  f.steps.forEach((s, i) => {
+    const n = i + 1;
+    const skey = `flow:FlowStep:${f.id}#${n}`;
+    const out = [{ from: skey, to: f.id, by: "id", type: "step-of", how: "flow step" }];
+    const add = (to, how, by = "id") => {
+      out.push({ from: skey, to, by, type: "calls", how: `step ${n} ${how}` });
+      links.push({ from: key, to, by, type: "calls", how: `step ${n} ${how}` });
+    };
+    for (const ref of s.refs)
+      add(ref, "field:refs");
+    if (s.to) {
+      add(s.to.component, "field:to.component");
+      const m = /^\s*([A-Za-z]+)\s+(\/\S*)/.exec(s.to.entry);
+      if (m)
+        add(endpointName(m[1], m[2]), "field:to.entry", "name");
+      else
+        add(s.to.entry, "field:to.entry");
+    }
+    if (s.store)
+      add(s.store.table, "field:store.table");
+    const fields = [
+      ...s.data?.sends ?? [],
+      ...s.data?.returns ?? [],
+      ...s.data?.reads ?? [],
+      ...s.store?.columns ?? []
+    ];
+    const where = s.to ? ` \u2192 ${s.to.component} ${s.to.entry}` : s.store ? ` ${s.store.table}` : "";
+    const line = `${n} ${s.kind}${where}${fields.length ? ` [${[...new Set(fields)].join(", ")}]` : ""}`;
+    stepLines.push(line);
+    const c = s.evidence[0];
+    nodes.push({
+      key: skey,
+      kind: "FlowStep",
+      id: `${f.id}#${n}`,
+      grp: "flow",
+      name: s.what,
+      file,
+      verified: !!s.confirmedBy,
+      line: `step ${f.id}#${n} ${s.kind}: ${s.what}${where}${c?.path ? ` [${c.repo ? `${c.repo}/` : ""}${c.path}${c.line ? `:${c.line}` : ""}]` : ""}`,
+      detail: `Step ${n} of flow ${f.id} (${file}):
+${toCanonicalYaml(s, ["kind", "what"])}`,
+      names: "",
+      ids: idWords(`${f.id}#${n}`),
+      body: [s.what, ...fields].join("\n"),
+      mentions: false
+    });
+    links.push(...out);
+  });
+  const allConfirmed = f.steps.every((s) => !!s.confirmedBy);
+  nodes.unshift({
+    key,
+    kind: "Flow",
+    id: f.id,
+    grp: "flow",
+    name: f.name,
+    file,
+    verified: allConfirmed,
+    line: `flow ${f.id} (component ${f.component}) "${f.name}": ${f.trigger.kind} ${f.trigger.what}. Steps: ${stepLines.join("; ")} [${file}]`,
+    detail: serializeRecord(f),
+    names: f.name,
+    ids: idWords(f.id),
+    body: [
+      f.trigger.what,
+      ...f.steps.map((s) => s.what),
+      ...f.errors.map((e) => `${e.when} ${e.then}`)
+    ].join("\n"),
+    mentions: false,
+    json: JSON.stringify(f)
+  });
+  return {
+    nodes,
+    names: [
+      { name: foldName(f.id), id: f.id, kind: "Flow", how: "id" },
+      { name: foldName(f.name), id: f.id, kind: "Flow", how: "name:flow" }
+    ],
+    links
+  };
+}
+var ASKED_ONLY_KINDS = /* @__PURE__ */ new Set(["PastChange"]);
+function changeNodes(path, text) {
+  const parts = path.split("/");
+  const fileName = parts.slice(-1)[0];
+  if (parts.at(-3) === "archive") {
+    const id2 = parts.at(-2);
+    const title2 = /^#\s+(.+)$/m.exec(text)?.[1]?.trim() ?? id2;
+    return {
+      nodes: [
+        {
+          key: `change:PastChange:${id2}`,
+          kind: "PastChange",
+          id: id2,
+          grp: "change",
+          name: title2,
+          file: path,
+          verified: false,
+          line: `archived change ${id2} "${title2}" [${path}]`,
+          detail: `${path}:
+${text}`,
+          names: title2,
+          ids: idWords(id2),
+          body: text.slice(0, 2e4),
+          mentions: false
+        }
+      ],
+      names: [],
+      links: []
+    };
+  }
+  const inTargets = parts.at(-2) === "target-flows";
+  const inInputs = parts.at(-2) === "read" && parts.at(-3) === "inputs";
+  const change = inTargets ? parts.at(-3) : inInputs ? parts.at(-4) : parts.at(-2);
+  const ckey = `change:Change:${change}`;
+  const out = { nodes: [], names: [], links: [] };
+  if (inInputs) {
+    const input = `inputs/${fileName.replace(/\.md$/, "")}`;
+    const id2 = `${change}/${input}`;
+    const key2 = `change:ChangeDoc:${id2}`;
+    out.links.push({ from: key2, to: change, by: "id", type: "part-of", how: input });
+    out.nodes.push({
+      key: key2,
+      kind: "ChangeDoc",
+      id: id2,
+      grp: "change",
+      name: input,
+      file: path,
+      verified: false,
+      line: `${input} attached to change ${change} [${path}]`,
+      detail: `${path}:
+${text}`,
+      names: input,
+      ids: idWords(id2),
+      body: text.slice(0, 2e4),
+      mentions: true
+    });
+    return out;
+  }
+  const data = () => {
+    try {
+      const d = (0, import_yaml.parse)(text);
+      return d && typeof d === "object" ? d : void 0;
+    } catch (e) {
+      out.problem = e.message.split("\n")[0];
+      return void 0;
+    }
+  };
+  if (inTargets) {
+    const d = data();
+    if (d && str(d.flow))
+      out.links.push({
+        from: ckey,
+        to: String(d.flow),
+        by: "id",
+        type: "touches",
+        how: "target flow"
+      });
+    return out;
+  }
+  if (fileName === "change.yaml") {
+    const d = data();
+    if (!d)
+      return out;
+    const title2 = str(d.title) ?? change;
+    for (const s of arr(d.systems))
+      if (typeof s === "string")
+        out.links.push({
+          from: ckey,
+          to: s,
+          by: "id",
+          type: "touches",
+          how: "change.yaml systems"
+        });
+    const t = d.touches ?? {};
+    for (const f of ["interfaces", "tables", "dataStores", "records", "repos"])
+      for (const v of arr(t[f])) {
+        const id2 = typeof v === "string" ? v : str(v?.id);
+        if (id2)
+          out.links.push({
+            from: ckey,
+            to: id2,
+            by: "id",
+            type: "touches",
+            how: `change.yaml touches.${f}`
+          });
+      }
+    out.nodes.push({
+      key: ckey,
+      kind: "Change",
+      id: change,
+      grp: "change",
+      name: title2,
+      file: path,
+      verified: false,
+      line: `change ${change} "${title2}"${str(d.state) ? ` (${String(d.state)})` : ""} [${path}]`,
+      detail: `Change ${change} "${title2}" (${path}): state ${str(d.state) ?? "?"}; systems ${arr(d.systems).join(", ") || "none named"}.`,
+      names: title2,
+      ids: idWords(change),
+      body: [title2, str(d.type) ?? ""].join("\n"),
+      mentions: false
+    });
+    out.names.push({ name: foldName(change), id: change, kind: "Change", how: "id" });
+    return out;
+  }
+  if (fileName === "feature.yaml") {
+    const d = data();
+    if (!d)
+      return out;
+    for (const f of arr(d.flows)) {
+      const id2 = str(f?.id);
+      if (id2)
+        out.links.push({ from: ckey, to: id2, by: "id", type: "touches", how: "placement flows" });
+    }
+    for (const f of arr(d.features)) {
+      const id2 = str(f?.id);
+      if (id2)
+        out.links.push({
+          from: ckey,
+          to: id2,
+          by: "id",
+          type: "touches",
+          how: "placement features"
+        });
+    }
+    return out;
+  }
+  if (fileName === "needs.yaml") {
+    const d = data();
+    if (!d)
+      return out;
+    for (const n of arr(d.needs)) {
+      const item = str(n.item);
+      const target = str(n.for) ?? "change";
+      if (!item)
+        continue;
+      const id2 = `${change}:${item}:${target}`;
+      const key2 = `change:Need:${id2}`;
+      out.links.push({ from: key2, to: item, by: "id", type: "needs", how: "needs.yaml item" }, { from: key2, to: change, by: "id", type: "part-of", how: "needs.yaml" });
+      const flow = /^flow:(.+)$/.exec(target)?.[1];
+      if (flow)
+        out.links.push({ from: key2, to: flow, by: "id", type: "for", how: "needs.yaml for" });
+      const title2 = str(n.title) ?? item;
+      out.nodes.push({
+        key: key2,
+        kind: "Need",
+        id: id2,
+        grp: "change",
+        name: title2,
+        file: path,
+        verified: false,
+        line: `need ${item} for ${target} of ${change}: ${title2} (${str(n.status) ?? "open"}) [${path}]`,
+        detail: `Need ${item} for ${target} of change ${change} (${path}): ${title2}. Why: ${str(n.why) ?? ""}. Status: ${str(n.status) ?? "open"}.`,
+        names: title2,
+        ids: idWords(id2),
+        body: [str(n.why) ?? "", str(n.because?.quote) ?? ""].join("\n"),
+        mentions: false
+      });
+    }
+    return out;
+  }
+  const id = `${change}/${fileName}`;
+  const key = `change:ChangeDoc:${id}`;
+  const title = /^#\s+(.+)$/m.exec(text)?.[1]?.trim() ?? id;
+  out.links.push({ from: key, to: change, by: "id", type: "part-of", how: fileName });
+  out.nodes.push({
+    key,
+    kind: "ChangeDoc",
+    id,
+    grp: "change",
+    name: title,
+    file: path,
+    verified: false,
+    line: `${fileName} of change ${change}: ${title} [${path}]`,
+    detail: `${path}:
+${text}`,
+    names: title,
+    ids: idWords(id),
+    body: text.slice(0, 2e4),
+    mentions: true
+  });
+  return out;
+}
+function questionNodes(path, text) {
+  let q;
+  try {
+    const r = Question.safeParse((0, import_yaml.parse)(text));
+    if (!r.success)
+      return {
+        nodes: [],
+        names: [],
+        links: [],
+        problem: r.error.issues[0]?.message ?? "not a question"
+      };
+    q = r.data;
+  } catch (e) {
+    return { nodes: [], names: [], links: [], problem: e.message.split("\n")[0] };
+  }
+  if (q.state !== "answered" || !q.answer)
+    return { nodes: [], names: [], links: [] };
+  const a = q.answer;
+  const picked = a.option !== void 0 ? q.options[a.option - 1] : void 0;
+  const answer = picked ? `${picked.label}: ${picked.means}` : a.text ?? "";
+  const key = `question:Question:${q.id}`;
+  const gap = gapNameOf(q);
+  return {
+    nodes: [
+      {
+        key,
+        kind: "Question",
+        id: q.id,
+        grp: "question",
+        name: q.question,
+        file: path,
+        verified: false,
+        line: `answered question ${q.id}: ${q.question} Answer: ${answer} (${a.by}, ${a.at}) [${path}]`,
+        detail: `Question ${q.id} (${path}), asked by ${q.askedBy.step} about repo ${q.repo}: ${q.question}
+Answer, by ${a.by} at ${a.at}: ${answer}
+Evidence: ${q.evidence.join(", ")}`,
+        names: "",
+        ids: q.id,
+        body: [q.question, answer].join("\n"),
+        mentions: true
+      }
+    ],
+    // An answered gap (ADR 0107 point 5): the name it was about is known from now on, by this answer.
+    // An endpoint is also named as the selection looks endpoints up (U2): method, path, {} params.
+    names: gap ? answeredGapNames(gap).map((name) => ({
+      name,
+      id: q.id,
+      kind: "Question",
+      how: "answered gap"
+    })) : [],
+    links: [{ from: key, to: q.repo, by: "id", type: "about", how: "question repo" }]
+  };
+}
+function answeredGapNames(gap) {
+  const m = /^\s*(GET|POST|PUT|PATCH|DELETE)\s+(\/\S*)\s*$/i.exec(gap);
+  return [.../* @__PURE__ */ new Set([foldName(gap), ...m ? [endpointName(m[1], m[2])] : []])];
+}
+function wikiNodes(root, path, text) {
+  const k = rel(root, knowledgeDirOf(root));
+  const rest = path.slice(k.length + "/snapshots/".length).split("/");
+  const source = rest[0];
+  const date = rest[1];
+  const page = rest.slice(2).join("/");
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  const sections = [
+    { heading: "", level: 0, line: 1, text: [] }
+  ];
+  if (lines[0]?.trim() === "---") {
+    const end = lines.findIndex((l, k2) => k2 > 0 && (l.trim() === "---" || l.trim() === "..."));
+    for (let k2 = 0; k2 <= end; k2++)
+      lines[k2] = "";
+  }
+  let fence;
+  lines.forEach((l, i) => {
+    const f = /^ {0,3}(```+|~~~+)/.exec(l);
+    if (f)
+      fence = fence ? l.trim().startsWith(fence) ? void 0 : fence : f[1];
+    const m = fence || f ? void 0 : /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(l);
+    if (m)
+      sections.push({ heading: m[2], level: m[1].length, line: i + 1, text: [] });
+    else
+      sections.at(-1).text.push(l);
+  });
+  const out = { nodes: [], names: [], links: [] };
+  const used = /* @__PURE__ */ new Set();
+  const stack = [];
+  for (const s of sections) {
+    if (s.level > 0) {
+      stack.length = s.level - 1;
+      while (stack.length < s.level - 1)
+        stack.push("");
+      stack.push(s.heading);
+    }
+    const path_ = stack.filter(Boolean).join(" \u203A ");
+    const paras = [];
+    let at = s.level > 0 ? s.line + 1 : 1;
+    let cur;
+    for (const l of s.text) {
+      if (l.trim())
+        (cur ??= { line: at, text: [] }).text.push(l);
+      else if (cur) {
+        paras.push({ line: cur.line, text: cur.text.join("\n") });
+        cur = void 0;
+      }
+      at++;
+    }
+    if (cur)
+      paras.push({ line: cur.line, text: cur.text.join("\n") });
+    if (!paras.length)
+      continue;
+    const id = sectionId(source, page, s.heading);
+    if (used.has(id))
+      continue;
+    used.add(id);
+    const parts = partsOf(paras);
+    parts.forEach((p, i) => {
+      const pid = i === 0 ? id : `${id}#${i + 1}`;
+      const line = i === 0 ? s.line : p.line;
+      const of = parts.length > 1 ? ` (part ${i + 1} of ${parts.length})` : "";
+      const name = path_ || page;
+      out.nodes.push({
+        key: `wiki:WikiSection:${pid}`,
+        kind: "WikiSection",
+        id: pid,
+        grp: "wiki",
+        name,
+        file: path,
+        verified: false,
+        line: `wiki ${source}/${page}${path_ ? ` \xA7 ${path_}` : ""}${of} (snapshot ${date}) [${path}:${line}]`,
+        detail: `${source}/${page}${path_ ? ` \u203A ${path_}` : ""}${of}, snapshot ${date} (${path}:${line}):
+${p.text}`,
+        names: path_,
+        ids: idWords(page),
+        body: p.text,
+        mentions: true
+      });
+      if (i > 0)
+        out.links.push({
+          from: `wiki:WikiSection:${pid}`,
+          to: id,
+          by: "id",
+          type: "part-of",
+          how: `part ${i + 1}`
+        });
+    });
+  }
+  return out;
+}
+var PART_CHARS = 1600;
+function partsOf(paras) {
+  const parts = [];
+  for (const p of paras) {
+    const last = parts.at(-1);
+    if (last && last.text.length + 2 + p.text.length <= PART_CHARS)
+      last.text = `${last.text}
+
+${p.text}`;
+    else
+      parts.push({ line: p.line, text: p.text });
+  }
+  return parts;
+}
+var DOCUMENT_EXTENSIONS = /\.(docx|pptx|xlsx|pdf|md|markdown|html?|txt)$/i;
+async function documentNodes(path, bytes) {
+  const out = { nodes: [], names: [], links: [] };
+  const [{ readDocument }, { screenFile }] = await Promise.all([
+    import("./chunk-4NDAAFQT.js"),
+    import("./chunk-6JCPI55B.js")
+  ]);
+  const screen = screenFile(path, bytes);
+  if (screen.problem)
+    return { ...out, problem: screen.problem };
+  if (screen.screening && (screen.screening.risk === "medium" || screen.screening.risk === "high"))
+    return {
+      ...out,
+      problem: `kept out of the index: the ingested-content defences found ${screen.screening.risk} risk (${screen.screening.reason})`
+    };
+  let read;
+  try {
+    read = readDocument(path, bytes);
+  } catch (e) {
+    return { ...out, problem: e.message };
+  }
+  const title = read.text.title;
+  const stack = [];
+  const used = /* @__PURE__ */ new Set();
+  for (const s of read.text.sections) {
+    if (s.level > 0) {
+      stack.length = s.level - 1;
+      while (stack.length < s.level - 1)
+        stack.push("");
+      stack.push(s.heading);
+    }
+    const heading = s.heading || title;
+    const trail = [title, ...stack.filter(Boolean)].filter((h, i, all) => h && all.indexOf(h) === i);
+    const name = (s.level > 0 ? trail : [heading]).join(" \u203A ");
+    const paras = s.text.split(/\n/).map((t, i) => ({ line: (s.line ?? 0) + i + 1, text: t.trim() })).filter((p) => p.text);
+    if (!paras.length)
+      continue;
+    const id = `${path}#${heading}`;
+    if (used.has(id))
+      continue;
+    used.add(id);
+    const parts = partsOf(paras);
+    parts.forEach((p, i) => {
+      const pid = i === 0 ? id : `${id}#${i + 1}`;
+      const of = parts.length > 1 ? ` (part ${i + 1} of ${parts.length})` : "";
+      const where = s.page ? `, page ${s.page}` : s.line !== void 0 ? `, line ${i === 0 ? s.line : p.line}` : "";
+      const cite = `${path} \xA7 ${heading}${where}`;
+      out.nodes.push({
+        key: `document:DocumentSection:${pid}`,
+        kind: "DocumentSection",
+        id: pid,
+        grp: "document",
+        name,
+        file: path,
+        verified: false,
+        line: `document ${path} \xA7 ${name}${of} [${cite}]`,
+        detail: `${path} \u203A ${name}${of} (${cite}):
+${p.text}`,
+        names: name,
+        ids: idWords(path),
+        body: p.text,
+        mentions: true
+      });
+      if (i > 0)
+        out.links.push({
+          from: `document:DocumentSection:${pid}`,
+          to: id,
+          by: "id",
+          type: "part-of",
+          how: `part ${i + 1}`
+        });
+    });
+  }
+  return out;
+}
+function manifestNodes(path, text) {
+  let d;
+  try {
+    d = (0, import_yaml.parse)(text) ?? {};
+  } catch (e) {
+    return { nodes: [], names: [], links: [], problem: e.message.split("\n")[0] };
+  }
+  const out = { nodes: [], names: [], links: [] };
+  const platform = str(d.platform);
+  for (const r of arr(d.repos)) {
+    const id = str(r.id);
+    if (!id)
+      continue;
+    const about = r.description ?? void 0;
+    const text2 = str(about?.text);
+    if (!text2)
+      continue;
+    const suggested = str(about?.trust) === "suggested";
+    const what = `${text2}${suggested ? " (unconfirmed: drafted by the assistant)" : ""}`;
+    const where = [
+      str(r.system) ? `system ${String(r.system)}` : void 0,
+      str(r.component) ? `component ${String(r.component)}` : void 0,
+      str(r.type) ? String(r.type) : void 0,
+      str(r.owner) ? `owner ${String(r.owner)}` : void 0
+    ].filter(Boolean).join(", ");
+    out.nodes.push({
+      key: `org-pack:Repo:${id}`,
+      kind: "Repo",
+      id,
+      grp: "org-pack",
+      name: id,
+      file: path,
+      verified: false,
+      line: `repo ${id}${platform ? ` (${platform})` : ""}${where ? `: ${where}` : ""} \u2014 ${what} [${path}]`,
+      detail: `Repo ${id} of the ${platform ?? "?"} platform (${path})${where ? `: ${where}` : ""}. What it is, in a person's words: ${what}. That is a note, not read from the code.`,
+      names: [id, text2].join("\n"),
+      ids: idWords(id),
+      body: [what, where].filter(Boolean).join("\n"),
+      mentions: false
+    });
+    out.names.push({ name: foldName(id), id, kind: "Repo", how: "id" });
+    for (const link of [str(r.system), str(r.component)])
+      if (link)
+        out.links.push({
+          from: `org-pack:Repo:${id}`,
+          to: link,
+          by: "id",
+          type: "part-of",
+          how: "manifest"
+        });
+  }
+  return out;
+}
+function profileNodes(path, text) {
+  if (path.endsWith("repos.manifest.yaml"))
+    return manifestNodes(path, text);
+  let d;
+  try {
+    d = (0, import_yaml.parse)(text) ?? {};
+  } catch (e) {
+    return { nodes: [], names: [], links: [], problem: e.message.split("\n")[0] };
+  }
+  const out = { nodes: [], names: [], links: [] };
+  for (const s of arr(d.systems)) {
+    const id = str(s.id);
+    if (!id)
+      continue;
+    const name = str(s.name) ?? id;
+    const aliases = arr(s.aliases).filter((a) => typeof a === "string");
+    out.nodes.push({
+      key: `org-pack:System:${id}`,
+      kind: "System",
+      id,
+      grp: "org-pack",
+      name,
+      file: path,
+      verified: false,
+      line: `system ${id} "${name}"${str(s.boundary) ? ` (${String(s.boundary)})` : ""}${str(s.owner) ? `, owner ${String(s.owner)}` : ""}${aliases.length ? `, also called ${aliases.join(", ")}` : ""} [${path}]`,
+      detail: `System ${id} "${name}" in the org pack profile (${path}): boundary ${str(s.boundary) ?? "?"}${str(s.owner) ? `, owner ${String(s.owner)}` : ""}${aliases.length ? `; also called ${aliases.join(", ")}` : ""}.`,
+      names: [name, ...aliases].join("\n"),
+      ids: idWords(id),
+      body: [str(s.boundary) ?? "", str(s.owner) ?? ""].join("\n"),
+      mentions: false
+    });
+    out.names.push({ name: foldName(id), id, kind: "System", how: "id" }, { name: foldName(name), id, kind: "System", how: "name:org-pack" }, ...aliases.map((a) => ({ name: foldName(a), id, kind: "System", how: "alias:org-pack" })));
+  }
+  return out;
+}
+function readSource(root, f, text) {
+  switch (f.source) {
+    case "catalog": {
+      const r = deserializeRecord(text);
+      if (!r.ok)
+        return {
+          nodes: [],
+          names: [],
+          links: [],
+          problem: r.issues.map((i) => `${i.path}: ${i.message}`).join("; ")
+        };
+      return { ...recordNode(r.record, f.path, "catalog"), record: r.record };
+    }
+    case "knowledge": {
+      const r = deserializeRecord(text);
+      if (!r.ok)
+        return {
+          nodes: [],
+          names: [],
+          links: [],
+          problem: r.issues.map((i) => `${i.path}: ${i.message}`).join("; ")
+        };
+      if (!knowledgeKindOf(r.record))
+        return { nodes: [], names: [], links: [] };
+      return recordNode(r.record, f.path, "knowledge");
+    }
+    case "review": {
+      try {
+        const d = (0, import_yaml.parse)(text);
+        if (!str(d?.item) || !str(d?.verdict))
+          return { nodes: [], names: [], links: [], problem: "not a review" };
+        return {
+          nodes: [],
+          names: [],
+          links: [],
+          review: {
+            item: String(d.item),
+            verdict: String(d.verdict),
+            by: str(d.by) ?? "",
+            at: str(d.at) ?? ""
+          }
+        };
+      } catch (e) {
+        return { nodes: [], names: [], links: [], problem: e.message.split("\n")[0] };
+      }
+    }
+    case "flow":
+      return flowNodes(text, f.path);
+    case "change":
+      return changeNodes(f.path, text);
+    case "question":
+      return questionNodes(f.path, text);
+    case "wiki":
+      return wikiNodes(root, f.path, text);
+    case "profile":
+      return profileNodes(f.path, text);
+    case "document":
+      return { nodes: [], names: [], links: [] };
+  }
+}
+
+// packages/index/dist/store.js
+import { createHash } from "node:crypto";
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// packages/index/dist/vectors.js
+var VECTORS_SCHEMA = `
+CREATE TABLE IF NOT EXISTS vec.vectors (
+  model TEXT NOT NULL, text_sha TEXT NOT NULL, kind TEXT NOT NULL, dim INTEGER NOT NULL,
+  scale REAL NOT NULL, q BLOB NOT NULL, PRIMARY KEY (model, text_sha, kind)
+);
+`;
+function nodeText(n) {
+  const words = (s) => identifierWords(s).join(" ");
+  const id = n.ids.split(" ")[0] ?? "";
+  return `${n.kind}: ${words(n.name) || n.name}. ${id.includes("/") ? "" : words(id)}. ${n.body}`.replace(/\s+/g, " ").slice(0, 2e3);
+}
+function attachVectors(db, file) {
+  db.exec(`ATTACH DATABASE '${file.replace(/'/g, "''")}' AS vec`);
+  db.exec(VECTORS_SCHEMA);
+}
+function meaningState(db, embedder, why) {
+  const total = db.prepare("SELECT count(*) AS n FROM node_text").get().n;
+  if (!embedder)
+    return {
+      on: false,
+      embedded: 0,
+      total,
+      note: `similar in meaning is off: ${why ?? "no embedding model"}`
+    };
+  const embedded = db.prepare("SELECT count(*) AS n FROM node_text t JOIN vec.vectors v ON v.model = ? AND v.text_sha = t.text_sha AND v.kind = 'document'").get(embedder.id).n;
+  const on = total > 0 && embedded === total;
+  return {
+    on,
+    model: embedder.id,
+    embedded,
+    total,
+    note: on ? `similar in meaning by ${embedder.id} (${total} nodes)` : `similar in meaning is off until every node is embedded: ${embedded} of ${total} by ${embedder.id} (atticus index embed)`
+  };
+}
+var toBlob = (v) => Buffer.from(v.q.buffer, v.q.byteOffset, v.q.byteLength);
+function store(db, embedder, kind, shas, vs) {
+  const ins = db.prepare("INSERT OR REPLACE INTO vec.vectors VALUES (?, ?, ?, ?, ?, ?)");
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    vs.forEach((v, i) => ins.run(embedder.id, shas[i], kind, v.q.length, v.scale, toBlob(v)));
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+}
+async function embedMissing(db, embedder, o = {}) {
+  const rows = db.prepare(`SELECT DISTINCT t.text_sha AS sha, t.text AS text FROM node_text t
+       WHERE NOT EXISTS (SELECT 1 FROM vec.vectors v WHERE v.model = ? AND v.text_sha = t.text_sha AND v.kind = 'document')
+       ORDER BY t.text_sha`).all(embedder.id);
+  const todo = rows.slice(0, o.max ?? rows.length);
+  const batch = o.batch ?? 16;
+  for (let i = 0; i < todo.length; i += batch) {
+    const part = todo.slice(i, i + batch);
+    const vs = await embedder.embed(part.map((r) => r.text), "document");
+    store(db, embedder, "document", part.map((r) => r.sha), vs);
+    o.progress?.(Math.min(i + batch, todo.length), todo.length);
+  }
+  return todo.length;
+}
+async function queryVectors(db, embedder, texts) {
+  const shas = texts.map(textSha);
+  const missing = texts.filter((_, i) => !cachedQuery(db, embedder.id, shas[i]));
+  if (missing.length) {
+    const vs = await embedder.embed(missing, "query");
+    store(db, embedder, "query", missing.map(textSha), vs);
+  }
+  return shas.map((s) => cachedQuery(db, embedder.id, s));
+}
+function cachedQuery(db, model, sha2) {
+  const r = db.prepare("SELECT scale, q FROM vec.vectors WHERE model = ? AND text_sha = ? AND kind = 'query'").get(model, sha2);
+  return r ? { scale: r.scale, q: new Int8Array(r.q.buffer, r.q.byteOffset, r.q.byteLength) } : void 0;
+}
+function loadMatrix(db, model) {
+  const rows = db.prepare(`SELECT t.key AS key, n.kind AS kind, v.scale AS scale, v.q AS q, v.dim AS dim FROM node_text t
+       JOIN nodes n ON n.key = t.key
+       JOIN vec.vectors v ON v.model = ? AND v.text_sha = t.text_sha AND v.kind = 'document'
+       ORDER BY t.key`).all(model);
+  const dim = rows[0]?.dim ?? 0;
+  const q = new Int8Array(rows.length * dim);
+  const scales = new Float64Array(rows.length);
+  rows.forEach((r, i) => {
+    q.set(new Int8Array(r.q.buffer, r.q.byteOffset, r.q.byteLength), i * dim);
+    scales[i] = r.scale;
+  });
+  return { keys: rows.map((r) => r.key), kinds: rows.map((r) => r.kind), scales, q, dim };
+}
+function nearest(m, queries, o) {
+  const kinds = o.kinds?.length ? new Set(o.kinds) : void 0;
+  const out = [];
+  for (let i = 0; i < m.keys.length; i++) {
+    if (kinds ? !kinds.has(m.kinds[i]) : ASKED_ONLY_KINDS.has(m.kinds[i]))
+      continue;
+    if (o.exclude?.has(m.keys[i]))
+      continue;
+    let best = -Infinity;
+    for (const qv of queries) {
+      const c = dotInt8(qv.q, m.q, i * m.dim) * qv.scale * m.scales[i];
+      if (c > best)
+        best = c;
+    }
+    if (best >= o.floor)
+      out.push({ key: m.keys[i], cos: Math.round(best * 1e4) / 1e4 });
+  }
+  return out.sort((a, b) => b.cos - a.cos || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0)).slice(0, o.limit);
+}
+function cosines(m, rows, queries, keys) {
+  const out = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    const i = rows.get(key);
+    if (i === void 0 || out.has(key))
+      continue;
+    let best = -Infinity;
+    for (const qv of queries) {
+      const c = dotInt8(qv.q, m.q, i * m.dim) * qv.scale * m.scales[i];
+      if (c > best)
+        best = c;
+    }
+    if (best > -Infinity)
+      out.set(key, Math.round(best * 1e4) / 1e4);
+  }
+  return out;
+}
+function queryChunks(input) {
+  const out = [];
+  const push = (s) => {
+    const t = s.replace(/\s+/g, " ").trim().slice(0, 1e3);
+    if (t.length >= 3 && !out.includes(t))
+      out.push(t);
+  };
+  if (input.title)
+    push(input.title);
+  for (const p of input.text.split(/\n\s*\n/))
+    push(p.replace(/^#+\s*/gm, ""));
+  return out.slice(0, 20);
+}
+
+// packages/index/dist/store.js
+var INDEX_VERSION = 5;
+var SCHEMA = `
+CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+CREATE TABLE files (path TEXT PRIMARY KEY, source TEXT NOT NULL, size INTEGER NOT NULL, mtime INTEGER NOT NULL, hash TEXT NOT NULL);
+CREATE TABLE records (
+  kind TEXT NOT NULL, id TEXT NOT NULL, status TEXT NOT NULL, confidence TEXT NOT NULL,
+  name TEXT NOT NULL, system TEXT, file TEXT NOT NULL, stale INTEGER NOT NULL, json TEXT NOT NULL,
+  PRIMARY KEY (kind, id)
+);
+CREATE INDEX records_id ON records (id);
+CREATE INDEX records_system ON records (system);
+CREATE INDEX records_file ON records (file);
+CREATE TABLE refs (from_kind TEXT NOT NULL, from_id TEXT NOT NULL, field TEXT NOT NULL, to_id TEXT NOT NULL, file TEXT NOT NULL);
+CREATE INDEX refs_to ON refs (to_id);
+CREATE INDEX refs_from ON refs (from_id);
+CREATE INDEX refs_file ON refs (file);
+CREATE TABLE evidence (kind TEXT NOT NULL, id TEXT NOT NULL, source TEXT NOT NULL, repo TEXT, path TEXT, line INTEGER, file TEXT NOT NULL);
+CREATE INDEX evidence_path ON evidence (repo, path);
+CREATE INDEX evidence_file ON evidence (file);
+CREATE TABLE nodes (
+  key TEXT PRIMARY KEY, kind TEXT NOT NULL, id TEXT NOT NULL, grp TEXT NOT NULL, name TEXT NOT NULL,
+  file TEXT NOT NULL, verified INTEGER NOT NULL, line TEXT NOT NULL, detail TEXT NOT NULL,
+  body TEXT NOT NULL, mentions INTEGER NOT NULL, json TEXT
+);
+CREATE INDEX nodes_id ON nodes (id);
+CREATE INDEX nodes_file ON nodes (file);
+CREATE TABLE names (name TEXT NOT NULL, id TEXT NOT NULL, kind TEXT NOT NULL, how TEXT NOT NULL, file TEXT NOT NULL);
+CREATE INDEX names_name ON names (name);
+CREATE INDEX names_id ON names (id);
+CREATE INDEX names_file ON names (file);
+CREATE TABLE links (from_key TEXT NOT NULL, to_ref TEXT NOT NULL, by TEXT NOT NULL, type TEXT NOT NULL, how TEXT NOT NULL, file TEXT NOT NULL, derived INTEGER NOT NULL);
+CREATE INDEX links_from ON links (from_key);
+CREATE INDEX links_to ON links (to_ref, by);
+CREATE INDEX links_file ON links (file);
+CREATE TABLE reviews (item TEXT NOT NULL, verdict TEXT NOT NULL, by TEXT NOT NULL, at TEXT NOT NULL, file TEXT NOT NULL);
+CREATE INDEX reviews_item ON reviews (item);
+CREATE INDEX reviews_file ON reviews (file);
+CREATE VIRTUAL TABLE fts USING fts5(key UNINDEXED, name, ids, body, words, tokenize = 'porter unicode61');
+CREATE TABLE selections (key TEXT PRIMARY KEY, json TEXT NOT NULL);
+CREATE TABLE node_text (key TEXT PRIMARY KEY, text_sha TEXT NOT NULL, text TEXT NOT NULL, file TEXT NOT NULL);
+CREATE INDEX node_text_file ON node_text (file);
+`;
+var NAMEABLE_KINDS = ["System", "Component", "Party", "Product"];
+var meta = (db, key) => db.prepare("SELECT value FROM meta WHERE key = ?").get(key)?.value;
+function ensureSchema(db, rebuild = false) {
+  let version;
+  try {
+    version = meta(db, "version");
+  } catch {
+    version = void 0;
+  }
+  if (!rebuild && version === String(INDEX_VERSION))
+    return false;
+  const objects = db.prepare("SELECT type, name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'").all();
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    const virtual = objects.filter((o) => /VIRTUAL/i.test(db.prepare("SELECT sql FROM sqlite_master WHERE name = ?").get(o.name)?.sql ?? ""));
+    for (const v of virtual)
+      db.exec(`DROP TABLE IF EXISTS "${v.name}"`);
+    for (const o of objects)
+      db.exec(`DROP TABLE IF EXISTS "${o.name}"`);
+    db.exec(SCHEMA);
+    db.prepare("INSERT INTO meta VALUES ('version', ?)").run(String(INDEX_VERSION));
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+  return true;
+}
+var sha = (s) => createHash("sha256").update(s, "utf8").digest("hex");
+function systemsOf(records) {
+  const key = (r) => `${r.kind}|${r.id}`;
+  const systems = new Set(records.filter((r) => r.kind === "System").map((r) => r.id));
+  const componentSystem = /* @__PURE__ */ new Map();
+  for (const r of records)
+    if (r.kind === "Component")
+      componentSystem.set(r.id, r.system);
+  const ofId = (id) => {
+    if (typeof id !== "string")
+      return void 0;
+    return componentSystem.get(id) ?? (systems.has(id) ? id : void 0);
+  };
+  const out = /* @__PURE__ */ new Map();
+  const tables = /* @__PURE__ */ new Map();
+  const stores = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const x = r;
+    let s;
+    if (r.kind === "System")
+      s = r.id;
+    else if (r.kind === "Component")
+      s = r.system;
+    else if (r.kind === "Interface")
+      s = ofId(r.from);
+    else
+      s = ofId(x.component) ?? ofId(x.ownerComponent) ?? ofId(x.owner) ?? (typeof x.system === "string" ? x.system : void 0);
+    if (s)
+      out.set(key(r), s);
+    if (r.kind === "DataStore" && s)
+      stores.set(r.id, s);
+  }
+  for (const r of records)
+    if (r.kind === "Table" && !out.has(key(r)) && stores.has(r.dataStore))
+      out.set(key(r), stores.get(r.dataStore));
+  for (const r of records)
+    if (r.kind === "Table" && out.has(key(r)))
+      tables.set(r.id, out.get(key(r)));
+  for (const r of records) {
+    const x = r;
+    if (out.has(key(r)))
+      continue;
+    const s = typeof x.table === "string" && tables.get(x.table) || typeof x.dataStore === "string" && stores.get(x.dataStore) || void 0;
+    if (s)
+      out.set(key(r), s);
+  }
+  return out;
+}
+function mentionNames(db) {
+  const rows = db.prepare(`SELECT DISTINCT n.name AS name, n.id AS id, n.how AS how FROM names n
+       WHERE length(n.name) >= 3 AND n.how != 'endpoint'
+         AND EXISTS (SELECT 1 FROM nodes d WHERE d.id = n.id AND d.kind IN (${NAMEABLE_KINDS.map(() => "?").join(", ")}))
+       ORDER BY n.name, n.id, n.how`).all(...NAMEABLE_KINDS);
+  const out = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (/^\d+$/.test(r.name))
+      continue;
+    const l = out.get(r.name) ?? [];
+    if (!l.some((x) => x.id === r.id))
+      l.push({ id: r.id, how: r.how });
+    out.set(r.name, l);
+  }
+  return out;
+}
+function nameTokens(text) {
+  return foldName(text).split(/[\s,;()[\]"`*|<>!?]+/).map((t) => t.replace(/^[^a-z0-9/{]+/, "").replace(/'s$/, "").replace(/[^a-z0-9}]+$/, "")).filter(Boolean);
+}
+function namesIn(text, dict, maxWords) {
+  const toks = nameTokens(text);
+  const out = [];
+  for (let i = 0; i < toks.length; i++) {
+    for (let n = Math.min(maxWords, toks.length - i); n >= 1; n--) {
+      const cand = toks.slice(i, i + n).join(" ");
+      if (dict.has(cand)) {
+        out.push({ name: cand, at: i });
+        break;
+      }
+    }
+  }
+  return out;
+}
+var maxWordsOf = (dict) => Math.min(8, Math.max(1, ...[...dict.keys()].map((k) => k.split(" ").length)));
+async function updateIndex(db, root, files, o = {}) {
+  const known = new Map(db.prepare("SELECT path, size, mtime, hash FROM files").all().map((r) => [r.path, r]));
+  const present = new Set(files.map((f) => f.path));
+  const removed = [...known.keys()].filter((p) => !present.has(p)).sort();
+  const stale = files.filter((f) => {
+    const k = known.get(f.path);
+    return o.force || !k || k.size !== f.size || k.mtime !== f.mtimeMs;
+  });
+  const result = { changed: [], removed, problems: [], rematched: false };
+  if (!stale.length && !removed.length)
+    return result;
+  const reads = [];
+  for (const f of stale) {
+    const bytes = await readFile2(join2(root, ...f.path.split("/"))).catch(() => void 0);
+    if (bytes === void 0)
+      continue;
+    reads.push({
+      f,
+      bytes,
+      text: bytes.toString("utf8"),
+      hash: createHash("sha256").update(bytes).digest("hex")
+    });
+  }
+  const documents = /* @__PURE__ */ new Map();
+  for (const r of reads)
+    if (r.f.source === "document" && (o.force || known.get(r.f.path)?.hash !== r.hash))
+      documents.set(r.f.path, await documentNodes(r.f.path, r.bytes));
+  const touched = new Set(reads.filter((r) => o.force || known.get(r.f.path)?.hash !== r.hash).map((r) => r.f.path));
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    const drop = (path) => {
+      for (const t of [
+        "records",
+        "refs",
+        "evidence",
+        "nodes",
+        "names",
+        "links",
+        "reviews",
+        "node_text"
+      ])
+        db.prepare(`DELETE FROM ${t} WHERE file = ?`).run(path);
+    };
+    const dropFts = db.prepare("DELETE FROM fts WHERE rowid IN (SELECT rowid FROM nodes WHERE file = ?)");
+    for (const p of removed) {
+      dropFts.run(p);
+      drop(p);
+      db.prepare("DELETE FROM files WHERE path = ?").run(p);
+    }
+    const insRec = db.prepare("INSERT OR REPLACE INTO records VALUES (?, ?, ?, ?, ?, NULL, ?, ?, ?)");
+    const insRef = db.prepare("INSERT INTO refs VALUES (?, ?, ?, ?, ?)");
+    const insEv = db.prepare("INSERT INTO evidence VALUES (?, ?, ?, ?, ?, ?, ?)");
+    const insNode = db.prepare("INSERT OR REPLACE INTO nodes VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+    const insName = db.prepare("INSERT INTO names VALUES (?, ?, ?, ?, ?)");
+    const insLink = db.prepare("INSERT INTO links VALUES (?, ?, ?, ?, ?, ?, ?)");
+    const insReview = db.prepare("INSERT INTO reviews VALUES (?, ?, ?, ?, ?)");
+    const insFts = db.prepare("INSERT INTO fts (rowid, key, name, ids, body, words) VALUES (?, ?, ?, ?, ?, ?)");
+    const delFtsKey = db.prepare("DELETE FROM fts WHERE rowid IN (SELECT rowid FROM nodes WHERE key = ?)");
+    const insText = db.prepare("INSERT OR REPLACE INTO node_text VALUES (?, ?, ?, ?)");
+    const upFile = db.prepare("INSERT OR REPLACE INTO files VALUES (?, ?, ?, ?, ?)");
+    let catalogChanged = removed.some((p) => known.has(p));
+    const fresh = [];
+    for (const { f, text, hash } of reads) {
+      if (!touched.has(f.path)) {
+        upFile.run(f.path, f.source, f.size, f.mtimeMs, hash);
+        continue;
+      }
+      if (known.has(f.path)) {
+        dropFts.run(f.path);
+        drop(f.path);
+      }
+      const r = documents.get(f.path) ?? readSource(root, f, text);
+      if (r.problem)
+        result.problems.push({ file: f.path, message: r.problem });
+      if (f.source === "catalog")
+        catalogChanged = true;
+      if (r.record) {
+        const rec = r.record;
+        insRec.run(rec.kind, rec.id, rec.status, rec.confidence, labelOf(rec), f.path, (rec.flags ?? []).includes("stale") ? 1 : 0, JSON.stringify(rec));
+        for (const l of r.links.filter((x) => x.type === "ref"))
+          insRef.run(rec.kind, rec.id, l.how.replace(/^field:/, ""), l.to, f.path);
+        for (const e of rec.evidence)
+          insEv.run(rec.kind, rec.id, String(e.source), e.repo ?? null, e.path ?? null, typeof e.line === "number" ? e.line : null, f.path);
+      }
+      for (const n of r.nodes) {
+        delFtsKey.run(n.key);
+        const row = insNode.run(n.key, n.kind, n.id, n.grp, n.name, f.path, n.verified ? 1 : 0, n.line, n.detail, n.body, n.mentions ? 1 : 0, n.json ?? null);
+        const t = nodeText(n);
+        insText.run(n.key, sha(t), t, f.path);
+        insFts.run(row.lastInsertRowid, n.key, n.names, n.ids, n.body, splitForms(`${n.name}
+${n.names}
+${n.ids}
+${n.body}`).join("\n"));
+      }
+      for (const n of r.names)
+        insName.run(n.name, n.id, n.kind, n.how, f.path);
+      for (const l of r.links)
+        insLink.run(l.from, l.to, l.by, l.type, l.how, f.path, 0);
+      if (r.review)
+        insReview.run(r.review.item, r.review.verdict, r.review.by, r.review.at, f.path);
+      upFile.run(f.path, f.source, f.size, f.mtimeMs, hash);
+      fresh.push(f.path);
+    }
+    result.changed = fresh.sort();
+    if (catalogChanged) {
+      const all2 = db.prepare("SELECT json FROM records").all().map((x) => JSON.parse(x.json));
+      const systems = systemsOf(all2);
+      const setSys = db.prepare("UPDATE records SET system = ? WHERE kind = ? AND id = ?");
+      for (const r of all2)
+        setSys.run(systems.get(`${r.kind}|${r.id}`) ?? null, r.kind, r.id);
+    }
+    const dict = mentionNames(db);
+    const dictHash = sha([...dict].map(([k, v]) => `${k}	${v.map((x) => `${x.id}/${x.how}`).join(",")}`).join("\n"));
+    const all = meta(db, "names") !== dictHash;
+    result.rematched = all;
+    if (all)
+      db.exec("DELETE FROM links WHERE derived = 1");
+    const sources = all ? db.prepare("SELECT key, id, name, body, file FROM nodes WHERE mentions = 1 ORDER BY key").all() : fresh.length ? db.prepare(`SELECT key, id, name, body, file FROM nodes WHERE mentions = 1 AND file IN (${fresh.map(() => "?").join(", ")}) ORDER BY key`).all(...fresh) : [];
+    const maxWords = maxWordsOf(dict);
+    for (const n of sources) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const m of namesIn(`${n.name}
+${n.body}`, dict, maxWords))
+        for (const t of dict.get(m.name) ?? []) {
+          if (t.id === n.id || seen.has(t.id))
+            continue;
+          seen.add(t.id);
+          insLink.run(n.key, t.id, "id", "names", `mention ${t.how}`, n.file, 1);
+        }
+    }
+    const setMeta = db.prepare("INSERT OR REPLACE INTO meta VALUES (?, ?)");
+    setMeta.run("names", dictHash);
+    const fileRows = db.prepare("SELECT path, hash FROM files ORDER BY path").all();
+    const gen = createHash("sha256").update(`v${INDEX_VERSION}
+`);
+    for (const f of fileRows)
+      gen.update(`${f.path}	${f.hash}
+`);
+    setMeta.run("generation", gen.digest("hex").slice(0, 16));
+    setMeta.run("records", String(db.prepare("SELECT count(*) AS n FROM records").get().n));
+    db.exec("DELETE FROM selections");
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+  return result;
+}
+
+// packages/index/dist/select.js
+var STOP = new Set("the and for with from that this into onto over under than then them they their there these those what when where which while who whom whose why how are was were been being has have had having not but can could should would will shall may might must its it's our ours your yours his her out off per via all any each every some such only own same other more most less least very just also too both either neither nor yet one two old use used uses using make makes made does done get gets got let lets about after before again against because below between during above upon here once until within without through scope out-of-scope problem outcome open questions".split(/\s+/));
+function queryWords(text, max = 200, o = {}) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (w) => {
+    if (w.length < 3 || STOP.has(w) || /^\d+$/.test(w) || seen.has(w))
+      return;
+    seen.add(w);
+    out.push(w);
+  };
+  for (const m of text.matchAll(/[A-Za-z0-9]+/g)) {
+    push(m[0].toLowerCase());
+    if (o.split !== false)
+      for (const w of identifierWords(m[0]))
+        push(w);
+    if (out.length >= max)
+      break;
+  }
+  return out.slice(0, max);
+}
+function searchIndex(ix, text, o = {}) {
+  const words = queryWords(text, 200, { split: o.split !== false });
+  if (!words.length)
+    return [];
+  const match = words.map((w) => `"${w}"`).join(" OR ");
+  const kinds = o.kinds?.length ? o.kinds : void 0;
+  const askedOnly = kinds ? [] : [...ASKED_ONLY_KINDS];
+  const wordsWeight = o.split === false ? 0 : 6;
+  const rows = prep(ix, `SELECT f.key AS key, n.kind AS kind, n.id AS id, n.name AS name, n.file AS file,
+              bm25(fts, 0.0, 10.0, 8.0, 1.0, ${wordsWeight.toFixed(1)}) AS rank
+       FROM fts f JOIN nodes n ON n.key = f.key
+       WHERE fts MATCH ?${kinds ? ` AND n.kind IN (${kinds.map(() => "?").join(", ")})` : ""}${askedOnly.length ? ` AND n.kind NOT IN (${askedOnly.map(() => "?").join(", ")})` : ""}
+       ORDER BY rank, f.key LIMIT ?`).all(match, ...kinds ?? [], ...askedOnly, o.limit ?? 20);
+  return rows.map(({ rank, ...r }) => ({ ...r, score: round(-rank) }));
+}
+var statements = /* @__PURE__ */ new WeakMap();
+function prep(ix, sql) {
+  let m = statements.get(ix.db);
+  if (!m)
+    statements.set(ix.db, m = /* @__PURE__ */ new Map());
+  let st = m.get(sql);
+  if (!st)
+    m.set(sql, st = ix.db.prepare(sql));
+  return st;
+}
+var round = (n) => Math.round(n * 1e6) / 1e6;
+var NODE_SQL = `SELECT n.key, n.kind, n.id, n.grp, n.name, n.file, n.verified, n.line, n.detail, n.json,
+  (SELECT r.verdict FROM reviews r WHERE r.item = n.id ORDER BY r.at DESC, r.file LIMIT 1) AS review
+  FROM nodes n`;
+function toNode(r) {
+  return {
+    key: r.key,
+    kind: r.kind,
+    id: r.id,
+    grp: r.grp,
+    name: r.name,
+    file: r.file,
+    verified: r.verified === 1 || r.review === "verified" || r.review === "corrected",
+    line: r.line,
+    detail: r.detail,
+    ...r.json ? { json: JSON.parse(r.json) } : {},
+    ...r.review ? { review: r.review } : {}
+  };
+}
+function nodesById(ix, id) {
+  return prep(ix, `${NODE_SQL} WHERE n.id = ? ORDER BY n.grp, n.kind`).all(id).map(toNode);
+}
+function nodeByKey(ix, key) {
+  const r = prep(ix, `${NODE_SQL} WHERE n.key = ?`).get(key);
+  return r ? toNode(r) : void 0;
+}
+function linksOf(ix, key) {
+  const self = prep(ix, "SELECT id FROM nodes WHERE key = ?").get(key);
+  if (!self)
+    return [];
+  const out = prep(ix, `SELECT DISTINCT d.key AS key, d.kind AS kind, d.id AS id, l.type AS type, l.how AS how
+       FROM links l JOIN nodes d ON d.id = l.to_ref
+       WHERE l.from_key = ? AND l.by = 'id' AND d.key != l.from_key
+       UNION
+       SELECT DISTINCT d.key, d.kind, d.id, l.type, l.how
+       FROM links l JOIN names m ON m.name = l.to_ref JOIN nodes d ON d.id = m.id
+       WHERE l.from_key = ? AND l.by = 'name' AND d.key != l.from_key`).all(key, key);
+  const inn = prep(ix, `SELECT DISTINCT d.key AS key, d.kind AS kind, d.id AS id, l.type AS type, l.how AS how
+       FROM links l JOIN nodes d ON d.key = l.from_key
+       WHERE l.by = 'id' AND l.to_ref = ? AND l.from_key != ?
+       UNION
+       SELECT DISTINCT d.key, d.kind, d.id, l.type, l.how
+       FROM names m JOIN links l ON l.by = 'name' AND l.to_ref = m.name JOIN nodes d ON d.key = l.from_key
+       WHERE m.id = ? AND l.from_key != ?`).all(self.id, key, self.id, key);
+  const all = [
+    ...out.map((l) => ({ dir: "out", ...l })),
+    ...inn.map((l) => ({ dir: "in", ...l }))
+  ];
+  return all.sort((a, b) => cmp(a.key, b.key) || cmp(a.dir, b.dir) || cmp(a.type, b.type) || cmp(a.how, b.how));
+}
+var cmp = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var RRF_K = 1;
+var RANK_FLOOR = 0.3;
+var MEANING_FLOOR = 0.3;
+function fuse(rankings, k = RRF_K) {
+  const sum = /* @__PURE__ */ new Map();
+  for (const r of rankings)
+    r.keys.forEach((key, i) => {
+      const v = 1 / (k + i + 1);
+      const s = sum.get(key) ?? { score: 0, parts: [] };
+      s.score += v;
+      const d = r.detail?.get(key);
+      s.parts.push({ name: `${r.name} #${i + 1}${d ? ` (${d})` : ""}`, rank: i + 1, v });
+      sum.set(key, s);
+    });
+  const best = Math.max(0, ...[...sum.values()].map((s) => s.score));
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, s] of [...sum].sort((a, b) => cmp(a[0], b[0]))) {
+    const parts = [...s.parts].sort((a, b) => b.v - a.v || cmp(a.name, b.name)).slice(0, 3);
+    out.set(key, {
+      score: round(0.95 * s.score / best),
+      via: `search (${parts.map((p) => p.name).join(", ")})`
+    });
+  }
+  return out;
+}
+function synonymsOf(ix, names, text, maxWords) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const namesOfId = prep(ix, "SELECT DISTINCT name, how FROM names WHERE id = ? ORDER BY name");
+  for (const m of namesIn(text, names, maxWords)) {
+    if (seen.has(m.name))
+      continue;
+    seen.add(m.name);
+    const words = /* @__PURE__ */ new Set();
+    for (const id of names.get(m.name) ?? []) {
+      const all = namesOfId.all(id);
+      const nodes = nodesById(ix, id);
+      const term = nodes.find((n) => n.kind === "GlossaryTerm");
+      const alias = all.some((r) => r.name === m.name && r.how.startsWith("alias:"));
+      if (!term && !alias)
+        continue;
+      for (const r of all)
+        if (r.name !== m.name)
+          words.add(r.name);
+      if (term) {
+        const x = term.json ?? {};
+        if (x.term)
+          words.add(x.term.toLowerCase());
+        for (const f of x.fields ?? [])
+          if (typeof f === "string")
+            for (const n of nodesById(ix, f))
+              words.add(identifierWords(n.name).join(" "));
+      }
+    }
+    if (words.size)
+      out.push({ name: m.name, words: [...words].sort() });
+  }
+  return out;
+}
+var trust = (key) => key.startsWith("document:") ? 0.8 : 1;
+var GROUP_ORDER = [
+  "catalog",
+  "flow",
+  "knowledge",
+  "change",
+  "question",
+  "wiki",
+  "document",
+  "org-pack"
+];
+function describe(n) {
+  const x = n.json ?? {};
+  const out = [];
+  for (const f of ["boundary", "partyKind", "productKind"])
+    if (typeof x[f] === "string")
+      out.push(String(x[f]).replace(/-/g, " "));
+  if (n.grp === "org-pack") {
+    const m = /\(([a-z-]+)\)/.exec(n.line);
+    if (m)
+      out.push(m[1]);
+  }
+  return out;
+}
+function namesMap(ix) {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of prep(ix, "SELECT DISTINCT name, id FROM names ORDER BY name, id").all()) {
+    const l = out.get(r.name) ?? [];
+    l.push(r.id);
+    out.set(r.name, l);
+  }
+  return out;
+}
+function endpointsIn(text) {
+  return [...text.matchAll(/\b(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+(\/[^\s`"'),;]*)/g)].map((m) => endpointName(m[1], m[2].replace(/[.:]+$/, "")));
+}
+var GENERIC = new Set("api apis service services system systems team app apps application platform portal ui ux gateway database db store queue topic site module library sdk client server backend frontend web mobile integration endpoint endpoints".split(" "));
+var FILE = /\.(md|markdown|ya?ml|json|java|kt|ts|tsx|js|mjs|py|go|cs|rb|sql|xml|txt|csv|html?|properties|sh|toml|ini|cfg)$/i;
+function nameCandidates(text) {
+  const out = /* @__PURE__ */ new Set();
+  const body = text.split(/\r?\n/).filter((l) => !/^\s*#/.test(l) && !/^\s*<!--/.test(l)).join("\n");
+  for (const m of body.matchAll(/`([^`\n]{2,60})`/g)) {
+    const t = m[1].trim();
+    if (/^(GET|POST|PUT|PATCH|DELETE)\s+\//.test(t))
+      continue;
+    const id = /^[a-z0-9]+(?:[-.][a-z0-9]+)+$/.test(t) && !FILE.test(t);
+    const name = /^[A-Z][A-Za-z0-9]*(?: [A-Z][A-Za-z0-9]*){0,3}$/.test(t);
+    if (id || name)
+      out.add(t);
+  }
+  for (const m of body.matchAll(/\b(GET|POST|PUT|PATCH|DELETE)\s+(\/[^\s`"'),;]*)/g))
+    out.add(`${m[1]} ${m[2].replace(/[.:]+$/, "")}`);
+  return [...out];
+}
+function knownName(ix, names, maxWords, candidate) {
+  const m = /^(GET|POST|PUT|PATCH|DELETE)\s+(\/\S*)$/.exec(candidate);
+  if (m)
+    return names.has(endpointName(m[1], m[2]));
+  const f = foldName(candidate);
+  if (names.has(f) || names.has(f.replace(/ /g, "-")))
+    return true;
+  const toks = f.split(/[\s-]+/).filter(Boolean);
+  const covered = new Array(toks.length).fill(false);
+  for (const hit of namesIn(toks.join(" "), names, maxWords)) {
+    const n = hit.name.split(" ").length;
+    for (let i = hit.at; i < hit.at + n && i < toks.length; i++)
+      covered[i] = true;
+  }
+  if (covered.some(Boolean) && toks.every((t, i) => covered[i] || GENERIC.has(t)))
+    return true;
+  const words = queryWords(candidate, 200, { split: false });
+  if (words.length < 2 || words.length !== toks.length)
+    return false;
+  const phrase = `"${words.join(" ")}"`;
+  return !!prep(ix, `SELECT 1 FROM fts f JOIN nodes n ON n.key = f.key WHERE fts MATCH ? AND n.grp != 'change' LIMIT 1`).get(phrase);
+}
+function candidatesOf(ix, input, o) {
+  const names = namesMap(ix);
+  const maxWords = Math.min(8, Math.max(1, ...[...names.keys()].map((k) => k.split(" ").length)));
+  const text = input.text;
+  const title = input.title ?? "";
+  const rejected = new Set(o.includeRejected ? [] : prep(ix, `SELECT item FROM reviews r WHERE verdict = 'rejected' AND at = (SELECT max(at) FROM reviews x WHERE x.item = r.item)`).all().map((r) => r.item));
+  const through = o.through?.length ? new Set(o.through) : void 0;
+  const seeds = /* @__PURE__ */ new Map();
+  const seed = (key, score, via) => {
+    const was = seeds.get(key);
+    if (!was)
+      seeds.set(key, { score, via });
+    else
+      seeds.set(key, { score: 1 - (1 - was.score) * (1 - score), via: was.via });
+  };
+  const exactIds = new Set(input.ids ?? []);
+  for (const m of namesIn(`${title}
+${text}`, names, maxWords))
+    for (const id of names.get(m.name) ?? [])
+      exactIds.add(id);
+  for (const e of endpointsIn(`${title}
+${text}`))
+    for (const id of names.get(e) ?? [])
+      exactIds.add(id);
+  const expansion = [];
+  for (const id of [...exactIds].sort())
+    for (const n of nodesById(ix, id)) {
+      if (rejected.has(n.id))
+        continue;
+      seed(n.key, 1, "named in the input");
+      expansion.push(...describe(n));
+    }
+  for (const id of [...new Set(input.expansion?.ids ?? [])].sort())
+    if (!exactIds.has(id))
+      for (const n of nodesById(ix, id)) {
+        if (rejected.has(n.id))
+          continue;
+        seed(n.key, 0.9, "named in the input (the model's reading, an id the index has)");
+        expansion.push(...describe(n));
+      }
+  const limit = o.searchLimit ?? 30;
+  const split = o.lexical?.split !== false;
+  const hitScore = /* @__PURE__ */ new Map();
+  const hitVia = /* @__PURE__ */ new Map();
+  const query = `${text}
+${expansion.join(" ")}`;
+  const about = [...new Set(expansion)].join(" ");
+  const synonyms = o.lexical?.synonyms === false ? [] : synonymsOf(ix, names, `${title}
+${text}`, maxWords);
+  const extra = [
+    ...input.rankings ?? [],
+    ...(input.expansion?.terms ?? []).slice(0, 8).map((t) => ({ name: `the model's "${t}"`, text: t }))
+  ];
+  const floor = o.rankFloor ?? RANK_FLOOR;
+  const ranked = (q, k) => {
+    const hs = searchIndex(ix, q, k);
+    const best = hs[0]?.score ?? 0;
+    return hs.filter((h) => h.score >= best * floor).map((h) => h.key);
+  };
+  for (const kinds2 of o.kinds?.length ? [void 0, o.kinds] : [void 0]) {
+    const k = { limit, split, ...kinds2 ? { kinds: kinds2 } : {} };
+    const rankings = [{ name: "words", keys: ranked(query, k) }];
+    if (title)
+      rankings.push({ name: "title", keys: ranked(title, k) });
+    if (about)
+      rankings.push({ name: "what is named", keys: ranked(about, k) });
+    for (const syn of synonyms)
+      rankings.push({
+        name: `synonyms of "${syn.name}"`,
+        keys: ranked(syn.words.join(" "), k)
+      });
+    if (o.meaning !== false) {
+      const sim = ix.similar(input, {
+        limit,
+        ...kinds2 ? { kinds: kinds2 } : {},
+        ...o.meaningFloor !== void 0 ? { floor: o.meaningFloor } : {}
+      });
+      if ("hits" in sim)
+        rankings.push({
+          name: "similar in meaning",
+          keys: sim.hits.map((h) => h.key),
+          detail: new Map(sim.hits.map((h) => [h.key, `cos ${h.cos.toFixed(2)}`]))
+        });
+    }
+    for (const r of extra)
+      rankings.push({
+        name: r.name,
+        keys: (r.keys ?? ranked(r.text ?? "", k)).filter((key) => !kinds2 || kinds2.includes(key.split(":")[1])).slice(0, limit)
+      });
+    for (const [key, v] of fuse(rankings, o.rrfK ?? RRF_K)) {
+      if (v.score > (hitScore.get(key) ?? 0)) {
+        hitScore.set(key, v.score);
+        hitVia.set(key, v.via);
+      }
+    }
+  }
+  for (const [key, s] of [...hitScore].sort((a, b) => cmp(a[0], b[0])))
+    if (!rejected.has(key.split(":").slice(2).join(":")))
+      seed(key, Math.min(0.95, s), hitVia.get(key) ?? "search");
+  const kindOf = /* @__PURE__ */ new Map();
+  const meta2 = prep(ix, "SELECT kind, id FROM nodes WHERE key = ?");
+  const info = (key) => {
+    let v = kindOf.get(key);
+    if (!v) {
+      v = meta2.get(key);
+      if (v)
+        kindOf.set(key, v);
+    }
+    return v;
+  };
+  const hops = o.hops ?? 2;
+  const fanout = o.fanout ?? 24;
+  const near = /* @__PURE__ */ new Map();
+  const neighbours = (key) => {
+    let l = near.get(key);
+    if (!l) {
+      const seen = /* @__PURE__ */ new Set();
+      l = linksOf(ix, key).filter((x) => !rejected.has(x.id)).filter((x) => seen.has(x.key) ? false : (seen.add(x.key), true)).sort((a, b) => (hitScore.get(b.key) ?? 0) - (hitScore.get(a.key) ?? 0) || cmp(a.key, b.key)).slice(0, fanout);
+      near.set(key, l);
+    }
+    return l;
+  };
+  const contributions = /* @__PURE__ */ new Map();
+  for (const [key, s] of [...seeds].sort((a, b) => cmp(a[0], b[0]))) {
+    const best = /* @__PURE__ */ new Map([[key, s]]);
+    let frontier = [key];
+    for (let h = 1; h <= hops && frontier.length; h++) {
+      const next = [];
+      for (const k of frontier) {
+        const at = info(k);
+        if (h > 1 && through && at && !through.has(at.kind))
+          continue;
+        const from = best.get(k);
+        for (const n of neighbours(k)) {
+          const score = from.score * 0.5;
+          const was = best.get(n.key);
+          if (was && was.score >= score)
+            continue;
+          if (!was)
+            next.push(n.key);
+          best.set(n.key, {
+            score,
+            via: `${n.dir === "out" ? `${at?.id ?? k} ${n.type} ${n.id}` : `${n.id} ${n.type} ${at?.id ?? k}`} (${n.how})`
+          });
+        }
+      }
+      frontier = next.sort();
+    }
+    for (const [k, v] of best) {
+      const l = contributions.get(k) ?? [];
+      l.push(v);
+      contributions.set(k, l);
+    }
+  }
+  const kinds = o.kinds?.length ? new Set(o.kinds) : void 0;
+  const exclude = new Set(o.exclude ?? []);
+  const groups = o.groups?.length ? new Set(o.groups) : void 0;
+  const verified = new Map(prep(ix, `SELECT n.key AS key, n.verified AS v,
+             (SELECT r.verdict FROM reviews r WHERE r.item = n.id ORDER BY r.at DESC LIMIT 1) AS review
+           FROM nodes n`).all().map((r) => [r.key, r.v === 1 || r.review === "verified" || r.review === "corrected"]));
+  const byKindId = /* @__PURE__ */ new Map();
+  for (const [key, cs] of contributions) {
+    const i = info(key);
+    if (!i || rejected.has(i.id) || exclude.has(i.id))
+      continue;
+    if (kinds && !kinds.has(i.kind))
+      continue;
+    if (groups && !groups.has(key.split(":")[0]))
+      continue;
+    const sorted = [...cs].sort((a, b) => b.score - a.score || cmp(a.via, b.via));
+    const text2 = 1 - sorted.reduce((p, c2) => p * (1 - Math.min(1, c2.score)), 1);
+    const score = round(text2 * trust(key) * (verified.get(key) ? 1.2 : 1));
+    if (score < (o.minScore ?? 0.1))
+      continue;
+    const grp = key.split(":")[0];
+    const k = `${i.kind}|${i.id}`;
+    const was = byKindId.get(k);
+    const c = { key, kind: i.kind, id: i.id, score, via: sorted[0].via, grp };
+    if (!was || GROUP_ORDER.indexOf(grp) < GROUP_ORDER.indexOf(was.grp) || grp === was.grp && key < was.key)
+      byKindId.set(k, was ? { ...c, score: Math.max(score, was.score) } : c);
+    else
+      byKindId.set(k, { ...was, score: Math.max(score, was.score) });
+  }
+  const candidates = [...byKindId.values()].map(({ grp: _g, ...c }) => c).sort((a, b) => b.score - a.score || cmp(a.key, b.key));
+  const asked = input.expansion ? [.../* @__PURE__ */ new Set([...input.expansion.unknown, ...nameCandidates(`${title}
+${text}`)])] : nameCandidates(`${title}
+${text}`);
+  const unknown = asked.filter((c) => !knownName(ix, names, maxWords, c)).sort();
+  return { candidates, unknown };
+}
+var candidateRef = (c) => `${c.kind} ${c.id}`;
+function orderCandidates(candidates, order) {
+  if (!order)
+    return { candidates, dropped: [], used: false };
+  const shown = new Set(order.shown);
+  const named2 = order.refs;
+  const byRef = new Map(candidates.map((c) => [candidateRef(c), c]));
+  const valid = new Set(named2).size === named2.length && named2.every((r) => shown.has(r) && byRef.has(r));
+  if (!valid)
+    return { candidates, dropped: [], used: false };
+  const keep = new Set(named2);
+  return {
+    candidates: [
+      ...named2.map((r) => byRef.get(r)),
+      ...candidates.filter((c) => !shown.has(candidateRef(c)))
+    ],
+    dropped: candidates.filter((c) => shown.has(candidateRef(c)) && !keep.has(candidateRef(c))),
+    used: true
+  };
+}
+var wrapped = (id, kind, origin, textLength) => `<atticus-data id="${id}" kind="${kind}" origin="${origin}">
+
+</atticus-data>`.length + textLength;
+var tokensOf = (chars) => Math.ceil(chars / 4);
+function selectContext(ix, raw, o) {
+  const input = typeof raw === "string" ? { text: raw } : raw;
+  const m = ix.meaning();
+  const probe = o.meaning === false || !m.on ? void 0 : ix.similar(input, { limit: 1 });
+  const meaning = o.meaning === false ? "similar in meaning is off for this step" : probe && "off" in probe ? `similar in meaning is off: ${probe.off}` : m.note;
+  const meaningOn = !!probe && "hits" in probe;
+  const version = meaningOn ? `${ix.version}+${m.model}` : ix.version;
+  const keyed = {
+    input,
+    kinds: o.kinds ?? null,
+    groups: o.groups ?? null,
+    through: o.through ?? null,
+    lexical: o.lexical ?? null,
+    rrfK: o.rrfK ?? RRF_K,
+    rankFloor: o.rankFloor ?? RANK_FLOOR,
+    hops: o.hops ?? 2,
+    fanout: o.fanout ?? 24,
+    searchLimit: o.searchLimit ?? 30,
+    minScore: o.minScore ?? 0.1,
+    exclude: o.exclude ?? null,
+    includeRejected: o.includeRejected ?? false,
+    meaning: meaningOn ? o.meaningFloor ?? "default" : false
+  };
+  const cacheKey = createHash2("sha256").update(`${version}
+${JSON.stringify(keyed)}`).digest("hex");
+  let cached = false;
+  let found;
+  const hit = prep(ix, "SELECT json FROM selections WHERE key = ?").get(cacheKey);
+  if (hit) {
+    found = JSON.parse(hit.json);
+    cached = true;
+  } else {
+    found = candidatesOf(ix, input, o);
+    try {
+      prep(ix, "INSERT OR REPLACE INTO selections VALUES (?, ?)").run(cacheKey, JSON.stringify(found));
+    } catch {
+    }
+  }
+  const prefix = o.idPrefix ?? "ctx-";
+  const base = o.priority ?? 50;
+  const classification = o.classification ?? "internal";
+  const budget = Math.max(0, Math.floor(o.budget * 0.98));
+  const fullBudget = budget * (o.fullShare ?? 0.6);
+  const sources = [];
+  const picked = [];
+  const leftOut = [];
+  const linesId = `${prefix}lines`;
+  const linesOrigin = "the index, one line each (ask for one in full by its id)";
+  const heading = o.linesHeading ?? "More that may matter, one line each; each names its id and where it is read from:";
+  const lines = [];
+  let linesChars = 0;
+  let used = 0;
+  let phase = "full";
+  let full = 0;
+  let over = false;
+  const ordered = orderCandidates(found.candidates, o.order);
+  const nameOf = (key) => prep(ix, "SELECT name FROM nodes WHERE key = ?").get(key)?.name;
+  const named2 = (key) => {
+    const n = nameOf(key);
+    return n ? { name: n } : {};
+  };
+  for (const c of ordered.candidates) {
+    if (over) {
+      leftOut.push({ id: c.id, kind: c.kind, score: c.score, ...named2(c.key) });
+      continue;
+    }
+    const n = nodeByKey(ix, c.key);
+    if (!n)
+      continue;
+    const kind = n.grp === "catalog" || n.grp === "flow" || n.grp === "org-pack" ? "catalog" : "document";
+    if (phase === "full") {
+      const text = o.render?.(n, "full") ?? n.detail;
+      const id = `${prefix}${n.kind}-${n.id}`.replace(/[^\w.#:/-]+/g, "-");
+      const t2 = tokensOf(wrapped(id, kind, n.file, text.length));
+      if (used + t2 <= fullBudget && (o.maxFull === void 0 || full < o.maxFull)) {
+        used += t2;
+        full++;
+        sources.push({
+          id,
+          kind,
+          origin: n.file,
+          text,
+          classification,
+          priority: round(base - sources.length * 1e-3)
+        });
+        picked.push({
+          key: n.key,
+          kind: n.kind,
+          id: n.id,
+          score: c.score,
+          level: "full",
+          file: n.file,
+          name: n.name,
+          via: c.via
+        });
+        continue;
+      }
+      phase = "line";
+    }
+    const line = o.render?.(n, "line") ?? n.line;
+    const nextChars = (linesChars || heading.length) + line.length + 1;
+    const t = tokensOf(wrapped(linesId, "catalog", linesOrigin, nextChars));
+    if (used + t <= budget) {
+      lines.push(line);
+      linesChars = nextChars;
+      picked.push({
+        key: n.key,
+        kind: n.kind,
+        id: n.id,
+        score: c.score,
+        level: "line",
+        file: n.file,
+        name: n.name,
+        via: c.via
+      });
+    } else {
+      over = true;
+      leftOut.push({ id: n.id, kind: n.kind, score: c.score, ...n.name ? { name: n.name } : {} });
+    }
+  }
+  for (const d of ordered.dropped)
+    leftOut.push({
+      id: d.id,
+      kind: d.kind,
+      score: d.score,
+      why: "the model judged it not needed",
+      ...named2(d.key)
+    });
+  if (lines.length)
+    sources.push({
+      id: linesId,
+      kind: "catalog",
+      origin: linesOrigin,
+      text: [heading, ...lines].join("\n"),
+      classification,
+      priority: round(base - (sources.length + 1) * 1e-3)
+    });
+  const tokens2 = used + (lines.length ? tokensOf(wrapped(linesId, "catalog", linesOrigin, linesChars)) : 0);
+  return { sources, picked, leftOut, unknown: found.unknown, tokens: tokens2, version, cached, meaning };
+}
+
+// packages/index/dist/catalog-index.js
+import { mkdir } from "node:fs/promises";
+import { dirname as dirname2, join as join3 } from "node:path";
+
+// packages/index/dist/db.js
+import { createRequire } from "node:module";
+var __atticus_import_meta_url = __atticusUrl("packages/index/dist/db.js");
+function openDb(file) {
+  const emit = process.emitWarning;
+  process.emitWarning = ((warning, ...rest) => {
+    const text = typeof warning === "string" ? warning : warning.message;
+    if (/SQLite/i.test(text))
+      return;
+    emit.call(process, warning, ...rest);
+  });
+  try {
+    const { DatabaseSync } = createRequire(__atticus_import_meta_url)("node:sqlite");
+    const db = new DatabaseSync(file);
+    db.exec("PRAGMA busy_timeout = 5000");
+    return db;
+  } finally {
+    process.emitWarning = emit;
+  }
+}
+
+// packages/index/dist/catalog-index.js
+var vectorsFileOf = (file) => join3(dirname2(file), "vectors.sqlite");
+var notInstalled = (e, pkg) => e.code === "ERR_MODULE_NOT_FOUND" && String(e.message).includes(pkg);
+async function embedderOf(root, setting, load = () => import("./chunk-TANFV3MZ.js")) {
+  if (setting === "off")
+    return { why: "turned off for this command" };
+  if (setting && setting !== "auto")
+    return { embedder: setting };
+  let embed;
+  try {
+    embed = await load();
+  } catch (e) {
+    if (notInstalled(e, "@maycombhq/embed"))
+      return {
+        why: "search by meaning is an optional plugin that isn't installed (@maycombhq/embed)"
+      };
+    return { why: `the embedding model couldn't be read: ${e.message.split("\n")[0]}` };
+  }
+  try {
+    const { embedderFor } = embed;
+    const r = await embedderFor(root);
+    return r.embedder ? { embedder: r.embedder } : { why: r.state.problem ?? "no embedding model" };
+  } catch (e) {
+    return { why: `the embedding model couldn't be read: ${e.message.split("\n")[0]}` };
+  }
+}
+async function openIndex(root, o = {}) {
+  const file = o.file ?? join3(stateDirOf(root), ".index", "catalog.sqlite");
+  await mkdir(dirname2(file), { recursive: true });
+  const files = await listSources(root);
+  const db = openDb(file);
+  try {
+    const fresh = ensureSchema(db, o.rebuild === true);
+    const u = await updateIndex(db, root, files, { force: fresh });
+    const rebuilt = fresh || u.changed.length > 0 || u.removed.length > 0;
+    attachVectors(db, vectorsFileOf(file));
+    const e = await embedderOf(root, o.embeddings, o.loadEmbed);
+    const ix = new CatalogIndex(db, file, u.problems, rebuilt, u, e.embedder, e.why);
+    if (e.embedder && (o.embedOnOpen ?? 500) > 0)
+      await ix.embed({ max: o.embedOnOpen ?? 500 }).catch((err) => {
+        ix.meaningProblem = `the embedding model couldn't run: ${err.message.split("\n")[0]}`;
+      });
+    return ix;
+  } catch (e) {
+    db.close();
+    throw e;
+  }
+}
+var CatalogIndex = class {
+  db;
+  file;
+  problems;
+  rebuilt;
+  update;
+  embedder;
+  noEmbedder;
+  constructor(db, file, problems, rebuilt, update, embedder, noEmbedder) {
+    this.db = db;
+    this.file = file;
+    this.problems = problems;
+    this.rebuilt = rebuilt;
+    this.update = update;
+    this.embedder = embedder;
+    this.noEmbedder = noEmbedder;
+  }
+  /** Set when the model is configured but couldn't run. */
+  meaningProblem;
+  matrix;
+  rows;
+  close() {
+    this.db.close();
+  }
+  /** Whether "similar in meaning" is on: a model, and a vector for every node (ADR 0116). */
+  meaning() {
+    if (this.meaningProblem)
+      return { ...meaningState(this.db, void 0, this.meaningProblem), model: this.embedder?.id };
+    return meaningState(this.db, this.embedder, this.noEmbedder);
+  }
+  /** Embed the nodes that have no vector yet (all, or at most `max`). */
+  async embed(o = {}) {
+    if (!this.embedder)
+      return 0;
+    const n = await embedMissing(this.db, this.embedder, o);
+    if (n) {
+      this.matrix = void 0;
+      this.rows = void 0;
+    }
+    return n;
+  }
+  /** Embed what an input will be compared by (its title and paragraphs), so a selection can. */
+  async prepare(input) {
+    if (!this.embedder || this.meaningProblem || !this.meaning().on)
+      return;
+    const i = typeof input === "string" ? { text: input } : input;
+    await queryVectors(this.db, this.embedder, queryChunks(i)).catch((err) => {
+      this.meaningProblem = `the embedding model couldn't run: ${err.message.split("\n")[0]}`;
+    });
+  }
+  /**
+   * The nodes nearest an input in meaning, best first: a ranking, never a link (ADR 0116).
+   * Undefined, with why, when similarity is off or the input wasn't prepared.
+   */
+  similar(input, o = {}) {
+    const state = this.meaning();
+    if (!state.on || !this.embedder)
+      return { off: state.note };
+    let queries;
+    let exclude;
+    if (typeof input === "object" && "key" in input) {
+      this.matrix ??= loadMatrix(this.db, this.embedder.id);
+      const at = this.matrix.keys.indexOf(input.key);
+      if (at < 0)
+        return { off: `${input.key} has no vector` };
+      const d = this.matrix.dim;
+      queries = [
+        { q: this.matrix.q.subarray(at * d, (at + 1) * d), scale: this.matrix.scales[at] }
+      ];
+      exclude = /* @__PURE__ */ new Set([input.key]);
+    } else {
+      const i = typeof input === "string" ? { text: input } : input;
+      const chunks = queryChunks(i);
+      const vs = chunks.map((c) => cachedQuery(this.db, this.embedder.id, textSha(c)));
+      if (!chunks.length)
+        return { hits: [] };
+      if (vs.some((v) => !v))
+        return { off: "the input wasn't embedded (prepare it first)" };
+      queries = vs;
+    }
+    this.matrix ??= loadMatrix(this.db, this.embedder.id);
+    return {
+      hits: nearest(this.matrix, queries, {
+        floor: o.floor ?? this.embedder.floor ?? MEANING_FLOOR,
+        limit: o.limit ?? 30,
+        ...o.kinds ? { kinds: o.kinds } : {},
+        ...exclude ? { exclude } : {}
+      })
+    };
+  }
+  /**
+   * How close in meaning each of these nodes is to the texts (ADR 0132 addendum): the best
+   * cosine of a node's stored vector over the texts' vectors. The texts are embedded as queries
+   * once and kept; a node is never embedded here (a node with no vector is left out). Off, with
+   * why, when similarity is off.
+   */
+  async closeness(texts, keys) {
+    const state = this.meaning();
+    if (!state.on || !this.embedder)
+      return { off: state.note };
+    const asked = [...new Set(texts.map((t) => t.replace(/\s+/g, " ").trim()).filter((t) => t))];
+    if (!asked.length)
+      return { cos: /* @__PURE__ */ new Map() };
+    let queries;
+    try {
+      queries = await queryVectors(this.db, this.embedder, asked);
+    } catch (err) {
+      this.meaningProblem = `the embedding model couldn't run: ${err.message.split("\n")[0]}`;
+      return { off: this.meaning().note };
+    }
+    this.matrix ??= loadMatrix(this.db, this.embedder.id);
+    this.rows ??= new Map(this.matrix.keys.map((k, i) => [k, i]));
+    return { cos: cosines(this.matrix, this.rows, queries, keys) };
+  }
+  /**
+   * The estate's names (ADR 0116): each id of these kinds with every name and alias it goes by,
+   * in id order, for a model to map an input's names to (the expansion's digest).
+   */
+  names(kinds) {
+    const rows = this.db.prepare(`SELECT DISTINCT d.id AS id, d.kind AS kind, n.name AS name FROM nodes d JOIN names n ON n.id = d.id
+         WHERE d.kind IN (${kinds.map(() => "?").join(", ")}) ORDER BY d.id, d.kind, n.name`).all(...kinds);
+    const out = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      const k = `${r.kind}|${r.id}`;
+      const e = out.get(k) ?? { id: r.id, kind: r.kind, names: [] };
+      if (r.name !== r.id && !e.names.includes(r.name))
+        e.names.push(r.name);
+      out.set(k, e);
+    }
+    return [...out.values()];
+  }
+  /** selectContext, with the input embedded first when similarity is on (ADR 0116). */
+  async select(input, o) {
+    await this.prepare(input);
+    return selectContext(this, input, o);
+  }
+  /**
+   * The index's version: a hash of every file it read, so the same files give the same version
+   * on every machine. Selections are cached under it.
+   */
+  get version() {
+    return this.db.prepare("SELECT value FROM meta WHERE key = 'generation'").get()?.value ?? "empty";
+  }
+  /** Full-text search over every node (ADR 0107 point 2): names and ids rank above prose. */
+  search(text, o = {}) {
+    return searchIndex(this, text, o);
+  }
+  /** The context a step should see for its input, fitted to a budget (ADR 0107 point 3). */
+  selectContext(input, o) {
+    return selectContext(this, input, o);
+  }
+  /** The nodes with this id, whatever their kind (a catalog record, a flow, an item...). */
+  nodes(id) {
+    return nodesById(this, id);
+  }
+  /** What a node links to and what links to it, each with how the link was made. */
+  links(key) {
+    return linksOf(this, key);
+  }
+  /** Records matching a query in the catalog query language, ordered by kind and id. */
+  query(text, o = {}) {
+    const { where, params } = compileQuery(parseQuery(text));
+    const total = this.db.prepare(`SELECT count(*) AS n FROM records r WHERE ${where}`).get(...params).n;
+    const rows = this.db.prepare(`SELECT kind, id, status, confidence, name, system, file FROM records r WHERE ${where} ORDER BY kind, id LIMIT ? OFFSET ?`).all(...params, o.limit ?? 100, o.offset ?? 0);
+    return { rows, total };
+  }
+  /** The full records for rows. */
+  records(rows) {
+    const get = this.db.prepare("SELECT json FROM records WHERE kind = ? AND id = ?");
+    return rows.map((r) => JSON.parse(get.get(r.kind, r.id).json));
+  }
+  /** One record, or undefined. */
+  get(kind, id) {
+    const row = this.db.prepare("SELECT json FROM records WHERE kind = ? AND id = ?").get(kind, id);
+    return row ? JSON.parse(row.json) : void 0;
+  }
+  /** Every record with this id, whatever its kind. */
+  find(id) {
+    return this.db.prepare("SELECT json FROM records WHERE id = ? ORDER BY kind").all(id).map((r) => JSON.parse(r.json));
+  }
+  /** The system a record belongs to, as worked out when the index was built. */
+  systemOf(kind, id) {
+    return this.db.prepare("SELECT system FROM records WHERE kind = ? AND id = ?").get(kind, id)?.system ?? void 0;
+  }
+  /** Records that refer to id: which record, by which field. */
+  referencesTo(id) {
+    return this.db.prepare("SELECT from_kind AS kind, from_id AS id, field FROM refs WHERE to_id = ? ORDER BY from_kind, from_id, field").all(id);
+  }
+  /** Count per kind, with how many are flagged stale. */
+  kinds() {
+    return this.db.prepare("SELECT kind, count(*) AS count, sum(stale) AS stale FROM records GROUP BY kind ORDER BY kind").all();
+  }
+  /** Records of one kind, filtered and paged by id (the API's listRecords). */
+  list(kind, o = {}) {
+    const where = ["kind = ?"];
+    const params = [kind];
+    if (o.status) {
+      where.push("status = ?");
+      params.push(o.status);
+    }
+    if (o.system) {
+      where.push("system = ?");
+      params.push(o.system);
+    }
+    if (o.q) {
+      where.push("(lower(id) LIKE ? OR lower(name) LIKE ?)");
+      params.push(`%${o.q.toLowerCase()}%`, `%${o.q.toLowerCase()}%`);
+    }
+    const total = this.db.prepare(`SELECT count(*) AS n FROM records WHERE ${where.join(" AND ")}`).get(...params).n;
+    const after = o.cursor ? Buffer.from(o.cursor, "base64url").toString("utf8") : void 0;
+    const limit = Math.min(Math.max(o.limit ?? 50, 1), 500);
+    const rows = this.db.prepare(`SELECT id, json FROM records WHERE ${where.join(" AND ")}${after !== void 0 ? " AND id > ?" : ""} ORDER BY id LIMIT ?`).all(...params, ...after !== void 0 ? [after] : [], limit + 1);
+    const page = rows.slice(0, limit);
+    return {
+      items: page.map((r) => JSON.parse(r.json)),
+      total,
+      ...rows.length > limit ? { next: Buffer.from(page[page.length - 1].id, "utf8").toString("base64url") } : {}
+    };
+  }
+};
+
+// packages/index/dist/graph.js
+function graph(ix, o = {}) {
+  const hops = ix.db.prepare(`SELECT id, json_extract(json, '$.from') AS "from", json_extract(json, '$.to') AS "to", json_extract(json, '$.via') AS via,
+                json_extract(json, '$.pattern.code') AS pattern, confidence, status
+         FROM records WHERE kind = 'Interface'${o.status ? " AND status = ?" : ""} ORDER BY id`).all(...o.status ? [o.status] : []).map((h) => ({ ...h, pattern: h.pattern ?? void 0 }));
+  for (const c of ix.db.prepare(`SELECT id, json_extract(json, '$.uses') AS uses, confidence, status FROM records
+       WHERE kind = 'Component' AND json_extract(json, '$.uses') IS NOT NULL${o.status ? " AND status = ?" : ""} ORDER BY id`).all(...o.status ? [o.status] : []))
+    for (const to of JSON.parse(c.uses))
+      hops.push({
+        id: `uses.${c.id}.${to}`,
+        from: c.id,
+        to,
+        via: "uses",
+        confidence: c.confidence,
+        status: c.status
+      });
+  const nodeRows = ix.db.prepare("SELECT kind, id, name, status, system FROM records WHERE kind IN ('System', 'Component') ORDER BY kind DESC, id").all();
+  const nodes = new Map(nodeRows.map((n) => [n.id, n]));
+  const systemOf = (id) => nodes.get(id)?.system ?? void 0;
+  let keep;
+  if (o.focus) {
+    const start = nodes.get(o.focus);
+    if (!start)
+      return { nodes: [], edges: [] };
+    keep = new Set(start.kind === "System" ? [
+      start.id,
+      ...nodeRows.filter((n) => n.kind === "Component" && n.system === start.id).map((n) => n.id)
+    ] : [start.id]);
+    let frontier = [...keep];
+    for (let d = 0; d < (o.depth ?? 1); d++) {
+      const next = [];
+      for (const h of hops) {
+        if (frontier.includes(h.from) && !keep.has(h.to))
+          next.push(h.to);
+        if (frontier.includes(h.to) && !keep.has(h.from))
+          next.push(h.from);
+      }
+      for (const n of next)
+        keep.add(n);
+      frontier = next;
+    }
+  } else
+    keep = /* @__PURE__ */ new Set([...nodes.keys(), ...hops.flatMap((h) => [h.from, h.to])]);
+  for (const id of [...keep]) {
+    const s = systemOf(id);
+    if (s && nodes.get(id)?.kind === "Component")
+      keep.add(s);
+  }
+  const outNodes = [...keep].filter((id) => nodes.has(id)).map((id) => {
+    const n = nodes.get(id);
+    return {
+      id,
+      kind: n.kind,
+      label: n.name,
+      status: n.status,
+      ...n.kind === "Component" && n.system ? { system: n.system } : {}
+    };
+  }).sort((a, b) => a.kind === b.kind ? a.id < b.id ? -1 : 1 : a.kind === "System" ? -1 : 1);
+  const edges = hops.filter((h) => keep.has(h.from) && keep.has(h.to)).map(({ pattern, ...e }) => ({ ...e, ...pattern ? { pattern } : {} }));
+  return { nodes: outNodes, edges };
+}
+function impact(ix, rootId, depth = 4) {
+  const roots = ix.find(rootId);
+  if (roots.length === 0)
+    return void 0;
+  const root = roots[0];
+  const recordOf = (kind, id) => ix.get(kind, id);
+  const anyRecord = (id) => ix.find(id)[0];
+  const step = (r) => {
+    const out = [];
+    const id = String(r.id);
+    if (r.kind === "Column" || r.kind === "IndexConstraint")
+      out.push({ kind: "Table", id: String(r.table), reason: `${id} is part of it` });
+    if (r.kind === "Table") {
+      for (const c of r.readers ?? [])
+        out.push({ kind: "", id: c, reason: `reads ${id}` });
+      for (const c of r.writers ?? [])
+        if (!(r.readers ?? []).includes(c))
+          out.push({ kind: "", id: c, reason: `writes ${id}` });
+    }
+    if (r.kind === "Interface") {
+      if (r.sync === "async")
+        out.push({
+          kind: "",
+          id: String(r.to),
+          reason: `receives ${String(r.normalizedPath)} from ${String(r.from)}`
+        });
+      else
+        out.push({
+          kind: "",
+          id: String(r.from),
+          reason: `calls ${String(r.to)}${r.method ? ` (${String(r.method)} ${String(r.normalizedPath)})` : ""}`
+        });
+    }
+    const isAsync = (interfaceId) => recordOf("Interface", interfaceId)?.sync === "async";
+    for (const ref of ix.referencesTo(id)) {
+      const k = ref.kind;
+      const f = ref.field;
+      if (k === "Interface" && f === "endpoint")
+        out.push({
+          kind: k,
+          id: ref.id,
+          reason: isAsync(ref.id) ? `carries ${id}` : `calls ${id}`
+        });
+      else if (k === "Interface" && f === "to" && r.kind !== "Endpoint" && !isAsync(ref.id))
+        out.push({ kind: k, id: ref.id, reason: `calls ${id}` });
+      else if (k === "Interface" && f === "from" && r.kind !== "Endpoint" && isAsync(ref.id))
+        out.push({ kind: k, id: ref.id, reason: `carries events published by ${id}` });
+      else if (k === "Interface" && f === "route")
+        out.push({ kind: k, id: ref.id, reason: `goes through ${id}` });
+      else if (k === "Endpoint" && f === "schemaRefs[]")
+        out.push({ kind: k, id: ref.id, reason: `uses schema ${id}` });
+      else if (k === "Setting" && f === "target")
+        out.push({ kind: k, id: ref.id, reason: `is a setting for calls to ${id}` });
+      else if (k === "FieldMapping" && f === "interface")
+        out.push({ kind: k, id: ref.id, reason: `maps fields of ${id}` });
+      else if (k === "IndexConstraint" && f === "references.table")
+        out.push({ kind: k, id: ref.id, reason: `is a foreign key into ${id}` });
+    }
+    if (r.kind === "System")
+      for (const c of ix.referencesTo(id).filter((x) => x.kind === "Component" && x.field === "system"))
+        out.push(...step(recordOf("Component", c.id) ?? {}).map((s) => ({ ...s })));
+    return out;
+  };
+  const ownerOf = (kind, id) => {
+    const s = ix.systemOf(kind, id);
+    const sys = s ? recordOf("System", s) : void 0;
+    return sys?.owner;
+  };
+  const seen = /* @__PURE__ */ new Set([`${root.kind}|${root.id}`]);
+  const affected = [];
+  let frontier = [
+    { r: root, path: [root.id] }
+  ];
+  for (let d = 0; d < depth && frontier.length > 0; d++) {
+    const next = [];
+    for (const { r, path } of frontier) {
+      for (const s of step(r)) {
+        const rec = s.kind ? recordOf(s.kind, s.id) : anyRecord(s.id);
+        const kind = rec?.kind ?? s.kind;
+        const key = `${kind}|${s.id}`;
+        if (seen.has(key) || !rec)
+          continue;
+        seen.add(key);
+        const p = [...path, s.id];
+        const owner = ownerOf(kind, s.id);
+        affected.push({ id: s.id, kind, path: p, reason: s.reason, ...owner ? { owner } : {} });
+        next.push({ r: rec, path: p });
+      }
+    }
+    frontier = next;
+  }
+  const gaps = [];
+  const gapKeys = /* @__PURE__ */ new Set();
+  const addGap = (g) => {
+    const k = `${g.record}|${g.field}`;
+    if (gapKeys.has(k))
+      return;
+    gapKeys.add(k);
+    gaps.push(g);
+  };
+  for (const a of affected) {
+    const rec = recordOf(a.kind, a.id);
+    if (a.kind === "Interface" && rec.confidence === "inferred")
+      addGap({
+        record: a.id,
+        field: "confidence",
+        question: `Only one end of this call was seen. Does ${String(rec.from)} really call ${String(rec.to)}?`
+      });
+    const s = ix.systemOf(a.kind, a.id);
+    if (s && (a.kind === "Component" || a.kind === "System")) {
+      const sys = recordOf("System", s);
+      if (sys && !sys.owner)
+        addGap({ record: s, field: "owner", question: `Who owns ${sys.name ?? s}?` });
+    }
+    if (a.kind === "Component")
+      for (const u of ix.db.prepare("SELECT json FROM records WHERE kind = 'Unresolved' AND json_extract(json, '$.owner') = ? ORDER BY id").all(a.id)) {
+        const x = JSON.parse(u.json);
+        addGap({
+          record: x.id,
+          field: "raw",
+          question: `${a.id} has a loose end Atticus couldn't follow (${x.raw}). Where does it go?`
+        });
+      }
+  }
+  return { root: root.id, affected, gaps };
+}
+
+// packages/index/dist/ask.js
+var OUTSIDE = "Outside";
+var PLAIN = /^[a-z0-9][a-z0-9._-]*$/;
+function askLookup(ix) {
+  return (word) => {
+    const w = word.toLowerCase();
+    const rec = ix.find(w)[0];
+    if (rec)
+      return { id: rec.id, kind: rec.kind };
+    if (!PLAIN.test(w) || STOP2.has(w) || KIND_WORDS[w])
+      return void 0;
+    const has = (q) => {
+      try {
+        return ix.query(q, { limit: 1 }).rows.length > 0;
+      } catch {
+        return false;
+      }
+    };
+    if (has(`kind:interface to:${w}`) || has(`kind:interface from:${w}`))
+      return { id: w, kind: OUTSIDE };
+    try {
+      const t = ix.query(`kind:table name:${w}`, { limit: 1 }).rows[0];
+      if (t)
+        return { id: t.id, kind: t.kind };
+    } catch {
+    }
+    return void 0;
+  };
+}
+var KIND_WORDS = {
+  interfaces: "interface",
+  interface: "interface",
+  calls: "interface",
+  tables: "table",
+  table: "table",
+  endpoints: "endpoint",
+  apis: "endpoint",
+  components: "component",
+  services: "component",
+  systems: "system",
+  settings: "setting",
+  columns: "column",
+  topics: "topic",
+  features: "capability",
+  migrations: "migration",
+  deployments: "deployment"
+};
+var STOP2 = new Set("a an the of in on to for by is are was what which who whom how does do did if when me show list find all any with that this there it its and or please".split(" "));
+function named(words, lookup) {
+  for (const w of [...words].sort((a, b) => b.length - a.length)) {
+    const hit = lookup(w);
+    if (hit)
+      return hit;
+  }
+  return void 0;
+}
+function translate(question, lookup) {
+  const q = question.trim();
+  const lower = q.toLowerCase();
+  const words = lower.replace(/[?!,;"'`()]/g, " ").split(/\s+/).map((w) => w.replace(/\.$/, "")).filter(Boolean);
+  const rec = named(words, lookup);
+  const has = (re) => re.test(lower);
+  if (rec?.kind === OUTSIDE)
+    return {
+      action: "query",
+      query: `kind:interface to:${rec.id}`,
+      explanation: `Read as: the calls to ${rec.id}, a system outside the estate that the code calls.`
+    };
+  if (has(/\b(break|breaks|affected|impacted|impact|reach|reaches|depends? on)\b/)) {
+    if (rec)
+      return {
+        action: "impact",
+        id: rec.id,
+        query: `impact ${rec.id}`,
+        explanation: `Read as: what a change to ${rec.id} reaches, hop by hop, with owners.`
+      };
+  }
+  if (rec && has(/\bwhat does\b.*\b(call|use|depend|talk)/))
+    return {
+      action: "query",
+      query: `kind:interface from:${rec.id}`,
+      explanation: `Read as: the interfaces ${rec.id} calls.`
+    };
+  if (rec && has(/\b(who|what|which)\b.*\b(calls?|uses?|consumes?|reads?|writes?)\b/)) {
+    if (rec.kind === "Table" || rec.kind === "Column")
+      return {
+        action: "query",
+        query: `refby:${rec.id} kind:component`,
+        explanation: `Read as: the components that read or write ${rec.id}.`
+      };
+    return {
+      action: "query",
+      query: `kind:interface to:${rec.id}`,
+      explanation: `Read as: the interfaces whose callee is ${rec.id}.`
+    };
+  }
+  if (rec && has(/\bwho owns\b|\bowner of\b/))
+    return {
+      action: "owner",
+      id: rec.id,
+      query: rec.id,
+      explanation: `Read as: the owner recorded for ${rec.id}.`
+    };
+  const terms = [];
+  const system = rec?.kind === "System" ? rec.id : void 0;
+  if (has(/\b(personal|sensitive|pii|confidential)\b/)) {
+    terms.push("kind:column");
+    if (system)
+      terms.push(`system:${system}`);
+    terms.push("classification:personal*");
+    return {
+      action: "query",
+      query: terms.join(" "),
+      explanation: `Read as: columns tagged as personal data${system ? ` in ${system}` : ""}. Untagged columns don't show.`
+    };
+  }
+  const kindWord = words.find((w) => KIND_WORDS[w]);
+  if (kindWord) {
+    terms.push(`kind:${KIND_WORDS[kindWord]}`);
+    if (has(/\bgateway\b/))
+      terms.push("via:gateway");
+    else if (has(/\b(event bus|event-bus|events?)\b/))
+      terms.push("via:event-bus");
+    if (system)
+      terms.push(`system:${system}`);
+    else if (rec)
+      terms.push(`refs:${rec.id}`);
+    if (has(/\b(without|no|missing) (a |an )?pattern\b/))
+      terms.push("missing:pattern");
+    if (has(/\b(inferred|unconfirmed|one end)\b/))
+      terms.push("confidence:inferred");
+    return {
+      action: "query",
+      query: terms.join(" "),
+      explanation: `Read as: ${KIND_WORDS[kindWord]} records${terms.length > 1 ? " where " + terms.slice(1).join(", ") : ""}.`
+    };
+  }
+  const text = words.filter((w) => !STOP2.has(w));
+  const query = rec ? rec.id : text.join(" ");
+  return {
+    action: "query",
+    query: query || q,
+    explanation: rec ? `Read as: a search for ${rec.id}.` : `No record in the catalog is named in the question, so this is a word search for "${text.join(" ")}".`
+  };
+}
+
+// packages/index/dist/tools.js
+import { existsSync, readdirSync } from "node:fs";
+import { readdir as readdir2, readFile as readFile3, realpath, stat as stat2 } from "node:fs/promises";
+import { isAbsolute, join as join4, relative as relative2, resolve, sep as sep2 } from "node:path";
+var ContextToolError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ToolError";
+  }
+};
+var CONTEXT_TOOL_NAMES = [
+  "search",
+  "show",
+  "walk",
+  "show_code",
+  "grep",
+  "files",
+  "outline",
+  "similar"
+];
+var CODE_TOOL_NAMES = ["grep", "files", "outline"];
+var CONTEXT_TOOL_BOUNDS = {
+  searchLimit: 20,
+  walkHops: 2,
+  walkLimit: 40,
+  codeContext: 20,
+  codeCites: 3,
+  codeFileBytes: 2e6,
+  /** grep (ADR 0118): hits a call shows at most, and by default. */
+  grepLimit: 100,
+  grepDefault: 30,
+  /** The longest pattern grep takes, and the most of a hit's line it shows. */
+  grepPattern: 200,
+  grepLineChars: 200,
+  /** Files one grep or files call walks at most, and bytes grep reads at most. */
+  walkFiles: 2e4,
+  grepBytes: 64e6,
+  filesLimit: 500,
+  filesDefault: 200,
+  outlineLines: 300
+};
+var CONTEXT_TOOLS = [
+  {
+    name: "search",
+    description: "Search everything Atticus knows by words and meaning: catalog records, knowledge items, flows and their steps, changes, answered questions, wiki sections and documents. Names and ids rank first; with a local embedding model, what is similar in meaning ranks too. Each hit gives its kind, id, name and the file it was read from.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "The words to look for." },
+        by: {
+          type: "string",
+          enum: ["words", "meaning", "both"],
+          description: "words: the words and the names they are made of; meaning: similar in meaning (needs the local model); both (the default)."
+        },
+        kinds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Only these kinds, for example System, Flow, ProcessDefinition, WikiSection."
+        },
+        limit: { type: "integer", minimum: 1, maximum: CONTEXT_TOOL_BOUNDS.searchLimit }
+      },
+      required: ["text"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "show",
+    description: "Show one record, flow, flow step (flow-id#n), knowledge item, change, answered question or wiki section in full, by its id, with the file it was read from and whether it was verified.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "The id, as the pack or a search names it." }
+      },
+      required: ["id"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "walk",
+    description: "Walk the links from one id: what it calls, contains, names or is named by, one line each with how the link was made, at most two hops.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        hops: { type: "integer", minimum: 1, maximum: CONTEXT_TOOL_BOUNDS.walkHops },
+        kinds: { type: "array", items: { type: "string" }, description: "Only these kinds." },
+        limit: { type: "integer", minimum: 1, maximum: CONTEXT_TOOL_BOUNDS.walkLimit }
+      },
+      required: ["id"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "show_code",
+    description: "Show the code a fact cites: a few lines around each file and line a record or flow step cites, read from the workspace checkout. Give the fact's id; or a repo, path and line that a fact cites or that a grep or outline hit of this run returned.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "A record or flow step (flow-id#n) id." },
+        repo: { type: "string" },
+        path: { type: "string" },
+        line: { type: "integer", minimum: 1 },
+        context: {
+          type: "integer",
+          minimum: 0,
+          maximum: CONTEXT_TOOL_BOUNDS.codeContext,
+          description: "Lines before and after the cited line (default 6)."
+        }
+      },
+      additionalProperties: false
+    }
+  },
+  {
+    name: "grep",
+    description: "Search the repos' code for the lines that match what you give: literal text, or a regular expression with regex true. Each hit is repo:path:line: the line. Use it to find code the material doesn't show, for example an in-house annotation, a wrapper or where a value is set. A hit is a pointer, not a fact: show_code shows the lines around it. Files .gitignore ignores are skipped.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          maxLength: CONTEXT_TOOL_BOUNDS.grepPattern,
+          description: "The text to find, or a regular expression (JavaScript syntax)."
+        },
+        regex: { type: "boolean", description: "The pattern is a regular expression." },
+        ignoreCase: { type: "boolean" },
+        repo: { type: "string", description: "Only this repo. Default: every cloned repo." },
+        paths: {
+          type: "string",
+          description: "Only paths that match this glob, for example src/**/*.java; a glob with no / matches at any depth."
+        },
+        limit: { type: "integer", minimum: 1, maximum: CONTEXT_TOOL_BOUNDS.grepLimit }
+      },
+      required: ["pattern"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "files",
+    description: "List the repos' files whose paths match a glob (src/**/*.java; a glob with no / matches at any depth), each as repo:path. Files .gitignore ignores are left out.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        glob: { type: "string" },
+        repo: { type: "string", description: "Only this repo. Default: every cloned repo." },
+        limit: { type: "integer", minimum: 1, maximum: CONTEXT_TOOL_BOUNDS.filesLimit }
+      },
+      required: ["glob"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "outline",
+    description: "Outline one file: its declarations (classes, functions, methods and the like, nested, each with the annotations or decorators written on it) from its syntax tree, each as line: what is declared there; for Markdown its headings, for YAML or properties its keys.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string" },
+        path: { type: "string", description: "The file's path in the repo." }
+      },
+      required: ["repo", "path"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "similar",
+    description: "What is nearest one id in meaning, by the local embedding model: records, items, sections and documents that read alike. A hint where to look, never a link or a fact: show one to read it.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        kinds: { type: "array", items: { type: "string" }, description: "Only these kinds." },
+        limit: { type: "integer", minimum: 1, maximum: CONTEXT_TOOL_BOUNDS.searchLimit }
+      },
+      required: ["id"],
+      additionalProperties: false
+    }
+  }
+];
+var str2 = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
+var int = (v, min, max, fallback) => typeof v === "number" && Number.isFinite(v) ? Math.min(max, Math.max(min, Math.floor(v))) : fallback;
+var strs = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string" && !!x.trim()) : void 0;
+function defaultCodeDir(root, repo) {
+  if (!RecordId.safeParse(repo).success)
+    return void 0;
+  for (const base of [join4(root, "workspace"), join4(stateDirOf(root), "workspace")]) {
+    const d = join4(base, repo);
+    if (existsSync(d))
+      return d;
+  }
+  return void 0;
+}
+async function runContextTool(ix, root, name, input, o = {}) {
+  switch (name) {
+    case "search":
+      return searchTool(ix, input);
+    case "show":
+      return showTool(ix, input);
+    case "walk":
+      return walkTool(ix, input);
+    case "show_code":
+      return showCodeTool(ix, root, input, o);
+    case "similar":
+      return similarTool(ix, input);
+    case "grep":
+    case "files":
+    case "outline":
+      return runCodeTool(root, name, input, o);
+    default:
+      throw new ContextToolError(`There is no tool ${name}. The tools: ${CONTEXT_TOOL_NAMES.join(", ")}.`);
+  }
+}
+function hitLine(ix, key, extra = "") {
+  const r = ix.db.prepare("SELECT kind, id, name, file FROM nodes WHERE key = ?").get(key);
+  return r ? `- ${r.kind} ${r.id}: ${r.name}${extra} [${r.file}]` : void 0;
+}
+async function searchTool(ix, input) {
+  const text = str2(input.text);
+  if (!text)
+    throw new ContextToolError("search needs text: the words to look for.");
+  const kinds = strs(input.kinds);
+  const limit = int(input.limit, 1, CONTEXT_TOOL_BOUNDS.searchLimit, 10);
+  const by = input.by === "words" || input.by === "meaning" ? input.by : "both";
+  if (input.by !== void 0 && !["words", "meaning", "both"].includes(String(input.by)))
+    throw new ContextToolError("search's by is words, meaning or both.");
+  const k = { limit, ...kinds?.length ? { kinds } : {} };
+  const words = by === "meaning" ? [] : ix.search(text, k);
+  let near = [];
+  let off;
+  if (by !== "words") {
+    await ix.prepare(text);
+    const s = ix.similar(text, k);
+    if ("off" in s)
+      off = s.off;
+    else
+      near = s.hits;
+  }
+  if (by === "meaning" && off)
+    return `Similar in meaning is off: ${off}. Search by words instead.`;
+  const cos = new Map(near.map((h) => [h.key, h.cos]));
+  const keys = near.length ? [
+    ...fuse([
+      { name: "words", keys: words.map((h) => h.key) },
+      { name: "meaning", keys: near.map((h) => h.key) }
+    ])
+  ].sort((a, b) => b[1].score - a[1].score || (a[0] < b[0] ? -1 : 1)).map(([key]) => key).slice(0, limit) : words.map((h) => h.key);
+  const lines = keys.map((key) => hitLine(ix, key, cos.has(key) ? ` (similar in meaning, cos ${cos.get(key).toFixed(2)})` : "")).filter((l) => !!l);
+  const note = off && by === "both" ? [`(Similar in meaning is off: ${off}.)`] : [];
+  if (!lines.length)
+    return [`Nothing in the index matches "${text}".`, ...note].join("\n");
+  return [
+    `${lines.length} hit${lines.length === 1 ? "" : "s"} for "${text}", best first:`,
+    ...lines,
+    ...note,
+    "Show one in full with show and its id."
+  ].join("\n");
+}
+function similarTool(ix, input) {
+  const id = str2(input.id);
+  if (!id)
+    throw new ContextToolError("similar needs an id.");
+  const kinds = strs(input.kinds);
+  const limit = int(input.limit, 1, CONTEXT_TOOL_BOUNDS.searchLimit, 10);
+  const node = nodesOf(ix, id)[0];
+  const s = ix.similar({ key: node.key }, { limit, ...kinds?.length ? { kinds } : {} });
+  if ("off" in s)
+    return `Similar in meaning is off: ${s.off}.`;
+  if (!s.hits.length)
+    return `Nothing reads like ${id}.`;
+  return [
+    `Nearest ${id} in meaning (a hint where to look, not a link or a fact):`,
+    ...s.hits.map((h) => hitLine(ix, h.key, ` (cos ${h.cos.toFixed(2)})`)).filter((l) => !!l),
+    "Show one in full with show and its id."
+  ].join("\n");
+}
+function nodesOf(ix, id) {
+  const nodes = ix.nodes(id);
+  if (!nodes.length)
+    throw new ContextToolError(`There is nothing called ${id} in the index. Search for it by words with search.`);
+  return nodes;
+}
+function showTool(ix, input) {
+  const id = str2(input.id);
+  if (!id)
+    throw new ContextToolError("show needs an id.");
+  const nodes = nodesOf(ix, id).slice(0, 3);
+  return nodes.map((n) => {
+    const state = n.review ? `a person ${n.review} it` : n.verified ? "verified" : "not verified by a person or a check";
+    const links = ix.links(n.key).length;
+    return [
+      `${n.kind} ${n.id} (${state}), read from ${n.file}:`,
+      n.detail.trimEnd(),
+      ...links ? [`It has ${links} link${links === 1 ? "" : "s"}; walk shows them.`] : []
+    ].join("\n");
+  }).join("\n\n");
+}
+function walkTool(ix, input) {
+  const id = str2(input.id);
+  if (!id)
+    throw new ContextToolError("walk needs an id.");
+  const hops = int(input.hops, 1, CONTEXT_TOOL_BOUNDS.walkHops, 1);
+  const limit = int(input.limit, 1, CONTEXT_TOOL_BOUNDS.walkLimit, 25);
+  const kinds = strs(input.kinds);
+  const starts = nodesOf(ix, id);
+  const seen = new Set(starts.map((n) => n.key));
+  const lines = [];
+  let more = 0;
+  let frontier = starts.map((n) => ({ key: n.key, id: n.id }));
+  for (let h = 1; h <= hops && frontier.length; h++) {
+    const next = [];
+    for (const f of frontier)
+      for (const l of ix.links(f.key)) {
+        if (seen.has(l.key))
+          continue;
+        seen.add(l.key);
+        next.push({ key: l.key, id: l.id });
+        if (kinds?.length && !kinds.includes(l.kind))
+          continue;
+        if (lines.length >= limit) {
+          more++;
+          continue;
+        }
+        const what = l.dir === "out" ? `${f.id} ${l.type} ${l.id}` : `${l.id} ${l.type} ${f.id}`;
+        lines.push(`- hop ${h}: ${what} (${l.how}); ${l.kind} ${l.id}`);
+      }
+    frontier = next.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+  }
+  if (!lines.length)
+    return `${id} has no links${kinds?.length ? ` to ${kinds.join(", ")}` : ""}.`;
+  return [
+    `Links from ${id}, ${hops} hop${hops === 1 ? "" : "s"}:`,
+    ...lines,
+    ...more ? [`\u2026 and ${more} more; ask for fewer kinds or one hop.`] : []
+  ].join("\n");
+}
+function citesOf(ix, root, id) {
+  const out = [];
+  const rows = ix.db.prepare("SELECT kind, repo, path, line FROM evidence WHERE id = ? AND repo IS NOT NULL AND path IS NOT NULL AND line IS NOT NULL ORDER BY rowid").all(id);
+  for (const r of rows)
+    out.push({ repo: r.repo, path: r.path, line: r.line, what: `${r.kind} ${id}` });
+  if (out.length)
+    return out;
+  const m = /^(.+)#(\d+)$/.exec(id);
+  const flowId = m ? m[1] : id;
+  for (const n of ix.nodes(flowId).filter((x) => x.kind === "Flow")) {
+    const f = n.json;
+    const specRel = specsRelOf(root);
+    const specRepo = n.file.startsWith(`${specRel}/`) ? n.file.slice(specRel.length + 1).split("/")[0] : void 0;
+    const parts = m ? [{ what: `step ${id}`, evidence: f.steps?.[Number(m[2]) - 1]?.evidence ?? [] }] : [
+      { what: `trigger of ${flowId}`, evidence: f.trigger?.evidence ?? [] },
+      ...(f.steps ?? []).map((s, i) => ({
+        what: `step ${flowId}#${i + 1}`,
+        evidence: s.evidence ?? []
+      }))
+    ];
+    for (const p of parts)
+      for (const e of p.evidence) {
+        const repo = e.repo ?? specRepo;
+        if (repo && e.path && e.line)
+          out.push({ repo, path: e.path, line: e.line, what: p.what });
+      }
+  }
+  return out;
+}
+function isCited(ix, root, c) {
+  const hit = ix.db.prepare("SELECT 1 FROM evidence WHERE repo = ? AND path = ? AND line = ? LIMIT 1").get(c.repo, c.path, c.line);
+  if (hit)
+    return true;
+  const flows = ix.db.prepare("SELECT id FROM nodes WHERE kind = 'Flow'").all();
+  return flows.some((f) => citesOf(ix, root, f.id).some((x) => x.repo === c.repo && x.path === c.path && x.line === c.line));
+}
+async function insideClone(base, path) {
+  if (!path || path.includes("\0") || isAbsolute(path) || /^[a-zA-Z]:/.test(path))
+    throw new ContextToolError(`${path} isn't a path inside the repo.`);
+  const full = resolve(base, ...path.split(/[\\/]+/));
+  const rel2 = relative2(base, full);
+  if (!rel2 || rel2.startsWith("..") || isAbsolute(rel2))
+    throw new ContextToolError(`${path} leaves the repo's checkout; Atticus reads nothing outside it.`);
+  let real;
+  let realBase;
+  try {
+    [real, realBase] = await Promise.all([realpath(full), realpath(base)]);
+  } catch {
+    throw new ContextToolError(`${path} isn't in the workspace checkout (is the repo cloned?).`);
+  }
+  const r = relative2(realBase, real);
+  if (!r || r.startsWith("..") || isAbsolute(r) || r.split(sep2).includes(".."))
+    throw new ContextToolError(`${path} leads outside the repo's checkout; Atticus reads nothing outside it.`);
+  return real;
+}
+async function excerpt(root, c, around, o) {
+  const base = (o.codeDir ?? ((r) => defaultCodeDir(root, r)))(c.repo);
+  if (!base)
+    return `${c.what} ${c.verb ?? "cites"} ${c.repo}/${c.path}:${c.line}, but ${c.repo} isn't cloned in the workspace.`;
+  let file;
+  try {
+    file = await insideClone(base, c.path);
+  } catch (e) {
+    return `${c.what} ${c.verb ?? "cites"} ${c.repo}/${c.path}:${c.line}: ${e.message}`;
+  }
+  const size = (await stat2(file)).size;
+  if (size > CONTEXT_TOOL_BOUNDS.codeFileBytes)
+    return `${c.what} ${c.verb ?? "cites"} ${c.repo}/${c.path}:${c.line}, a file too big to show (${size} bytes).`;
+  const lines = (await readFile3(file, "utf8")).split(/\r?\n/);
+  if (c.line > lines.length)
+    return `${c.what} ${c.verb ?? "cites"} ${c.repo}/${c.path}:${c.line}, but the file has ${lines.length} lines now: the cite is stale.`;
+  const from = Math.max(1, c.line - around);
+  const to = Math.min(lines.length, c.line + around);
+  const width = String(to).length;
+  return [
+    `${c.what} ${c.verb ?? "cites"} ${c.repo}/${c.path}:${c.line}:`,
+    ...lines.slice(from - 1, to).map((l, i) => `${from + i === c.line ? ">" : " "}${String(from + i).padStart(width)}  ${l}`)
+  ].join("\n");
+}
+async function showCodeTool(ix, root, input, o) {
+  const around = int(input.context, 0, CONTEXT_TOOL_BOUNDS.codeContext, 6);
+  const id = str2(input.id);
+  let cites2;
+  if (id) {
+    if (!ix)
+      throw new ContextToolError("show_code by id needs the index.");
+    nodesOf(ix, id.replace(/#\d+$/, ""));
+    cites2 = citesOf(ix, root, id);
+    if (!cites2.length)
+      return `${id} cites no line of code (it may cite a wiki page or a document: show it).`;
+  } else {
+    const repo = str2(input.repo);
+    const path = str2(input.path);
+    const line = typeof input.line === "number" ? Math.floor(input.line) : void 0;
+    if (!repo || !path || !line || line < 1)
+      throw new ContextToolError("show_code needs an id, or a repo, path and line.");
+    if (!RecordId.safeParse(repo).success)
+      throw new ContextToolError(`${repo} isn't a repo id.`);
+    if (o.pointers?.has(pointerKey(repo, path, line)))
+      cites2 = [{ repo, path: posixPath(path), line, what: "A search hit", verb: "at" }];
+    else {
+      if (!ix || !isCited(ix, root, { repo, path, line }))
+        throw new ContextToolError(`No fact cites ${repo}/${path}:${line}, and no grep or outline hit of this run returned it; show_code shows only those. Give a record's id, or find the line with grep first.`);
+      cites2 = [{ repo, path, line, what: "A fact" }];
+    }
+  }
+  const shown = cites2.slice(0, CONTEXT_TOOL_BOUNDS.codeCites);
+  const parts = [];
+  for (const c of shown)
+    parts.push(await excerpt(root, c, around, o));
+  if (cites2.length > shown.length)
+    parts.push(`\u2026 and ${cites2.length - shown.length} more cites; ask for one by repo, path and line.`);
+  return parts.join("\n\n");
+}
+function contextToolBox(root, open, o = {}) {
+  const { calls, ...rest } = o;
+  const pointers = o.pointers ?? /* @__PURE__ */ new Set();
+  for (const c of calls ?? [])
+    for (const k of pointersIn(c.name, c.output))
+      pointers.add(k);
+  const opts = { ...rest, pointers };
+  return {
+    definitions: CONTEXT_TOOLS,
+    async call(name, input) {
+      if (CODE_TOOL_NAMES.includes(name))
+        return runCodeTool(root, name, input, opts);
+      const line = typeof input.line === "number" ? Math.floor(input.line) : void 0;
+      if (name === "show_code" && !str2(input.id) && str2(input.repo) && str2(input.path) && line && pointers.has(pointerKey(str2(input.repo), str2(input.path), line)))
+        return showCodeTool(void 0, root, input, opts);
+      const ix = await open();
+      try {
+        return await runContextTool(ix, root, name, input, opts);
+      } finally {
+        ix.close();
+      }
+    }
+  };
+}
+var posixPath = (p) => p.replace(/\\/g, "/").replace(/^(\.\/)+/, "");
+var pointerKey = (repo, path, line) => `${repo}\0${posixPath(path)}\0${line}`;
+var HIT = /^([a-z0-9][a-z0-9._-]*):(.+?):(\d+): /;
+var OUTLINE_HEAD = /^Outline of ([a-z0-9][a-z0-9._-]*):(.+)$/;
+var OUTLINE_LINE = /^\s*(\d+): /;
+function pointersIn(name, output) {
+  const out = [];
+  if (name === "grep")
+    for (const l of output.split(/\r?\n/)) {
+      const m = HIT.exec(l);
+      if (m)
+        out.push(pointerKey(m[1], m[2], Number(m[3])));
+    }
+  if (name === "outline") {
+    let at;
+    for (const l of output.split(/\r?\n/)) {
+      const h = OUTLINE_HEAD.exec(l);
+      if (h) {
+        at = { repo: h[1], path: h[2] };
+        continue;
+      }
+      const m = at && OUTLINE_LINE.exec(l);
+      if (at && m)
+        out.push(pointerKey(at.repo, at.path, Number(m[1])));
+    }
+  }
+  return out;
+}
+async function namesInCode(root, names, o = {}) {
+  const B = CONTEXT_TOOL_BOUNDS;
+  const found = /* @__PURE__ */ new Map();
+  const want = [...new Set(names.filter((n) => n.trim().length >= 2))];
+  const ids = o.repos ? o.repos() : workspaceRepos(root);
+  const repos = [];
+  for (const r of ids) {
+    const dir = (o.codeDir ?? ((x) => defaultCodeDir(root, x)))(r);
+    if (dir && RecordId.safeParse(r).success)
+      repos.push({ repo: r, dir });
+  }
+  const how = /* @__PURE__ */ new Map();
+  let walked = 0;
+  let bytes = 0;
+  let cut = false;
+  for (const { repo, dir } of repos) {
+    if (found.size === want.length)
+      break;
+    const w = await walkClone(dir, B.walkFiles - walked, async (p) => {
+      walked++;
+      const open = want.filter((n) => !found.has(n));
+      for (const n of open)
+        if (p === n || p.endsWith(`/${n.replace(/^\/+/, "")}`)) {
+          found.set(n, `${repo}:${p}`);
+          how.set(n, "file");
+        }
+      if (!o.outline || o.outlines && !o.outlines(p))
+        return;
+      const names2 = open.filter((n) => !found.has(n) && DECLARABLE.test(n));
+      if (!names2.length)
+        return;
+      const buf = await readFile3(join4(dir, ...p.split("/"))).catch(() => void 0);
+      if (!buf || buf.length > B.codeFileBytes)
+        return;
+      if (buf.subarray(0, 8e3).includes(0))
+        return;
+      bytes += buf.length;
+      if (bytes > B.grepBytes) {
+        cut = true;
+        return false;
+      }
+      const text = buf.toString("utf8");
+      if (!names2.some((n) => text.includes(n)))
+        return;
+      const decls = await o.outline(p, text).catch(() => void 0);
+      for (const d of decls ?? []) {
+        if (!isTypeDeclaration(d.kind))
+          continue;
+        const n = names2.find((x) => x === d.name);
+        if (n && !found.has(n)) {
+          found.set(n, `${repo}:${p}:${d.line}`);
+          how.set(n, "declaration");
+        }
+      }
+      if (found.size === want.length)
+        return false;
+    });
+    if (w.cut)
+      cut = true;
+    if (cut)
+      break;
+  }
+  return { found, how, repos: repos.map((r) => r.repo), cut };
+}
+var DECLARABLE = /^[A-Za-z_$][\w$]*$/;
+var isTypeDeclaration = (kind) => !/method|constructor|field|property|variable|parameter|accessor|getter|setter/.test(kind);
+function workspaceRepos(root) {
+  const out = /* @__PURE__ */ new Set();
+  for (const base of [join4(root, "workspace"), join4(stateDirOf(root), "workspace")]) {
+    let names;
+    try {
+      names = readdirSync(base, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    } catch {
+      continue;
+    }
+    for (const n of names)
+      if (RecordId.safeParse(n).success)
+        out.add(n);
+  }
+  return [...out].sort();
+}
+function cloneOf(root, repo, o) {
+  if (!RecordId.safeParse(repo).success)
+    throw new ContextToolError(`${repo} isn't a repo id.`);
+  const dir = (o.codeDir ?? ((r) => defaultCodeDir(root, r)))(repo);
+  if (!dir)
+    throw new ContextToolError(`${repo} isn't cloned in the workspace.`);
+  return dir;
+}
+function reposOf(root, input, o) {
+  const named2 = str2(input.repo);
+  if (named2)
+    return [{ repo: named2, dir: cloneOf(root, named2, o) }];
+  const ids = o.repos ? o.repos() : workspaceRepos(root);
+  const out = [];
+  for (const r of ids) {
+    const dir = (o.codeDir ?? ((x) => defaultCodeDir(root, x)))(r);
+    if (dir && RecordId.safeParse(r).success)
+      out.push({ repo: r, dir });
+  }
+  if (!out.length)
+    throw new ContextToolError("No repo is cloned in the workspace.");
+  return out;
+}
+function globRe(glob2, anyDepth = !glob2.replace(/\/$/, "").includes("/")) {
+  let g = glob2.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+  if (g.startsWith("/")) {
+    g = g.slice(1);
+    anyDepth = false;
+  }
+  let re = "";
+  for (let i = 0; i < g.length; i++) {
+    const ch = g[i];
+    if (ch === "*") {
+      if (g[i + 1] === "*") {
+        const slash = g[i + 2] === "/";
+        re += slash ? "(?:.*/)?" : ".*";
+        i += slash ? 2 : 1;
+      } else
+        re += "[^/]*";
+    } else if (ch === "?")
+      re += "[^/]";
+    else if (ch === "[") {
+      const end = g.indexOf("]", i + 2);
+      if (end < 0)
+        re += "\\[";
+      else {
+        const body = g.slice(i + 1, end).replace(/^!/, "^").replace(/\\/g, "\\\\");
+        re += `[${body}]`;
+        i = end;
+      }
+    } else if (ch === "{") {
+      const end = g.indexOf("}", i);
+      if (end < 0)
+        re += "\\{";
+      else {
+        re += `(?:${g.slice(i + 1, end).split(",").map((p) => globRe(p, false).source.slice(1, -1)).join("|")})`;
+        i = end;
+      }
+    } else
+      re += ch.replace(/[.+^$()|\\]/g, "\\$&");
+  }
+  return new RegExp(`^${anyDepth ? "(?:.*/)?" : ""}${re}$`);
+}
+function ignoreRules(text, base) {
+  const out = [];
+  for (let line of text.split(/\r?\n/)) {
+    line = line.replace(/(?<!\\)\s+$/, "");
+    if (!line || line.startsWith("#"))
+      continue;
+    let negate = false;
+    if (line.startsWith("!")) {
+      negate = true;
+      line = line.slice(1);
+    } else if (line.startsWith("\\!") || line.startsWith("\\#"))
+      line = line.slice(1);
+    const dirOnly = line.endsWith("/");
+    if (dirOnly)
+      line = line.slice(0, -1);
+    if (!line)
+      continue;
+    const anchored = line.includes("/");
+    try {
+      out.push({ base, re: globRe(line.replace(/^\//, ""), !anchored), negate, dirOnly });
+    } catch {
+    }
+  }
+  return out;
+}
+function ignored(rules, path, isDir) {
+  let out = false;
+  for (const r of rules) {
+    if (r.dirOnly && !isDir)
+      continue;
+    if (r.base && !path.startsWith(`${r.base}/`))
+      continue;
+    const rel2 = r.base ? path.slice(r.base.length + 1) : path;
+    if (r.re.test(rel2))
+      out = !r.negate;
+  }
+  return out;
+}
+async function rulesFor(dir, path) {
+  const parts = path.split("/").slice(0, -1);
+  const rules = [];
+  for (let i = 0; i <= parts.length; i++) {
+    const base = parts.slice(0, i).join("/");
+    const text = await readFile3(join4(dir, ...parts.slice(0, i), ".gitignore"), "utf8").catch(() => void 0);
+    if (text)
+      rules.push(...ignoreRules(text, base));
+  }
+  return rules;
+}
+async function isIgnored(dir, path) {
+  const rules = await rulesFor(dir, path);
+  const parts = path.split("/");
+  for (let i = 1; i < parts.length; i++)
+    if (ignored(rules, parts.slice(0, i).join("/"), true))
+      return true;
+  return ignored(rules, path, false);
+}
+async function walkClone(dir, max, visit) {
+  let files = 0;
+  let cut = false;
+  const go = async (rel2, inherited) => {
+    let entries;
+    try {
+      entries = await readdir2(rel2 ? join4(dir, ...rel2.split("/")) : dir, { withFileTypes: true });
+    } catch {
+      return true;
+    }
+    const here = entries.find((e) => e.name === ".gitignore" && e.isFile());
+    const rules = here ? [
+      ...inherited,
+      ...ignoreRules(await readFile3(join4(dir, ...rel2.split("/"), ".gitignore"), "utf8"), rel2)
+    ] : inherited;
+    for (const e of entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+      if (e.isSymbolicLink() || e.name === ".git")
+        continue;
+      const p = rel2 ? `${rel2}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        if (ignored(rules, p, true))
+          continue;
+        if (!await go(p, rules))
+          return false;
+      } else if (e.isFile()) {
+        if (ignored(rules, p, false))
+          continue;
+        if (files >= max) {
+          cut = true;
+          return false;
+        }
+        files++;
+        if (await visit(p) === false)
+          return false;
+      }
+    }
+    return true;
+  };
+  await go("", []);
+  return { files, cut };
+}
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+async function runCodeTool(root, name, input, o) {
+  if (name === "grep")
+    return grepTool(root, input, o);
+  if (name === "files")
+    return filesTool(root, input, o);
+  return outlineTool(root, input, o);
+}
+async function grepTool(root, input, o) {
+  const B = CONTEXT_TOOL_BOUNDS;
+  const pattern = typeof input.pattern === "string" && input.pattern ? input.pattern : void 0;
+  if (!pattern)
+    throw new ContextToolError("grep needs a pattern: the text or expression to find.");
+  if (pattern.length > B.grepPattern)
+    throw new ContextToolError(`A grep pattern is at most ${B.grepPattern} characters.`);
+  const ignoreCase = input.ignoreCase === true;
+  let test;
+  if (input.regex === true) {
+    let re;
+    try {
+      re = new RegExp(pattern, ignoreCase ? "i" : "");
+    } catch (e) {
+      throw new ContextToolError(`${pattern} isn't a regular expression: ${e.message}.`);
+    }
+    test = (l) => re.test(l);
+  } else {
+    const p = ignoreCase ? pattern.toLowerCase() : pattern;
+    test = ignoreCase ? (l) => l.toLowerCase().includes(p) : (l) => l.includes(p);
+  }
+  const limit = int(input.limit, 1, B.grepLimit, B.grepDefault);
+  const paths = str2(input.paths);
+  const only = paths ? globRe(paths) : void 0;
+  const repos = reposOf(root, input, o);
+  const hits = [];
+  let more = false;
+  let read = 0;
+  let bytes = 0;
+  let cut = false;
+  for (const { repo, dir } of repos) {
+    const walked = await walkClone(dir, B.walkFiles - read, async (p) => {
+      if (only && !only.test(p))
+        return;
+      const buf = await readFile3(join4(dir, ...p.split("/"))).catch(() => void 0);
+      if (!buf || buf.length > B.codeFileBytes)
+        return;
+      if (buf.subarray(0, 8e3).includes(0))
+        return;
+      bytes += buf.length;
+      if (bytes > B.grepBytes) {
+        cut = true;
+        return false;
+      }
+      read++;
+      const lines = buf.toString("utf8").split(/\r?\n/);
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].slice(0, 2e3);
+        if (!test(line))
+          continue;
+        if (hits.length >= limit) {
+          more = true;
+          return false;
+        }
+        const text = line.trimEnd();
+        const shown = text.length > B.grepLineChars ? `${text.slice(0, B.grepLineChars)} \u2026` : text;
+        hits.push(`${repo}:${p}:${i + 1}: ${shown}`);
+        o.pointers?.add(pointerKey(repo, p, i + 1));
+      }
+    });
+    if (walked.cut)
+      cut = true;
+    if (more || cut)
+      break;
+  }
+  const where = repos.length === 1 ? ` in ${repos[0].repo}` : "";
+  const scope = paths ? `, paths ${paths}` : "";
+  if (!hits.length)
+    return `No line matches "${pattern}"${where}${scope} (${plural(read, "file")} read${cut ? "; the search stopped at its cap" : ""}).`;
+  return [
+    `${plural(hits.length, "hit")} for "${pattern}"${where}${scope} (${plural(read, "file")} read):`,
+    ...hits,
+    ...more ? [`\u2026 more hits past the ${limit} shown; narrow the pattern or the paths.`] : [],
+    ...cut ? [`\u2026 the search stopped at its cap of files or bytes; name a repo or narrower paths.`] : [],
+    "Show the lines around a hit with show_code (repo, path, line). A hit is a pointer, not a fact: a fact cites its file and line, and Atticus checks the value there."
+  ].join("\n");
+}
+async function filesTool(root, input, o) {
+  const B = CONTEXT_TOOL_BOUNDS;
+  const glob2 = str2(input.glob);
+  if (!glob2)
+    throw new ContextToolError("files needs a glob, for example src/**/*.java.");
+  const limit = int(input.limit, 1, B.filesLimit, B.filesDefault);
+  const re = globRe(glob2);
+  const repos = reposOf(root, input, o);
+  const out = [];
+  let more = false;
+  let seen = 0;
+  for (const { repo, dir } of repos) {
+    const walked = await walkClone(dir, B.walkFiles - seen, async (p) => {
+      seen++;
+      if (!re.test(p))
+        return;
+      if (out.length >= limit) {
+        more = true;
+        return false;
+      }
+      out.push(`${repo}:${p}`);
+    });
+    if (more || walked.cut) {
+      more = true;
+      break;
+    }
+  }
+  const where = repos.length === 1 ? ` in ${repos[0].repo}` : "";
+  if (!out.length)
+    return `No file matches ${glob2}${where}.`;
+  return [
+    `${plural(out.length, "file")} match ${glob2}${where}:`,
+    ...out,
+    ...more ? [`\u2026 more past the ${limit} shown; give a narrower glob.`] : []
+  ].join("\n");
+}
+function textOutline(path, text) {
+  const lines = text.split(/\r?\n/);
+  const pick = (re, how) => ({
+    how,
+    lines: lines.flatMap((l, i) => re.test(l) ? [`${i + 1}: ${l.trimEnd()}`] : [])
+  });
+  if (/\.(md|markdown|mdx)$/i.test(path)) {
+    let fence = false;
+    return {
+      how: "its headings",
+      lines: lines.flatMap((l, i) => {
+        if (/^\s*(```|~~~)/.test(l))
+          fence = !fence;
+        return !fence && /^#{1,6}\s/.test(l) ? [`${i + 1}: ${l.trimEnd()}`] : [];
+      })
+    };
+  }
+  if (/\.(adoc|asciidoc)$/i.test(path))
+    return pick(/^={1,6}\s/, "its headings");
+  if (/\.ya?ml$/i.test(path))
+    return pick(/^[^\s#-][^:]*:/, "its top-level keys");
+  if (/\.properties$/i.test(path)) {
+    const o = pick(/^\s*[^#!\s][^=:]*[=:]/, "its keys");
+    return {
+      how: o.how,
+      lines: o.lines.map((l) => l.replace(/^(\d+: )\s*([^=:]+?)\s*[=:].*$/, "$1$2"))
+    };
+  }
+  return void 0;
+}
+async function outlineTool(root, input, o) {
+  const repo = str2(input.repo);
+  const path = str2(input.path);
+  if (!repo || !path)
+    throw new ContextToolError("outline needs a repo and the file's path in it.");
+  const dir = cloneOf(root, repo, o);
+  const file = await insideClone(dir, path);
+  const rel2 = posixPath(relative2(await realpath(dir), file).split(sep2).join("/"));
+  if (await isIgnored(dir, rel2))
+    throw new ContextToolError(`${path} is a file the repo's .gitignore ignores; it isn't read.`);
+  const size = (await stat2(file)).size;
+  if (size > CONTEXT_TOOL_BOUNDS.codeFileBytes)
+    throw new ContextToolError(`${path} is too big to outline (${size} bytes).`);
+  const text = await readFile3(file, "utf8");
+  const head = `Outline of ${repo}:${rel2}`;
+  let how;
+  let lines;
+  const decls = o.outline ? await o.outline(rel2, text) : void 0;
+  if (decls) {
+    how = "From its syntax tree: each line is the line number, then what is declared there.";
+    lines = decls.flatMap((d) => {
+      const pad = "  ".repeat(d.depth);
+      return [
+        ...d.marks.map((m) => `${m.line}: ${pad}${m.text}`),
+        `${d.line}: ${pad}${d.kind} ${d.name}`
+      ];
+    });
+  } else {
+    const t = textOutline(rel2, text);
+    if (!t)
+      return `${repo}:${rel2} has no outline: no reader for this kind of file. grep it, or show_code a line a hit returned.`;
+    how = `From ${t.how}: each line is the line number, then the line.`;
+    lines = t.lines;
+  }
+  if (!lines.length)
+    return `${head}
+${how}
+(nothing)`;
+  const shown = lines.slice(0, CONTEXT_TOOL_BOUNDS.outlineLines);
+  for (const l of shown) {
+    const m = OUTLINE_LINE.exec(l);
+    if (m)
+      o.pointers?.add(pointerKey(repo, rel2, Number(m[1])));
+  }
+  return [
+    head,
+    how,
+    ...shown,
+    ...lines.length > shown.length ? [`\u2026 and ${lines.length - shown.length} more lines; grep the file for what you need.`] : []
+  ].join("\n");
+}
+
+export {
+  GAP_STEP,
+  gapQuestion,
+  gapNameOf,
+  QueryError,
+  searchIndex,
+  nodesById,
+  candidateRef,
+  openIndex,
+  graph,
+  impact,
+  askLookup,
+  translate,
+  CONTEXT_TOOLS,
+  defaultCodeDir,
+  runContextTool,
+  contextToolBox,
+  namesInCode,
+  workspaceRepos
+};