@inerrata-corporation/errata 2.0.22 → 2.0.23-dev.4689

package/pass-worker.mjs

@@ -959,10 +959,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path) {
-  if (!path)
+function getElementAtPath(obj, path2) {
+  if (!path2)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path2.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1274,11 +1274,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path, issues) {
+function prefixIssues(path2, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path);
+    iss.path.unshift(path2);
     return iss;
   });
 }
@@ -1520,7 +1520,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path = []) => {
+  const processError = (error49, path2 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -1530,7 +1530,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path, ...issue2.path];
+        const fullpath = [...path2, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1562,8 +1562,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path) {
+  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path2) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14257,13 +14257,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path = ref.slice(1).split("/").filter(Boolean);
-  if (path.length === 0) {
+  const path2 = ref.slice(1).split("/").filter(Boolean);
+  if (path2.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path[0] === defsKey) {
-    const key = path[1];
+  if (path2[0] === defsKey) {
+    const key = path2[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -15535,8 +15535,8 @@ function npmPurl(name2, version3) {
 function component(name2, version3) {
   return { purl: npmPurl(name2, version3), name: name2, version: version3, ecosystem: "npm" };
 }
-function isNpmImporterPath(path) {
-  return path === "" || !path.includes("node_modules/");
+function isNpmImporterPath(path2) {
+  return path2 === "" || !path2.includes("node_modules/");
 }
 function parsePackageLockJson(jsonText) {
   let doc;
@@ -15549,22 +15549,22 @@ function parsePackageLockJson(jsonText) {
   const components = [];
   const hoisted = /* @__PURE__ */ new Map();
   const byPath = /* @__PURE__ */ new Map();
-  for (const [path, meta3] of Object.entries(packages)) {
-    if (path === "" || meta3.link === true) continue;
-    const ix = path.lastIndexOf("node_modules/");
+  for (const [path2, meta3] of Object.entries(packages)) {
+    if (path2 === "" || meta3.link === true) continue;
+    const ix = path2.lastIndexOf("node_modules/");
     if (ix === -1) continue;
-    const name2 = path.slice(ix + "node_modules/".length);
+    const name2 = path2.slice(ix + "node_modules/".length);
     const version3 = typeof meta3.version === "string" ? meta3.version : "";
     if (!name2 || !version3) continue;
     components.push(component(name2, version3));
-    byPath.set(path, { name: name2, version: version3 });
-    const depth = path.split("node_modules/").length;
+    byPath.set(path2, { name: name2, version: version3 });
+    const depth = path2.split("node_modules/").length;
     const prev = hoisted.get(name2);
     if (!prev || depth < prev.depth) hoisted.set(name2, { version: version3, depth });
   }
   const dependencies = [];
-  for (const [path, meta3] of Object.entries(packages)) {
-    const self = byPath.get(path);
+  for (const [path2, meta3] of Object.entries(packages)) {
+    const self = byPath.get(path2);
     if (!self) continue;
     const deps = meta3.dependencies;
     if (!deps || typeof deps !== "object") continue;
@@ -15577,8 +15577,8 @@ function parsePackageLockJson(jsonText) {
       dependencies.push({ ref: npmPurl(self.name, self.version), dependsOn });
   }
   const directRaw = [];
-  for (const [path, meta3] of Object.entries(packages)) {
-    if (!isNpmImporterPath(path)) continue;
+  for (const [path2, meta3] of Object.entries(packages)) {
+    if (!isNpmImporterPath(path2)) continue;
     for (const section of [meta3.dependencies, meta3.devDependencies, meta3.optionalDependencies]) {
       if (!section || typeof section !== "object") continue;
       for (const name2 of Object.keys(section)) {
@@ -15825,31 +15825,31 @@ function basename(p) {
   const ix = p.lastIndexOf("/");
   return ix === -1 ? p : p.slice(ix + 1);
 }
-function parseCsproj(path, text) {
+function parseCsproj(path2, text) {
   const deps = [];
   for (const m of text.matchAll(/<PackageReference\s+Include="([^"]+)"(?:\s+Version="([^"]+)")?/g)) {
-    deps.push({ ecosystem: "nuget", name: m[1] ?? "", version: m[2] ?? null, kind: "package", manifest: path });
+    deps.push({ ecosystem: "nuget", name: m[1] ?? "", version: m[2] ?? null, kind: "package", manifest: path2 });
   }
   for (const m of text.matchAll(/<Project\s+Sdk="([^"/]+)(?:\/([^"]+))?"/g)) {
     const sdk = m[1] ?? "";
     if (sdk.toLowerCase() !== "microsoft.net.sdk") {
-      deps.push({ ecosystem: "nuget", name: sdk, version: m[2] ?? null, kind: "sdk", manifest: path });
+      deps.push({ ecosystem: "nuget", name: sdk, version: m[2] ?? null, kind: "sdk", manifest: path2 });
     }
   }
   for (const m of text.matchAll(/<TargetFramework>([^<]+)<\/TargetFramework>/g)) {
     const mm = /^net(\d+\.\d+)/.exec((m[1] ?? "").trim());
-    if (mm) deps.push({ ecosystem: "dotnet", name: "dotnet", version: mm[1] ?? null, kind: "runtime", manifest: path });
+    if (mm) deps.push({ ecosystem: "dotnet", name: "dotnet", version: mm[1] ?? null, kind: "runtime", manifest: path2 });
   }
   return deps;
 }
-function parseGodot(path, text) {
+function parseGodot(path2, text) {
   const m = /config\/features=PackedStringArray\(([^)]*)\)/.exec(text);
   if (!m) return [];
   const feats = (m[1] ?? "").split(",").map((f) => f.trim().replace(/^"|"$/g, "")).filter((f) => f.length > 0);
   const version3 = feats.find((f) => /^\d+\.\d+/.test(f)) ?? null;
-  return [{ ecosystem: "godot", name: "godot", version: version3, kind: "engine", manifest: path }];
+  return [{ ecosystem: "godot", name: "godot", version: version3, kind: "engine", manifest: path2 }];
 }
-function parsePackageJson(path, text) {
+function parsePackageJson(path2, text) {
   let obj;
   try {
     obj = JSON.parse(text);
@@ -15863,7 +15863,7 @@ function parsePackageJson(path, text) {
     if (!section || typeof section !== "object") continue;
     for (const [name2, ver] of Object.entries(section)) {
       const version3 = ver ? String(ver) : null;
-      deps.push({ ecosystem: "npm", name: name2, version: version3, kind: "package", manifest: path });
+      deps.push({ ecosystem: "npm", name: name2, version: version3, kind: "package", manifest: path2 });
     }
   }
   return deps;
@@ -15871,7 +15871,7 @@ function parsePackageJson(path, text) {
 function isPep508DirectRef(spec) {
   return /^[A-Za-z0-9][A-Za-z0-9._-]*(?:\[[^\]]*\])?\s*@\s*\S/.test(spec.trim());
 }
-function parseRequirements(path, text) {
+function parseRequirements(path2, text) {
   const deps = [];
   for (const raw of text.split(/\r?\n/)) {
     const line = (raw.split("#", 1)[0] ?? "").trim();
@@ -15883,14 +15883,14 @@ function parseRequirements(path, text) {
         name: m[1] ?? "",
         version: m[2] ? m[3] ?? null : null,
         kind: "package",
-        manifest: path,
+        manifest: path2,
         ...isPep508DirectRef(line) ? { directRef: true } : {}
       });
     }
   }
   return deps;
 }
-function parsePyproject(path, text) {
+function parsePyproject(path2, text) {
   const deps = [];
   const m = /^\s*dependencies\s*=\s*\[([\s\S]*?)\]/m.exec(text);
   if (!m) return deps;
@@ -15903,14 +15903,14 @@ function parsePyproject(path, text) {
         name: mm[1] ?? "",
         version: null,
         kind: "package",
-        manifest: path,
+        manifest: path2,
         ...isPep508DirectRef(spec) ? { directRef: true } : {}
       });
     }
   }
   return deps;
 }
-function parseDocker(path, text) {
+function parseDocker(path2, text) {
   const deps = [];
   for (const m of text.matchAll(/^\s*(?:image:\s*|FROM\s+(?:--platform=\S+\s+)?)["']?([^\s"']+)/gm)) {
     const ref = m[1] ?? "";
@@ -15920,32 +15920,32 @@ function parseDocker(path, text) {
     const colon = undigested.indexOf(":");
     const name2 = colon === -1 ? undigested : undigested.slice(0, colon);
     const tag = colon === -1 ? "" : undigested.slice(colon + 1);
-    deps.push({ ecosystem: "docker", name: name2, version: tag || null, kind: "image", manifest: path });
+    deps.push({ ecosystem: "docker", name: name2, version: tag || null, kind: "image", manifest: path2 });
   }
   return deps;
 }
-function parseGoMod(path, text) {
+function parseGoMod(path2, text) {
   const deps = [];
   for (const m of text.matchAll(/^\s*(?:require\s+)?([a-z0-9.\-]+\.[a-z]+\/[^\s]+)\s+(v[^\s]+)/gm)) {
     const end = (m.index ?? 0) + m[0].length;
     if (text.slice(end, end + 20).includes("// indirect")) continue;
-    deps.push({ ecosystem: "golang", name: m[1] ?? "", version: m[2] ?? null, kind: "package", manifest: path });
+    deps.push({ ecosystem: "golang", name: m[1] ?? "", version: m[2] ?? null, kind: "package", manifest: path2 });
   }
   return deps;
 }
-function parseCargo(path, text) {
+function parseCargo(path2, text) {
   const deps = [];
   const sec = /^\[dependencies\]([\s\S]*?)(?=^\[|(?![\s\S]))/m.exec(text);
   if (!sec) return deps;
   for (const m of (sec[1] ?? "").matchAll(/^\s*([A-Za-z0-9_-]+)\s*=\s*(?:"([^"]+)"|\{[^}]*version\s*=\s*"([^"]+)")/gm)) {
-    deps.push({ ecosystem: "cargo", name: m[1] ?? "", version: m[2] ?? m[3] ?? null, kind: "package", manifest: path });
+    deps.push({ ecosystem: "cargo", name: m[1] ?? "", version: m[2] ?? m[3] ?? null, kind: "package", manifest: path2 });
   }
   return deps;
 }
 function mavenName(groupId, artifactId) {
   return `${groupId.trim()}:${artifactId.trim()}`;
 }
-function parsePom(path, text) {
+function parsePom(path2, text) {
   const deps = [];
   const coord = (block) => {
     const g = /<groupId>([^<]+)<\/groupId>/.exec(block)?.[1];
@@ -15955,15 +15955,15 @@ function parsePom(path, text) {
   };
   for (const m of text.matchAll(/<dependency>([\s\S]*?)<\/dependency>/g)) {
     const c = coord(m[1] ?? "");
-    if (c) deps.push({ ecosystem: "maven", name: mavenName(c.g, c.a), version: c.v, kind: "package", manifest: path });
+    if (c) deps.push({ ecosystem: "maven", name: mavenName(c.g, c.a), version: c.v, kind: "package", manifest: path2 });
   }
   for (const m of text.matchAll(/<parent>([\s\S]*?)<\/parent>/g)) {
     const c = coord(m[1] ?? "");
-    if (c) deps.push({ ecosystem: "maven", name: mavenName(c.g, c.a), version: c.v, kind: "sdk", manifest: path });
+    if (c) deps.push({ ecosystem: "maven", name: mavenName(c.g, c.a), version: c.v, kind: "sdk", manifest: path2 });
   }
   return deps;
 }
-function parseGradle(path, text) {
+function parseGradle(path2, text) {
   const deps = [];
   const re = new RegExp(`\\b(?:${GRADLE_CONFIGS})\\s*(?:\\(\\s*)?["']([^"']+)["']`, "g");
   for (const m of text.matchAll(re)) {
@@ -15975,12 +15975,12 @@ function parseGradle(path, text) {
       name: mavenName(group, artifact),
       version: version3?.trim() || null,
       kind: "package",
-      manifest: path
+      manifest: path2
     });
   }
   return deps;
 }
-function parseVersionCatalog(path, text) {
+function parseVersionCatalog(path2, text) {
   const section = /^\s*\[libraries\]([\s\S]*?)(?=^\s*\[|(?![\s\S]))/m.exec(text);
   if (!section) return [];
   const deps = [];
@@ -15991,34 +15991,34 @@ function parseVersionCatalog(path, text) {
     if (module2) {
       const [group2, artifact2] = module2.split(":");
       if (group2 && artifact2) {
-        deps.push({ ecosystem: "maven", name: mavenName(group2, artifact2), version: version3, kind: "package", manifest: path });
+        deps.push({ ecosystem: "maven", name: mavenName(group2, artifact2), version: version3, kind: "package", manifest: path2 });
       }
       continue;
     }
     const group = /\bgroup\s*=\s*["']([^"']+)["']/.exec(line)?.[1];
     const artifact = /\bname\s*=\s*["']([^"']+)["']/.exec(line)?.[1];
     if (group && artifact) {
-      deps.push({ ecosystem: "maven", name: mavenName(group, artifact), version: version3, kind: "package", manifest: path });
+      deps.push({ ecosystem: "maven", name: mavenName(group, artifact), version: version3, kind: "package", manifest: path2 });
     }
   }
   return deps;
 }
-function parseGemfile(path, text) {
+function parseGemfile(path2, text) {
   const deps = [];
   for (const raw of text.split(/\r?\n/)) {
     const line = (raw.split("#", 1)[0] ?? "").trim();
     const m = /^gem\s+["']([^"']+)["']\s*(?:,\s*["']([^"']+)["'])?/.exec(line);
     if (!m?.[1]) continue;
-    deps.push({ ecosystem: "gem", name: m[1], version: m[2] ?? null, kind: "package", manifest: path });
+    deps.push({ ecosystem: "gem", name: m[1], version: m[2] ?? null, kind: "package", manifest: path2 });
   }
   return deps;
 }
-function parseGemspec(path, text) {
+function parseGemspec(path2, text) {
   const deps = [];
   for (const m of text.matchAll(
     /\.add_(?:runtime_|development_)?dependency\s*\(?\s*["']([^"']+)["']\s*(?:,\s*["']([^"']+)["'])?/g
   )) {
-    if (m[1]) deps.push({ ecosystem: "gem", name: m[1], version: m[2] ?? null, kind: "package", manifest: path });
+    if (m[1]) deps.push({ ecosystem: "gem", name: m[1], version: m[2] ?? null, kind: "package", manifest: path2 });
   }
   return deps;
 }
@@ -16039,8 +16039,8 @@ function pomSelf(text) {
   if (artifact) self.push({ ecosystem: "maven", kind: "name", value: mavenName(group, artifact) });
   return self;
 }
-function parseManifestSelf(path, text) {
-  const file2 = basename(path);
+function parseManifestSelf(path2, text) {
+  const file2 = basename(path2);
   if (file2 === "package.json") {
     let obj;
     try {
@@ -16082,23 +16082,23 @@ function parseManifestSelf(path, text) {
   }
   return [];
 }
-function parseManifest(path, text) {
-  const name2 = basename(path);
-  if (name2.endsWith(".csproj") || name2.endsWith(".fsproj")) return parseCsproj(path, text);
-  if (name2 === "project.godot") return parseGodot(path, text);
-  if (name2 === "package.json") return parsePackageJson(path, text);
-  if (name2.startsWith("requirements") && name2.endsWith(".txt")) return parseRequirements(path, text);
-  if (name2 === "pyproject.toml") return parsePyproject(path, text);
+function parseManifest(path2, text) {
+  const name2 = basename(path2);
+  if (name2.endsWith(".csproj") || name2.endsWith(".fsproj")) return parseCsproj(path2, text);
+  if (name2 === "project.godot") return parseGodot(path2, text);
+  if (name2 === "package.json") return parsePackageJson(path2, text);
+  if (name2.startsWith("requirements") && name2.endsWith(".txt")) return parseRequirements(path2, text);
+  if (name2 === "pyproject.toml") return parsePyproject(path2, text);
   if (name2.startsWith("docker-compose") || name2.startsWith("compose") || name2.startsWith("Dockerfile")) {
-    return parseDocker(path, text);
-  }
-  if (name2 === "go.mod") return parseGoMod(path, text);
-  if (name2 === "libs.versions.toml") return parseVersionCatalog(path, text);
-  if (name2 === "Cargo.toml") return parseCargo(path, text);
-  if (name2 === "pom.xml") return parsePom(path, text);
-  if (name2 === "build.gradle" || name2 === "build.gradle.kts") return parseGradle(path, text);
-  if (name2 === "Gemfile") return parseGemfile(path, text);
-  if (name2.endsWith(".gemspec")) return parseGemspec(path, text);
+    return parseDocker(path2, text);
+  }
+  if (name2 === "go.mod") return parseGoMod(path2, text);
+  if (name2 === "libs.versions.toml") return parseVersionCatalog(path2, text);
+  if (name2 === "Cargo.toml") return parseCargo(path2, text);
+  if (name2 === "pom.xml") return parsePom(path2, text);
+  if (name2 === "build.gradle" || name2 === "build.gradle.kts") return parseGradle(path2, text);
+  if (name2 === "Gemfile") return parseGemfile(path2, text);
+  if (name2.endsWith(".gemspec")) return parseGemspec(path2, text);
   return [];
 }
 function buildSpine(sha2, manifestPaths2, readText) {
@@ -16172,7 +16172,7 @@ var init_history_read = __esm({
   "../../packages/shared/src/history-read.ts"() {
     "use strict";
     init_history_dependencies();
-    CLOUD_ATTR_DUPLICATE_KEYS = ["attrsJson", "embedding"];
+    CLOUD_ATTR_DUPLICATE_KEYS = ["attrsJson", "embedding", "structEmbedding", "structEmbeddedAt"];
   }
 });
 
@@ -16184,7 +16184,7 @@ var init_history_temporal = __esm({
 });
 
 // ../../packages/shared/src/history-revision.ts
-var Sha, HistoryRevisionRequestSchema;
+var Sha, HistoryRevisionRequestSchema, HistoryCarryRequestSchema, HISTORY_REVIEW_BUDGET, HISTORY_REVIEW_POLICY;
 var init_history_revision = __esm({
   "../../packages/shared/src/history-revision.ts"() {
     "use strict";
@@ -16204,6 +16204,17 @@ var init_history_revision = __esm({
         dependencyContext: HistoryDependencyContextSchema.optional()
       })).max(50)
     });
+    HistoryCarryRequestSchema = external_exports.strictObject({
+      fromCommit: Sha,
+      atCommit: Sha,
+      parents: external_exports.array(external_exports.strictObject({ commit: Sha, parents: external_exports.array(Sha).max(32) })).max(8192),
+      /** Every symbol in a file the range changed, both sides; `null` = too many to name, treat all as changed. */
+      changedSymbols: external_exports.array(external_exports.string().regex(/^sym_[a-f0-9]{8,64}$/)).max(5e3).nullable(),
+      /** Manifests the range changed; `null` = a lockfile (or too many manifests) changed, treat all as changed. */
+      changedManifests: external_exports.array(external_exports.string().regex(/^hmanifest_[a-f0-9]{32}$/)).max(512).nullable()
+    });
+    HISTORY_REVIEW_BUDGET = 48e3;
+    HISTORY_REVIEW_POLICY = `reviewer-view-${HISTORY_REVIEW_BUDGET}`;
   }
 });
 
@@ -16387,13 +16398,13 @@ function loadNodeSqlite() {
     process.emitWarning = original;
   }
 }
-function openDatabase(path, opts) {
-  const db = opts ? new DatabaseSync(path, opts) : new DatabaseSync(path);
+function openDatabase(path2, opts) {
+  const db = opts ? new DatabaseSync(path2, opts) : new DatabaseSync(path2);
   try {
     db.exec("PRAGMA foreign_keys = ON");
   } catch {
   }
-  if (path !== ":memory:" && !opts?.readOnly) {
+  if (path2 !== ":memory:" && !opts?.readOnly) {
     try {
       db.exec("PRAGMA journal_mode = WAL");
       db.exec("PRAGMA synchronous = NORMAL");
@@ -16402,20 +16413,20 @@ function openDatabase(path, opts) {
     } catch {
     }
   }
-  const wrapStmt = (stmt) => ({
+  const wrapStmt = (stmt2) => ({
     run: (...params) => {
-      const r = stmt.run(...coerceParams(params));
+      const r = stmt2.run(...coerceParams(params));
       return {
         changes: Number(r.changes),
         lastInsertRowid: Number(r.lastInsertRowid)
       };
     },
     get: (...params) => {
-      const r = stmt.get(...coerceParams(params));
+      const r = stmt2.get(...coerceParams(params));
       return r;
     },
     all: (...params) => {
-      const r = stmt.all(...coerceParams(params));
+      const r = stmt2.all(...coerceParams(params));
       return r;
     }
   });
@@ -16476,6 +16487,548 @@ var init_sqlite_adapter = __esm({
   }
 });
 
+// ../../packages/local-shared/src/tag-grammar.ts
+function tagGrammarCopy() {
+  const copy = [];
+  for (const ref of ["its-handle", "its-id", "h", "id"]) {
+    for (const build of Object.values(TAG_EXAMPLES)) copy.push(build(ref));
+  }
+  for (const v of TAG_VERBS) {
+    copy.push(v.hint);
+    if (v.taughtBy) copy.push(v.taughtBy);
+    for (const q of v.qualifiers ?? []) copy.push(q.note);
+    for (const l of v.lowering) {
+      if (l.note) copy.push(l.note);
+      if (l.knownViolation) copy.push(l.knownViolation.finding);
+    }
+  }
+  for (const f of TAG_FENCES) copy.push(f.hint);
+  return copy;
+}
+function normalizeTemplateBody(body2) {
+  return body2.replace(/…|\.{3}/g, " ").replace(/\s+/g, " ").trim().replace(/^[\s,;:—–-]+|[\s,;:.—–-]+$/g, "").toLowerCase();
+}
+function deriveTagTemplates(copy) {
+  const bodies = /* @__PURE__ */ new Set();
+  const handles = new Set([...TAG_PLACEHOLDER_HANDLES].map((h) => h.toLowerCase()));
+  for (const text of copy) {
+    for (const m of text.matchAll(BRACKET_TOKEN)) {
+      const token = m[1].trim().toLowerCase();
+      if (!/^[!?]/.test(token) && !REAL_HANDLE_SHAPE.test(token)) handles.add(token);
+    }
+  }
+  for (const text of copy) {
+    for (const m of text.matchAll(TEMPLATE_VERB_GROUP)) {
+      const body2 = normalizeTemplateBody(m[2]);
+      bodies.add(body2);
+      const unthreaded = normalizeTemplateBody(body2.replace(/^#[a-z][\w-]*/i, ""));
+      bodies.add(unthreaded);
+      const rest = normalizeTemplateBody(unthreaded.replace(BRACKET_TOKEN, (t, h) => handles.has(h.trim().toLowerCase()) ? " " : t).replace(/,/g, " "));
+      bodies.add(rest);
+    }
+  }
+  bodies.delete("");
+  return { bodies, handles };
+}
+var TAG_CANONICAL_ID_PREFIXES, TAG_HANDLE_SOURCE, TAG_THREAD_SOURCE, TAG_PLACEHOLDER_HANDLES, TAG_EXAMPLES, P, S, RC, CITE_LOWERING, INSTANCE_LOWERING, TRIAGE_TO_RC, TAG_VERBS, TAG_FENCES, TAG_VERB_BY_NAME, TAG_PAREN_VERBS, TAG_GRAMMAR_OPENERS, TAG_QUOTED_PAREN_SOURCE, TAG_QUOTED_RE, TAG_QUOTED_PAREN_RE, TEMPLATE_VERB_GROUP, BRACKET_TOKEN, REAL_HANDLE_SHAPE, TAG_TEMPLATES, VERB_WORDS_SOURCE, JOINED_VERB, LEADING_VERB, ANY_VERB_WORD, QUOTED_TAG_OPENER;
+var init_tag_grammar = __esm({
+  "../../packages/local-shared/src/tag-grammar.ts"() {
+    "use strict";
+    TAG_CANONICAL_ID_PREFIXES = ["pat", "sol", "drc", "dcause", "dfix", "dprob", "dvuln", "prob", "claim", "err"];
+    TAG_HANDLE_SOURCE = String.raw`\[([a-z0-9][\w-]{0,80})\]|((?:${TAG_CANONICAL_ID_PREFIXES.join("|")})_[0-9a-f]{6,})`;
+    TAG_THREAD_SOURCE = String.raw`#([a-z][\w-]{0,63})`;
+    TAG_PLACEHOLDER_HANDLES = /* @__PURE__ */ new Set([
+      "handle",
+      "its-handle",
+      "another",
+      "a-third",
+      "h",
+      "h1",
+      "h2",
+      "id",
+      "its-id",
+      "a",
+      "b",
+      "\u2026",
+      "..."
+    ]);
+    TAG_EXAMPLES = {
+      prior: (ref) => `([${ref}])`,
+      problem: () => `[!one line on what's wrong]`,
+      vulnerability: () => `[!vuln: who can do what; observed basis @ path:line]`,
+      suspectedVulnerability: () => `[?vuln: consequence; missing check]`,
+      vulnerabilityThread: () => `[!#v vuln: finding here]`,
+      fix: (ref) => `(fix:[${ref}])`,
+      // CONSTRAINT — the native capture path for a DIFFUSE problem (a constraint/tension/
+      // conflict that shaped a decision). Free text, attaches to the decision sentence the
+      // agent is already writing. Full rationale in the constraint note below + prior-tags.ts.
+      constraint: () => `(constraint: the limitation that forced it)`,
+      // TRIAGE — routes the problem/symptom in scope to its cause. `(cause:[handle])`
+      // links to a cited RootCause/Solution node; `(cause: free text)` mints a RootCause
+      // from the text. Harvested in prior-tags.ts → engine.ts (see the triage note below).
+      triage: (ref) => `(cause:[${ref}])`,
+      // Unlike a bare cause citation, this handle names the Problem being explained.
+      triageExplain: (ref) => `(cause:[${ref}] the mechanism)`,
+      // The MINT form — free-text cause that mints a RootCause. Prime-time surfacing
+      // (recallForFile) pastes this next to an open Problem that has no cause yet, so the
+      // diagnostic moment is cued when the agent is looking at the problem. Kept here so
+      // the grammar can't drift from parseInlineTags' `(cause: …)` acceptance.
+      triageMint: () => `(cause: why it happens)`,
+      // THREAD forms — the witness-declared symptom↔cause/fix binding. A `#id` on the
+      // flag names the diagnosis thread; the same `#id` on a later verb binds to it
+      // explicitly (across sentences AND turns), replacing proximity guessing. Adjacent
+      // tags never need one — the id is for diagnoses that unfold over distance.
+      problemThread: () => `[!#slug one line on what's wrong]`,
+      causeThread: () => `(cause:#slug the mechanism)`,
+      fixThread: (thread = "slug") => `(fix:#${thread} what you changed)`,
+      // ATTEMPT arc — what's being tried and what didn't work. A failed attempt is a
+      // witnessed NEGATIVE result: it saves the next agent the same dead end.
+      tried: () => `(tried: the approach you're attempting)`,
+      failed: () => `(failed: what didn't work and the dead end it rules out)`,
+      // `(failed:[h] …)` on a shown SOLUTION — the refute-by-failure form the context render teaches.
+      failedCite: (ref) => `(failed:[${ref}] what came back)`,
+      // LINK verbs (AC epic) — bind the problem in scope to CANONICAL priors and
+      // abstractions. Multi-target by design: single links are weak; ~3 links to 3
+      // DIFFERENT relevant priors is the target shape (see linkBullet).
+      instance: (ref) => `(instance:[${ref}],[another],[a-third])`,
+      pattern: () => `(pattern: name the general shape)`,
+      // DOMAIN — the abstract area a problem is about; the concept layer an
+      // anchor-less problem clusters on. Mints/resolves a Domain by name.
+      domain: () => `(domain: The Area)`,
+      // PACKAGE/COMPONENT — agent-named public anchors (OM-agent-anchors): the
+      // package a problem is ABOUT (even when not a dependency) and the
+      // framework/product-level unit it concerns. Public spine anchors → the
+      // knowledge can cross to the collective.
+      package: () => `(package: the-package-name)`,
+      component: () => `(component: The Component)`,
+      aids: (ref) => `(aids:[${ref}])`,
+      // SOLUTION-STRUCTURE (SS-structure) — taught in the link bullet; Solution→Solution.
+      buildsOn: (ref) => `(builds-on:[${ref}])`,
+      supersedes: (ref) => `(supersedes:[${ref}])`,
+      alternative: (ref) => `(alternative:[${ref}])`,
+      // VERDICT (VS-verdict-tags) — a judgment on a SHOWN prior, distinct from leaning on it.
+      // `confirm` rides the corroborate channel (it held); `refute` the contradict channel
+      // (it's wrong / didn't hold) and REQUIRES a reason. This is the inline producer the
+      // evidence channels lacked — refute sat dead (contradictionPressure 0) until now, while
+      // lean-on corroboration lived, because only corroboration had an inline path. Grammar
+      // single-sourced with parseInlineTags' CONFIRM_PREFIX/REFUTE_PREFIX.
+      confirm: (ref) => `(confirm:[${ref}])`,
+      refute: (ref) => `(refute:[${ref}] one line why)`,
+      // RETRACT — "not a real problem": the errata-resolved block with a disposition
+      // (parseDesignResolutions, turn.ts). No inline form exists; the block is the grammar.
+      retract: (id) => ["```errata-resolved", `id: ${id}`, "disposition: false_positive", "reason: why it was never a real problem", "```"].join("\n")
+    };
+    P = "Problem";
+    S = "Solution";
+    RC = "RootCause";
+    CITE_LOWERING = [
+      { target: RC, writes: [{ from: P, edge: "CAUSED_BY", to: RC }] },
+      { target: S, writes: [{ from: P, edge: "SOLVED_BY", to: S }] },
+      { target: "Pattern", writes: [{ from: P, edge: "INSTANCE_OF", to: "Pattern" }, { from: "Pattern", edge: "ANCHORED_AT", to: "File" }], note: "cite-anchor promotion after 2 sessions", decision: "d", knownViolation: { edge: "ANCHORED_AT", finding: "motif cite-anchor promotion writes a refused ANCHORED_AT" } },
+      { target: "Package", writes: [{ from: P, edge: "DEPENDS_ON", to: "Package" }] },
+      { target: "Language", writes: [{ from: P, edge: "OCCURS_IN", to: "Language" }] },
+      { target: "Tool", writes: [{ from: P, edge: "CONCERNS", to: "Tool" }] },
+      { target: "Component", writes: [{ from: P, edge: "CONCERNS", to: "Component" }] },
+      { target: P, writes: [{ from: P, edge: "RELATES_TO", to: P }, { from: P, edge: "ANCHORED_AT", to: "File" }], note: "corroboration witness + cite-anchor promotion" },
+      { target: "AntiPattern", writes: [{ from: P, edge: "RELATES_TO", to: "AntiPattern" }, { from: "AntiPattern", edge: "ANCHORED_AT", to: "File" }], decision: "e", knownViolation: { edge: "ANCHORED_AT", finding: "motif cite-anchor promotion writes a refused ANCHORED_AT" } },
+      { target: "Technique", writes: [{ from: P, edge: "RELATES_TO", to: "Technique" }, { from: "Technique", edge: "ANCHORED_AT", to: "File" }], decision: "e", knownViolation: { edge: "ANCHORED_AT", finding: "motif cite-anchor promotion writes a refused ANCHORED_AT" } },
+      { target: "Weakness", writes: [{ from: P, edge: "RELATES_TO", to: "Weakness" }], decision: "e" },
+      { target: "Domain", writes: [{ from: P, edge: "RELATES_TO", to: "Domain" }], decision: "e" },
+      { target: "Claim", writes: [{ from: P, edge: "RELATES_TO", to: "Claim" }, { from: "Claim", edge: "ANCHORED_AT", to: "File" }] }
+    ];
+    INSTANCE_LOWERING = [
+      { target: "Pattern", writes: [{ from: P, edge: "INSTANCE_OF", to: "Pattern" }] },
+      { target: P, writes: [{ from: P, edge: "RELATES_TO", to: P }] },
+      { target: S, writes: [{ from: P, edge: "SOLVED_BY", to: S }], note: "an instance cite on a Solution claims the problem is solved by it", decision: "a" },
+      { target: RC, writes: [{ from: P, edge: "CAUSED_BY", to: RC }] },
+      { target: "AntiPattern", writes: [{ from: P, edge: "RELATES_TO", to: "AntiPattern" }], decision: "e" },
+      { target: "Technique", writes: [{ from: P, edge: "RELATES_TO", to: "Technique" }], decision: "e" },
+      { target: "Weakness", writes: [{ from: P, edge: "RELATES_TO", to: "Weakness" }], decision: "e" },
+      { target: "Domain", writes: [{ from: P, edge: "RELATES_TO", to: "Domain" }], decision: "e" },
+      { target: "Package", writes: [{ from: P, edge: "DEPENDS_ON", to: "Package" }] },
+      { target: "Component", writes: [{ from: P, edge: "CONCERNS", to: "Component" }] }
+    ];
+    TRIAGE_TO_RC = [
+      { from: P, edge: "TRIAGED_BY", to: "Triage" },
+      { from: "Triage", edge: "INDICATES", to: RC },
+      { from: P, edge: "CAUSED_BY", to: RC }
+    ];
+    TAG_VERBS = [
+      {
+        verb: "cite",
+        form: "citation",
+        opener: "(",
+        kinds: ["prior"],
+        args: "handles",
+        thread: false,
+        handleRequired: true,
+        lowering: CITE_LOWERING,
+        examples: ["prior"],
+        hint: "cite a shown prior you leaned on: ([its-handle]) \u2014 handles only, no prose inside the parens",
+        taught: "taught"
+      },
+      {
+        verb: "!",
+        form: "flag",
+        opener: "[!",
+        kinds: ["problem", "triage", "vulnerability", "fix", "prior"],
+        args: "flag-body",
+        thread: true,
+        minText: 8,
+        qualifiers: [
+          { name: "vuln", taught: true, note: "[!vuln: \u2026] \u2192 Vulnerability (asserted)" },
+          { name: "fixed", taught: false, note: "[!fixed: X] \u2192 read as a self-found fix" },
+          { name: "resolved", taught: false, note: "[!resolved: X] \u2192 read as a self-found fix" }
+        ],
+        lowering: [
+          { target: P, writes: [], note: "mints a Problem; `@ path[:line]` anchors it (ANCHORED_AT to code)" },
+          { target: RC, writes: [...TRIAGE_TO_RC, { from: RC, edge: "CAUSED_BY", to: RC }], note: "`<-` segments: first \u2192 triage route, later \u2192 RootCause chain" },
+          { target: "Vulnerability", writes: [], note: "[!vuln: \u2026]; `<-` causes stay on the finding (vulnerabilityCauses)" }
+        ],
+        examples: ["problem", "problemThread", "vulnerability", "vulnerabilityThread"],
+        hint: "flag a problem on one line: [!what's wrong @ path:42]; fold causes with <- ; a fix goes in (fix: \u2026), not [!fixed: \u2026]",
+        taught: "taught"
+      },
+      {
+        verb: "?",
+        form: "flag",
+        opener: "[?",
+        kinds: ["todo", "vulnerability"],
+        args: "flag-body",
+        thread: true,
+        minText: 8,
+        qualifiers: [{ name: "vuln", taught: true, note: "[?vuln: \u2026] \u2192 Vulnerability (suspected)" }],
+        lowering: [{ target: P, writes: [], note: "mints a todo Problem; a fix can close it today", decision: "g" }],
+        examples: ["suspectedVulnerability"],
+        hint: "[?\u2026] marks an open question / todo; [?vuln: consequence; missing check] a suspected vulnerability",
+        taught: "untaught",
+        taughtBy: "only the [?vuln:] form is taught; the bare [?todo] form is not",
+        decisions: ["g"]
+      },
+      {
+        verb: "fix",
+        form: "verb",
+        opener: "(fix:",
+        kinds: ["fix"],
+        args: "handles-text",
+        thread: true,
+        minText: 12,
+        lowering: [
+          { target: P, writes: [{ from: P, edge: "SOLVED_BY", to: S }], note: "closes the Problem; a note \u226512 chars mints the Solution" },
+          { target: "Vulnerability", writes: [{ from: "Vulnerability", edge: "SOLVED_BY", to: S }] },
+          { target: RC, writes: [], note: "dropped: 'fix tag went nowhere' (not a Problem); no tag writes FIXED_BY", decision: "f" }
+        ],
+        examples: ["fix", "fixThread"],
+        hint: "one fix per tag: (fix:[its-handle]) or (fix:#thread what you changed) \u2014 put the cause in its own (cause: \u2026)",
+        taught: "taught",
+        decisions: ["f"]
+      },
+      {
+        verb: "cause",
+        form: "verb",
+        opener: "(cause:",
+        kinds: ["triage"],
+        args: "handles-text",
+        thread: true,
+        minText: 8,
+        lowering: [
+          { target: RC, writes: TRIAGE_TO_RC },
+          { target: P, writes: [{ from: P, edge: "TRIAGED_BY", to: "Triage" }, { from: "Triage", edge: "INDICATES", to: RC }, { from: P, edge: "CAUSED_BY", to: RC }], note: "(cause:[problem] mechanism) \u2014 the cited Problem is the symptom; the mechanism mints the RootCause" },
+          { target: S, writes: [{ from: P, edge: "TRIAGED_BY", to: "Triage" }, { from: "Triage", edge: "INDICATES", to: S }], decision: "b", knownViolation: { edge: "INDICATES", finding: "(cause:[solution]) writes a refused INDICATES \u2192 Solution" } }
+        ],
+        examples: ["triage", "triageExplain", "triageMint", "causeThread"],
+        hint: "(cause: the mechanism you'd change) or (cause:[root-cause-handle]); bind a distant symptom with (cause:#thread \u2026)",
+        taught: "taught",
+        decisions: ["b"]
+      },
+      {
+        verb: "constraint",
+        form: "verb",
+        opener: "(constraint:",
+        kinds: ["constraint"],
+        args: "text",
+        thread: false,
+        minText: 8,
+        textRequired: true,
+        lowering: [{ target: P, writes: [], note: "mints a constraint-kind Problem" }],
+        examples: ["constraint"],
+        hint: "(constraint: the limitation that forced the decision)",
+        taught: "taught"
+      },
+      {
+        verb: "tried",
+        form: "verb",
+        opener: "(tried:",
+        kinds: ["attempt"],
+        args: "text",
+        thread: true,
+        minText: 8,
+        textRequired: true,
+        lowering: [{ target: P, writes: [], note: "journals an attempt on the bound problem" }],
+        examples: ["tried"],
+        hint: "(tried: the approach) \u2014 bind with (tried:#thread \u2026)",
+        taught: "taught"
+      },
+      {
+        verb: "failed",
+        form: "verb",
+        opener: "(failed:",
+        kinds: ["failure"],
+        args: "handles-text",
+        thread: true,
+        minText: 8,
+        textRequired: true,
+        lowering: [
+          { target: P, writes: [], note: "journals a failed attempt on the bound problem" },
+          { target: S, writes: [], note: "(failed:[h]) refutes the cited prior (contradictionPressure); skips the label gate today", decision: "j" }
+        ],
+        examples: ["failed", "failedCite"],
+        hint: "(failed: what didn't work); (failed:[solution] what came back) refutes a shown fix",
+        taught: "taught",
+        decisions: ["j"]
+      },
+      {
+        verb: "instance",
+        form: "verb",
+        opener: "(instance:",
+        kinds: ["instance"],
+        args: "handles",
+        thread: false,
+        handleRequired: true,
+        lowering: INSTANCE_LOWERING,
+        examples: ["instance"],
+        hint: "(instance:[h1],[h2],[h3]) \u2014 ~3 DIFFERENT shown priors this problem instantiates; handles only",
+        taught: "taught",
+        decisions: ["a", "e"]
+      },
+      {
+        verb: "pattern",
+        form: "verb",
+        opener: "(pattern:",
+        kinds: ["pattern"],
+        args: "handle-or-text",
+        thread: false,
+        minText: 3,
+        lowering: [{ target: "Pattern", writes: [{ from: P, edge: "INSTANCE_OF", to: "Pattern" }], note: "a handle must be a Pattern; free text resolves-or-mints one" }],
+        examples: ["pattern"],
+        hint: "(pattern: name the general shape) or (pattern:[shown-pattern])",
+        taught: "taught"
+      },
+      {
+        verb: "domain",
+        form: "verb",
+        opener: "(domain:",
+        kinds: ["domain"],
+        args: "text",
+        thread: false,
+        minText: 2,
+        textRequired: true,
+        lowering: [{ target: "Domain", writes: [{ from: P, edge: "PERTAIN_TO", to: "Domain" }], note: '(domain:#t X) mints a Domain named "#t X" today', decision: "k" }],
+        examples: ["domain"],
+        hint: "(domain: The Area) \u2014 Title Case, no thread",
+        taught: "taught",
+        decisions: ["k"]
+      },
+      {
+        verb: "package",
+        form: "verb",
+        opener: "(package:",
+        kinds: ["package"],
+        args: "text",
+        thread: false,
+        minText: 2,
+        textRequired: true,
+        lowering: [{ target: "Package", writes: [{ from: P, edge: "DEPENDS_ON", to: "Package" }], note: "means 'concerns', written as DEPENDS_ON", decision: "c" }],
+        examples: ["package"],
+        hint: "(package: the-package-name) \u2014 the public package it's about",
+        taught: "taught",
+        decisions: ["c"]
+      },
+      {
+        verb: "component",
+        form: "verb",
+        opener: "(component:",
+        kinds: ["component"],
+        args: "text",
+        thread: false,
+        minText: 2,
+        textRequired: true,
+        lowering: [{ target: "Component", writes: [{ from: P, edge: "CONCERNS", to: "Component" }] }],
+        examples: ["component"],
+        hint: "(component: The Component) \u2014 the framework/product unit",
+        taught: "taught"
+      },
+      {
+        verb: "aids",
+        form: "verb",
+        opener: "(aids:",
+        kinds: ["transfer"],
+        args: "handles",
+        thread: true,
+        handleRequired: true,
+        lowering: [{ target: P, writes: [{ from: S, edge: "MAY_RESOLVE", to: P }], note: "source = the Solution in scope; non-Problem targets are skipped" }],
+        examples: ["aids"],
+        hint: "(aids:[problem-handle],\u2026) \u2014 other shown problems your fix might also resolve",
+        taught: "taught"
+      },
+      {
+        verb: "builds-on",
+        form: "verb",
+        opener: "(builds-on:",
+        kinds: ["builds-on"],
+        args: "handles",
+        thread: true,
+        handleRequired: true,
+        lowering: [{ target: S, writes: [{ from: S, edge: "BUILDS_ON", to: S }] }],
+        examples: ["buildsOn"],
+        hint: "(builds-on:[shown-solution]) \u2014 your fix layers on it",
+        taught: "taught",
+        taughtBy: "linkBullet instruction text"
+      },
+      {
+        verb: "supersedes",
+        form: "verb",
+        opener: "(supersedes:",
+        kinds: ["supersedes"],
+        args: "handles",
+        thread: true,
+        handleRequired: true,
+        lowering: [{ target: S, writes: [{ from: S, edge: "SUPERSEDES", to: S }] }],
+        examples: ["supersedes"],
+        hint: "(supersedes:[shown-solution]) \u2014 your fix replaces it",
+        taught: "taught",
+        taughtBy: "linkBullet instruction text"
+      },
+      {
+        verb: "alternative",
+        form: "verb",
+        opener: "(alternative:",
+        kinds: ["alternative"],
+        args: "handles",
+        thread: true,
+        handleRequired: true,
+        lowering: [{ target: S, writes: [{ from: S, edge: "ALTERNATIVE_TO", to: S }] }],
+        examples: ["alternative"],
+        hint: "(alternative:[shown-solution]) \u2014 a different valid approach",
+        taught: "taught",
+        taughtBy: "linkBullet instruction text"
+      },
+      {
+        verb: "confirm",
+        form: "verb",
+        opener: "(confirm:",
+        kinds: ["confirm"],
+        args: "handles",
+        thread: false,
+        handleRequired: true,
+        lowering: [{ target: S, writes: [], note: "corroboration witness (corroborationCount), no edge" }],
+        examples: ["confirm"],
+        hint: "(confirm:[shown-prior]) \u2014 it held",
+        taught: "taught",
+        taughtBy: "verdictBullet + context render",
+        decisions: ["j"]
+      },
+      {
+        verb: "refute",
+        form: "verb",
+        opener: "(refute:",
+        kinds: ["refute"],
+        args: "handles-text",
+        thread: false,
+        minText: 4,
+        handleRequired: true,
+        textRequired: true,
+        lowering: [{ target: S, writes: [], note: "contradiction witness (contradictionPressure), no edge; reason stays local" }],
+        examples: ["refute"],
+        hint: "(refute:[shown-prior] one line why) \u2014 the reason is required",
+        taught: "taught",
+        taughtBy: "verdictBullet + context render",
+        decisions: ["j"]
+      }
+    ];
+    TAG_FENCES = [
+      {
+        fence: "errata-problem",
+        fields: ["problem", "cause", "fix", "anchor", "kind"],
+        required: [["problem"]],
+        taught: "untaught",
+        parser: "apps/daemon/src/turn.ts parseDesignFlags",
+        decisions: ["h"],
+        hint: "use an inline [!\u2026] flag instead (errata-problem cause ids never meet inline ids)"
+      },
+      {
+        fence: "errata-resolved",
+        fields: ["id", "problem", "fix", "disposition", "reason"],
+        required: [["id", "problem"]],
+        taught: "taught",
+        taughtBy: "retract form only (TAG_EXAMPLE.retract); the fix form is untaught",
+        parser: "apps/daemon/src/turn.ts parseDesignResolutions",
+        hint: "```errata-resolved with id: and disposition: false_positive | invalid, reason: \u2026"
+      },
+      {
+        fence: "errata-triage",
+        fields: ["presenting", "cause", "test", "fix", "drift", "route"],
+        required: [["presenting", "route"], ["cause", "test"]],
+        taught: "taught",
+        taughtBy: "MCP errata_triage tool copy",
+        parser: "packages/local-graph/src/triage.ts parseTriageFences",
+        hint: "```errata-triage with presenting: and cause: (or route: + test: to answer one)"
+      },
+      {
+        fence: "errata-abstraction",
+        fields: ["candidate", "principle", "covers"],
+        required: [["candidate"], ["principle"], ["covers"]],
+        taught: "taught",
+        taughtBy: "MCP errata_pending_abstractions tool copy",
+        parser: "packages/local-graph/src/abstraction.ts parseAbstractionFences",
+        hint: "```errata-abstraction with candidate:, principle:, covers: (all required)"
+      },
+      {
+        fence: "errata-intent",
+        fields: ["intent"],
+        required: [["intent"]],
+        taught: "taught",
+        parser: "packages/local-graph/src/intent.ts parseIntentFences",
+        hint: "```errata-intent with intent: what you're about to do"
+      },
+      {
+        fence: "errata-share",
+        fields: ["priors"],
+        required: [["priors"]],
+        taught: "taught",
+        taughtBy: "subagent hand-off copy",
+        parser: "packages/local-graph/src/intent.ts parseShareFence",
+        hint: "```errata-share with priors: all | [h1], [h2]"
+      }
+    ];
+    TAG_VERB_BY_NAME = new Map(
+      TAG_VERBS.filter((v) => v.form === "verb").map((v) => [v.verb, v])
+    );
+    TAG_PAREN_VERBS = [...TAG_VERB_BY_NAME.keys()].sort((a, b) => b.length - a.length);
+    TAG_GRAMMAR_OPENERS = [
+      ...new Set(TAG_VERBS.filter((v) => v.form !== "citation").map((v) => v.opener))
+    ];
+    TAG_QUOTED_PAREN_SOURCE = String.raw`\(\s*(?:${TAG_PAREN_VERBS.map((v) => v.replace(/-/g, "\\-")).join("|")})\s*:|\(\[`;
+    TAG_QUOTED_RE = new RegExp(String.raw`\[[!?]|` + TAG_QUOTED_PAREN_SOURCE, "i");
+    TAG_QUOTED_PAREN_RE = new RegExp(TAG_QUOTED_PAREN_SOURCE, "i");
+    TEMPLATE_VERB_GROUP = new RegExp(
+      String.raw`\(\s*(${TAG_PAREN_VERBS.map((v) => v.replace(/-/g, "\\-")).join("|")})\s*:((?:[^()\n]|\([^()\n]*\))*)\)`,
+      "gi"
+    );
+    BRACKET_TOKEN = /\[([^\]\n]{1,80})\]/g;
+    REAL_HANDLE_SHAPE = new RegExp(
+      String.raw`^(?:[a-z0-9]+(?:-[a-z0-9]+)*-(?=[0-9a-f]{0,3}\d)[0-9a-f]{4}|(?:${TAG_CANONICAL_ID_PREFIXES.join("|")})_[0-9a-f]{6,})$`,
+      "i"
+    );
+    TAG_TEMPLATES = deriveTagTemplates(tagGrammarCopy());
+    VERB_WORDS_SOURCE = TAG_PAREN_VERBS.map((v) => v.replace(/-/g, "\\-")).join("|");
+    JOINED_VERB = new RegExp(String.raw`[,;]\s*(?=(?:${VERB_WORDS_SOURCE})\s*:)`, "i");
+    LEADING_VERB = new RegExp(String.raw`^\s*(${VERB_WORDS_SOURCE})\s*:`, "i");
+    ANY_VERB_WORD = new RegExp(String.raw`\b(?:${VERB_WORDS_SOURCE})\s*:`, "gi");
+    QUOTED_TAG_OPENER = new RegExp(String.raw`\(\s*(?:(${VERB_WORDS_SOURCE})\s*:|(?=\[))`, "gi");
+  }
+});
+
 // ../../packages/local-shared/src/index.ts
 var init_src2 = __esm({
   "../../packages/local-shared/src/index.ts"() {
@@ -16489,6 +17042,7 @@ var init_src2 = __esm({
     init_review();
     init_anchorable();
     init_sqlite_adapter();
+    init_tag_grammar();
   }
 });
 
@@ -16874,11 +17428,12 @@ function purgeWorkspaceCodeGraph(store2, workspaceId) {
   const edgesBefore = store2.edgeCount();
   store2.transaction(() => {
     for (const label of INDEXER_OWNED_LABELS) {
-      const nodes = store2.findAllVersionsByLabel(label);
+      const nodes = store2.selectNodes({
+        labels: [label],
+        includeClosed: true,
+        where: [{ attr: "workspaceId", eq: workspaceId }]
+      });
       for (const n of nodes) {
-        if (n.attrs.workspaceId !== workspaceId) {
-          continue;
-        }
         store2.deleteNode(n.id);
         nodesDeleted++;
       }
@@ -16895,10 +17450,20 @@ function isReExportBarrel(relPath) {
 function graphExportMap(store2, workspaceId, relPath) {
   const out2 = /* @__PURE__ */ new Map();
   const fileId = fileNodeId(workspaceId, relPath);
-  if (!store2.getNode(fileId)) return out2;
-  for (const e of store2.outEdges(fileId, ["DEFINES"])) {
-    const n = store2.getNode(e.to);
-    if (!n || !EXPORTABLE_LABELS.has(n.label)) continue;
+  if (store2.nodeLabels([fileId]).size === 0) return out2;
+  const defines = store2.outEdges(fileId, ["DEFINES"]);
+  const rows = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < defines.length; i2 += 500) {
+    for (const r of store2.selectNodes({
+      labels: [...EXPORTABLE_LABELS],
+      attrs: ["workspaceId", "name"],
+      where: [{ idIn: defines.slice(i2, i2 + 500).map((e) => e.to) }],
+      includeClosed: true
+    })) rows.set(r.id, r);
+  }
+  for (const e of defines) {
+    const n = rows.get(e.to);
+    if (!n) continue;
     if (n.attrs["workspaceId"] !== workspaceId) continue;
     const name2 = n.attrs["name"] ?? n.description;
     if (!name2 || name2.startsWith("<") || name2.includes(":")) continue;
@@ -17065,14 +17630,37 @@ async function incrementalReindex(store2, rootPath, workspaceId, changedAbsPaths
       signatureAfter: a.signature
     });
   }
+  const repointable = /* @__PURE__ */ new Map();
   store2.transaction(() => {
     for (const nid of changedIds) store2.freezeNode(nid, t);
     for (const nid of removedIds) {
+      repointable.set(nid, store2.inEdges(nid, ["CALLS", "ACCESSES", "ANCHORED_AT"]));
       for (const e of store2.outEdges(nid)) store2.closeEdge(e.id, t);
       store2.closeNode(nid, t);
     }
   });
-  const r = await runIndexer(store2, {
+  const seenNodes = /* @__PURE__ */ new Set();
+  const seenEdges = /* @__PURE__ */ new Set();
+  const writeStore = store2.mergeNodeIfChanged && store2.mergeEdgeIfChanged ? new Proxy(store2, {
+    get(target, prop) {
+      if (prop === "mergeNode") {
+        return (n) => {
+          seenNodes.add(n.id);
+          if (n.label === "File" || n.label === "Folder") target.mergeNode(n);
+          else target.mergeNodeIfChanged(n);
+        };
+      }
+      if (prop === "mergeEdge") {
+        return (e) => {
+          seenEdges.add(edgeId(e.from, e.type, e.to));
+          target.mergeEdgeIfChanged(e);
+        };
+      }
+      const v = Reflect.get(target, prop, target);
+      return typeof v === "function" ? v.bind(target) : v;
+    }
+  }) : store2;
+  const r = await runIndexer(writeStore, {
     workspaceId,
     rootPath,
     providers,
@@ -17090,14 +17678,14 @@ async function incrementalReindex(store2, rootPath, workspaceId, changedAbsPaths
       if (typeof rel !== "string" || !changedRelPaths.has(rel)) continue;
       if (versionedAndFile.has(n.label)) {
         ownedLive.push(n.id);
-      } else if (n.label === "Comment" && n.lastUpdatedAt < t) {
+      } else if (n.label === "Comment" && n.lastUpdatedAt < t && !seenNodes.has(n.id)) {
         store2.closeNode(n.id, t);
       }
     }
     for (const id of ownedLive) {
       for (const e of store2.outEdges(id)) {
         if (e.type === "SUPERSEDED_BY") continue;
-        if (e.lastSeenAt < t) {
+        if (e.lastSeenAt < t && !seenEdges.has(edgeId(e.from, e.type, e.to))) {
           store2.closeEdge(e.id, t);
           delta.edgesRemoved++;
         } else if (e.createdAt >= t) {
@@ -17156,8 +17744,8 @@ async function incrementalReindex(store2, rootPath, workspaceId, changedAbsPaths
             version: b.version + 1
           });
           store2.mergeEdge(continuesEdge(m, t));
-          for (const e of store2.inEdges(m.fromNid, ["CALLS", "ACCESSES", "ANCHORED_AT"])) {
-            if (e.validTo != null) continue;
+          for (const e of repointable.get(m.fromNid) ?? []) {
+            if (e.from === m.fromNid || !store2.liveNodeIds([e.from]).has(e.from)) continue;
             const newId = edgeId(e.from, e.type, m.toNid);
             if (!store2.getEdge(newId)) {
               store2.mergeEdge({ ...e, id: newId, to: m.toNid, lastSeenAt: t });
@@ -17214,6 +17802,7 @@ async function runIndexer(store2, opts) {
   const maxBytes = opts.maxFileBytes ?? 1024 * 1024;
   const scope = opts.changedRelPaths;
   const inScope = (relPath) => scope === void 0 || scope.has(relPath) || isReExportBarrel(relPath);
+  const emits = (relPath) => scope === void 0 || scope.has(relPath);
   let perfLast = started;
   const perfFile = process.env["ERRATA_PERF"];
   const perf = (label) => {
@@ -17265,7 +17854,7 @@ async function runIndexer(store2, opts) {
     upsertFolder(store2, rootId, ".", opts.workspaceId, rootRel);
     report.nodesEmitted++;
     for (const f of files) {
-      if (!inScope(f.relPath)) continue;
+      if (!emits(f.relPath)) continue;
       const segments = f.relPath.split(/[\\/]/).slice(0, -1);
       let parentId = rootId;
       let acc = "";
@@ -17348,7 +17937,13 @@ async function runIndexer(store2, opts) {
     }
   }
   perf(`parse (${report.filesParsed} parsed, ${report.filesSkipped} skipped)`);
-  const exportsByFile = /* @__PURE__ */ new Map();
+  const pendingExports = /* @__PURE__ */ new Set();
+  const exportsByFile = new class extends Map {
+    get(relPath) {
+      if (pendingExports.delete(relPath)) super.set(relPath, graphExportMap(store2, opts.workspaceId, relPath));
+      return super.get(relPath);
+    }
+  }();
   const importsByFile = /* @__PURE__ */ new Map();
   for (const [relPath, symbols] of symbolsByFile) {
     const localExports = /* @__PURE__ */ new Map();
@@ -17372,7 +17967,8 @@ async function runIndexer(store2, opts) {
   if (scope !== void 0) {
     for (const f of files) {
       if (inScope(f.relPath) || exportsByFile.has(f.relPath)) continue;
-      exportsByFile.set(f.relPath, graphExportMap(store2, opts.workspaceId, f.relPath));
+      exportsByFile.set(f.relPath, /* @__PURE__ */ new Map());
+      pendingExports.add(f.relPath);
     }
   }
   const workspacePackages = /* @__PURE__ */ new Map();
@@ -17513,6 +18109,7 @@ async function runIndexer(store2, opts) {
   const providerByRel = new Map(files.map((x) => [x.relPath, x.provider]));
   let emittedFiles = 0;
   for (const [relPath, symbols] of symbolsByFile) {
+    if (!emits(relPath)) continue;
     if (emittedFiles > 0 && emittedFiles % 50 === 0) {
       await new Promise((r) => setImmediate(r));
     }
@@ -17714,9 +18311,10 @@ async function runIndexer(store2, opts) {
       if (ei > 0) await new Promise((r) => setImmediate(r));
       const slice = pendingEdges.slice(ei, ei + EDGE_BATCH);
       store2.transaction(() => {
+        const present = store2.nodeLabels([...new Set(slice.flatMap((e) => [e.from, e.to]))]);
         for (const e of slice) {
           if (e.from === e.to) continue;
-          if (!store2.getNode(e.from) || !store2.getNode(e.to)) continue;
+          if (!present.has(e.from) || !present.has(e.to)) continue;
           upsertEdge(
             store2,
             e.from,
@@ -17732,6 +18330,7 @@ async function runIndexer(store2, opts) {
   }
   perf("flush cross-file edges");
   for (const relPath of symbolsByFile.keys()) {
+    if (!emits(relPath)) continue;
     const fid = fileNodeId(opts.workspaceId, relPath);
     if (store2.outEdges(fid, ["DEFINES", "CONTAINS"]).length === 0) {
       stampIndexOutcome(store2, fid, { symbolCount: 0 });
@@ -18328,14 +18927,14 @@ function unmarshalNode(tree, address = TRANSFER_BUFFER) {
   address += SIZE_OF_INT;
   const row = C.getValue(address, "i32");
   address += SIZE_OF_INT;
-  const column = C.getValue(address, "i32");
+  const column2 = C.getValue(address, "i32");
   address += SIZE_OF_INT;
   const other = C.getValue(address, "i32");
   const result = new Node(INTERNAL, {
     id,
     tree,
     startIndex: index,
-    startPosition: { row, column },
+    startPosition: { row, column: column2 },
     other
   });
   return result;
@@ -18425,11 +19024,11 @@ async function Module2(moduleArg = {}) {
   }, "quit_");
   var _scriptName = import.meta.url;
   var scriptDirectory = "";
-  function locateFile(path) {
+  function locateFile(path2) {
     if (Module["locateFile"]) {
-      return Module["locateFile"](path, scriptDirectory);
+      return Module["locateFile"](path2, scriptDirectory);
     }
-    return scriptDirectory + path;
+    return scriptDirectory + path2;
   }
   __name(locateFile, "locateFile");
   var readAsync, readBinary;
@@ -19581,11 +20180,11 @@ async function Module2(moduleArg = {}) {
     }
   }
   __name(_tree_sitter_log_callback, "_tree_sitter_log_callback");
-  function _tree_sitter_parse_callback(inputBufferAddress, index, row, column, lengthAddress) {
+  function _tree_sitter_parse_callback(inputBufferAddress, index, row, column2, lengthAddress) {
     const INPUT_BUFFER_SIZE = 10 * 1024;
     const string4 = Module.currentParseCallback(index, {
       row,
-      column
+      column: column2
     });
     if (typeof string4 === "string") {
       setValue(lengthAddress, string4.length, "i32");
@@ -23249,10 +23848,10 @@ function collectDocstrings(root, records, out2) {
     }
   }
 }
-function docstringIn(stmt) {
-  if (!stmt) return null;
-  if (stmt.type !== "expression_statement") return null;
-  const expr = stmt.namedChild(0);
+function docstringIn(stmt2) {
+  if (!stmt2) return null;
+  if (stmt2.type !== "expression_statement") return null;
+  const expr = stmt2.namedChild(0);
   if (!expr) return null;
   if (expr.type !== "string") return null;
   const text = expr.text;
@@ -23523,9 +24122,9 @@ function extractNode3(node, containerQname, containerIsClass, source) {
       ];
     }
     case "preproc_include": {
-      const path = node.childForFieldName("path")?.text;
-      if (!path) return [];
-      const src = path.replace(/^[<"]|[>"]$/g, "");
+      const path2 = node.childForFieldName("path")?.text;
+      if (!path2) return [];
+      const src = path2.replace(/^[<"]|[>"]$/g, "");
       return [
         {
           kind: "import",
@@ -23913,9 +24512,9 @@ function importRecords(node) {
     if (n.type === "import_spec") specs.push(n);
   });
   for (const spec of specs) {
-    const path = spec.childForFieldName("path")?.text;
-    if (!path) continue;
-    const src = path.replace(/^["`]|["`]$/g, "");
+    const path2 = spec.childForFieldName("path")?.text;
+    if (!path2) continue;
+    const src = path2.replace(/^["`]|["`]$/g, "");
     out2.push({
       kind: "import",
       name: src,
@@ -24998,16 +25597,16 @@ function baseTypeName(node) {
 }
 function usingPath(node) {
   const alias = node.childForFieldName("name");
-  let path = null;
+  let path2 = null;
   for (let i2 = 0; i2 < node.namedChildCount; i2++) {
     const c = node.namedChild(i2);
     if (!c) continue;
     if (alias && c.startIndex === alias.startIndex && c.endIndex === alias.endIndex) continue;
     if (c.type === "qualified_name" || c.type === "identifier" || c.type === "generic_name") {
-      path = c;
+      path2 = c;
     }
   }
-  return path?.text ?? null;
+  return path2?.text ?? null;
 }
 function calleeName4(fn) {
   if (!fn) return null;
@@ -25274,6 +25873,110 @@ import { parentPort, workerData } from "node:worker_threads";
 init_src2();
 init_src();
 
+// ../../packages/local-graph/src/wm-calibration.ts
+var WM_CALIBRATION_LABELS = [
+  "Problem",
+  "Solution",
+  "RootCause",
+  "Pattern",
+  "Technique",
+  "AntiPattern"
+];
+var WM_CALIBRATION_SCHEMA = 2;
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var WM_CALIBRATION_KEYS = [
+  "shownCount",
+  "evictedCount",
+  "reinforceShownCount",
+  "reinforceRecentCount",
+  "reinforceEvictedCount",
+  "reinforceUnshownCount",
+  "reinforceUnshownQueryOnlyCount"
+];
+var WM_COUNTED_PREDICATE = WM_CALIBRATION_KEYS.map((k) => `json_type(attrs_json, '$.${k}') IS NOT NULL`).join(" OR ");
+var wmCounterSql = (k) => `CASE WHEN json_type(attrs_json, '$.${k}') IN ('integer', 'real') THEN json_extract(attrs_json, '$.${k}') END`;
+function wmCalibrationCells(store2) {
+  const cells = {
+    calibrationSchema: WM_CALIBRATION_SCHEMA,
+    shownNodes: 0,
+    shownImpressions: 0,
+    evictedNodes: 0,
+    evictedImpressions: 0,
+    reinforceShown: 0,
+    reinforceRecent: 0,
+    reinforceEvicted: 0,
+    reinforceUnshown: 0,
+    reinforceUnshownQueryOnly: 0,
+    reinforcedNodes: 0,
+    reinforcedShownNodes: 0
+  };
+  const newest = /* @__PURE__ */ new Map();
+  const rows = store2.wmCalibrationRows?.(WM_CALIBRATION_LABELS) ?? (function* () {
+    for (const label of WM_CALIBRATION_LABELS) {
+      yield* store2.selectNodes({ labels: [label], attrs: WM_CALIBRATION_KEYS, includeClosed: true });
+    }
+  })();
+  for (const n of rows) {
+    const live = n.validTo === null;
+    const prev = newest.get(n.logicalId);
+    if (prev && (prev.live || !live && prev.version >= n.version)) continue;
+    newest.set(n.logicalId, { version: n.version, live, attrs: n.attrs });
+  }
+  for (const { attrs } of newest.values()) {
+    const shown = num(attrs["shownCount"]);
+    const evicted = num(attrs["evictedCount"]);
+    if (shown > 0) {
+      cells.shownNodes++;
+      cells.shownImpressions += shown;
+    }
+    if (evicted > 0) {
+      cells.evictedNodes++;
+      cells.evictedImpressions += evicted;
+    }
+    const rs = num(attrs["reinforceShownCount"]);
+    const rr = num(attrs["reinforceRecentCount"]);
+    const re = num(attrs["reinforceEvictedCount"]);
+    const ru = num(attrs["reinforceUnshownCount"]);
+    cells.reinforceShown += rs;
+    cells.reinforceRecent += rr;
+    cells.reinforceEvicted += re;
+    cells.reinforceUnshown += ru;
+    cells.reinforceUnshownQueryOnly += num(attrs["reinforceUnshownQueryOnlyCount"]);
+    if (rs + rr + re + ru > 0) cells.reinforcedNodes++;
+    if (rs > 0) cells.reinforcedShownNodes++;
+  }
+  return cells;
+}
+
+// ../../packages/local-graph/src/exposure-attrs.ts
+var EXPOSURE_ATTRS = [
+  "shownCount",
+  "evictedCount",
+  "firstShownAt",
+  "firstEvictedAt",
+  "firstShownAtSeq",
+  "lastShownAtSeq",
+  "lastEvictedAtSeq",
+  "shownSinceTouch",
+  "shownSinceTouchAt",
+  "exposureLog",
+  "exposureLogStart",
+  "exposureLogSince",
+  "exposureFirst",
+  "exposureTrimmed"
+];
+var EXPOSURE_SCOPE = "exposure";
+var EXPOSURE_KEYS = new Set(EXPOSURE_ATTRS);
+var isExposureAttr = (key) => EXPOSURE_KEYS.has(key);
+function pickExposure(attrs) {
+  const out2 = {};
+  for (const k of EXPOSURE_ATTRS) if (attrs[k] !== void 0) out2[k] = attrs[k];
+  return out2;
+}
+function exposureDocSql(key) {
+  return `coalesce((SELECT x.attrs_json FROM node_exposure x WHERE x.id = nodes.id AND json_type(x.attrs_json, '$.${key}') IS NOT NULL), attrs_json)`;
+}
+
 // ../../packages/local-graph/src/history-cache-floor.ts
 var HISTORY_CACHE_FLOOR_KEY = "history-cache-withdrawal-floor-3";
 function installHistoryCacheFloor(db) {
@@ -25314,7 +26017,7 @@ function installHistoryCacheFloor(db) {
         OR EXISTS(SELECT 1 FROM history_cache_withdrawals w WHERE w.id = nodes.id))
       AND (embedding_blob IS NOT NULL OR embedding_json <> '[]' OR is_landmark <> 0
         OR description <> ${description} OR attrs_json <> ${attrs});`;
-    const internal = `key IN ('orgId','teamId','groupId','projectId','aliasTexts','aliasCanonicalIds')
+    const internal = `key IN ('orgId','teamId','groupId','projectId','aliasTexts','aliasCanonicalIds','residueAudienceVerified')
       OR key GLOB 'mergedFrom*' OR key GLOB '*WitnessKeys' OR key GLOB '*Sessions'
       OR key GLOB 'authoringSession*' OR key GLOB 'contributor*' OR key GLOB 'witnessKeys*'`;
     const stripMetadata = (scope) => `UPDATE nodes SET attrs_json=(
@@ -25450,7 +26153,9 @@ function installEditPlaceholderRetirement(db) {
 
 // ../../packages/local-graph/src/cloud-attr-compaction.ts
 init_src2();
-var CLOUD_ATTR_COMPACTION_KEY = "cloud-attr-compaction-1";
+var CLOUD_ATTR_COMPACTION_KEY = "cloud-attr-compaction-2";
+var V1_KEY = "cloud-attr-compaction-1";
+var STRUCT_LABELS = "('Problem', 'Solution', 'RootCause')";
 var DUPES = CLOUD_ATTR_DUPLICATE_KEYS.map((k) => `'${k}'`).join(",");
 function compacted(row) {
   const packed = `json_extract(${row}.attrs_json, '$.attrsJson')`;
@@ -25469,14 +26174,17 @@ function dirty(row) {
   return `json_extract(${row}.attrs_json, '$.source') = 'cloud' AND (${has})`;
 }
 function installCloudAttrCompaction(db) {
-  if (db.prepare("SELECT value FROM store_meta WHERE key = ?").get(CLOUD_ATTR_COMPACTION_KEY)) return;
+  const marked = (key) => Boolean(db.prepare("SELECT value FROM store_meta WHERE key = ?").get(key));
+  if (marked(CLOUD_ATTR_COMPACTION_KEY)) return;
+  const scope = marked(V1_KEY) ? ` AND label IN ${STRUCT_LABELS}` : "";
   db.transaction(() => {
     for (const operation of ["INSERT", "UPDATE"]) {
-      db.exec(`CREATE TRIGGER IF NOT EXISTS cloud_attr_compact_${operation.toLowerCase()}
+      db.exec(`DROP TRIGGER IF EXISTS cloud_attr_compact_${operation.toLowerCase()}`);
+      db.exec(`CREATE TRIGGER cloud_attr_compact_${operation.toLowerCase()}
         AFTER ${operation} ON nodes WHEN ${dirty("NEW")}
         BEGIN UPDATE nodes SET attrs_json = ${compacted("nodes")} WHERE id = NEW.id; END;`);
     }
-    db.exec(`UPDATE nodes SET attrs_json = ${compacted("nodes")} WHERE ${dirty("nodes")}`);
+    db.exec(`UPDATE nodes SET attrs_json = ${compacted("nodes")} WHERE ${dirty("nodes")}${scope}`);
     db.prepare("INSERT INTO store_meta(key,value) VALUES (?,?)").run(CLOUD_ATTR_COMPACTION_KEY, "installed");
   });
 }
@@ -25515,6 +26223,313 @@ function installHistoryAttrSlim(db) {
   db.prepare("INSERT INTO store_meta(key,value) VALUES (?,?)").run(HISTORY_ATTR_SLIM_KEY, "done");
 }
 
+// ../../packages/local-graph/src/text-index.ts
+var TEXT_INDEX_KEY = "text-index-trigram-2";
+var TEXT_INDEX_MIN_TERM = 3;
+function installTextIndex(db) {
+  if (db.prepare("SELECT value FROM store_meta WHERE key = ?").get(TEXT_INDEX_KEY)) return;
+  try {
+    db.exec(`CREATE VIRTUAL TABLE temp.fts5_probe USING fts5(x, tokenize='trigram'); DROP TABLE temp.fts5_probe`);
+  } catch {
+    db.prepare("INSERT INTO store_meta(key,value) VALUES (?,?)").run(TEXT_INDEX_KEY, "unavailable");
+    return;
+  }
+  db.transaction(() => {
+    db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS nodes_text
+      USING fts5(description, content='nodes', content_rowid='rowid', tokenize='trigram')`);
+    db.exec(`DROP TRIGGER IF EXISTS nodes_text_update_out; DROP TRIGGER IF EXISTS nodes_text_update_in;
+      DROP TRIGGER IF EXISTS nodes_text_update`);
+    db.exec(`CREATE TRIGGER IF NOT EXISTS nodes_text_insert AFTER INSERT ON nodes WHEN NEW.valid_to IS NULL
+      BEGIN INSERT INTO nodes_text(rowid, description) VALUES (NEW.rowid, NEW.description); END;`);
+    db.exec(`CREATE TRIGGER nodes_text_update AFTER UPDATE OF description, valid_to ON nodes
+      WHEN OLD.description IS NOT NEW.description OR OLD.valid_to IS NOT NEW.valid_to
+      BEGIN
+        INSERT INTO nodes_text(nodes_text, rowid, description)
+          SELECT 'delete', OLD.rowid, OLD.description WHERE OLD.valid_to IS NULL;
+        INSERT INTO nodes_text(rowid, description)
+          SELECT NEW.rowid, NEW.description WHERE NEW.valid_to IS NULL;
+      END;`);
+    db.exec(`CREATE TRIGGER IF NOT EXISTS nodes_text_delete AFTER DELETE ON nodes WHEN OLD.valid_to IS NULL
+      BEGIN INSERT INTO nodes_text(nodes_text, rowid, description) VALUES ('delete', OLD.rowid, OLD.description); END;`);
+    db.exec(`INSERT INTO nodes_text(nodes_text) VALUES ('delete-all')`);
+    db.exec(`INSERT INTO nodes_text(rowid, description) SELECT rowid, description FROM nodes WHERE valid_to IS NULL`);
+    db.prepare("INSERT OR REPLACE INTO store_meta(key,value) VALUES (?,?)").run("text-index-trigram-1", "installed");
+    db.prepare("INSERT INTO store_meta(key,value) VALUES (?,?)").run(TEXT_INDEX_KEY, "installed");
+  });
+}
+function textIndexReady(db) {
+  return db.prepare("SELECT value FROM store_meta WHERE key = ?").get(TEXT_INDEX_KEY)?.["value"] === "installed";
+}
+
+// ../../packages/local-graph/src/change-feed.ts
+var CHANGE_FEED_KEY = "change-feed";
+var ANY_CHANGE = "*";
+var nodeScope = (label) => `node:${label}`;
+var CHANGE_LOG_KEEP = 25e4;
+var PRUNED_TO_KEY = "change-log-pruned-to";
+function installChangeFeed(db) {
+  if (changeFeedInstalled(db)) return;
+  db.transaction(() => {
+    db.exec("CREATE TABLE IF NOT EXISTS change_seq (scope TEXT PRIMARY KEY, seq INTEGER NOT NULL) WITHOUT ROWID");
+    db.exec(`CREATE TABLE IF NOT EXISTS change_log (change_seq INTEGER PRIMARY KEY, kind TEXT NOT NULL, id TEXT NOT NULL,
+      label TEXT, from_id TEXT, to_id TEXT)`);
+    for (const name2 of ["nodes", "edges"].flatMap((t) => ["insert", "update", "delete"].map((op) => `change_feed_${t}_${op}`))) {
+      db.exec(`DROP TRIGGER IF EXISTS ${name2}`);
+    }
+    const changed = (table) => columns(db, table).map((c) => `OLD."${c}" IS NOT NEW."${c}"`).join(" OR ");
+    const strip = (row) => `json_remove(${row}.attrs_json, ${EXPOSURE_ATTRS.map((a) => `'$.${a}'`).join(", ")})`;
+    const exposureOnly = `(${columns(db, "nodes").filter((c) => c !== "attrs_json").map((c) => `OLD."${c}" IS NEW."${c}"`).join(" AND ")}
+      AND CASE WHEN json_valid(OLD.attrs_json) AND json_valid(NEW.attrs_json) THEN ${strip("OLD")} IS ${strip("NEW")} ELSE 0 END)`;
+    const bump = (...scopes) => `INSERT INTO change_seq(scope, seq) VALUES ${scopes.map((s) => `(${s}, 1)`).join(", ")}
+      ON CONFLICT(scope) DO UPDATE SET seq = seq + 1;`;
+    const seq = `(SELECT seq FROM change_seq WHERE scope = '*')`;
+    const logNode = (row) => `INSERT INTO change_log(change_seq, kind, id, label) VALUES (${seq}, 'node', ${row}.id, ${row}.label);`;
+    const logEdge = (row) => `INSERT INTO change_log(change_seq, kind, id, label, from_id, to_id) VALUES (${seq}, 'edge', ${row}.id, ${row}.type, ${row}.from_id, ${row}.to_id);`;
+    const node = (row) => `'node:' || ${row}.label`;
+    const edge = (row) => `'edge:' || ${row}.type`;
+    db.exec(`CREATE TRIGGER change_feed_nodes_insert AFTER INSERT ON nodes BEGIN ${bump(`'*'`, node("NEW"))} ${logNode("NEW")} END;`);
+    db.exec(`CREATE TRIGGER change_feed_nodes_update AFTER UPDATE ON nodes WHEN ${changed("nodes")} BEGIN
+      ${bump(`'*'`)}
+      INSERT INTO change_seq(scope, seq) SELECT CASE WHEN ${exposureOnly} THEN '${EXPOSURE_SCOPE}' ELSE ${node("NEW")} END, 1 WHERE 1
+        ON CONFLICT(scope) DO UPDATE SET seq = seq + 1;
+      INSERT INTO change_seq(scope, seq) SELECT ${node("OLD")}, 1 WHERE OLD.label IS NOT NEW.label
+        ON CONFLICT(scope) DO UPDATE SET seq = seq + 1;
+      ${logNode("NEW")}
+    END;`);
+    db.exec(`CREATE TRIGGER change_feed_nodes_delete AFTER DELETE ON nodes BEGIN ${bump(`'*'`, node("OLD"))} ${logNode("OLD")} END;`);
+    db.exec(`CREATE TRIGGER change_feed_edges_insert AFTER INSERT ON edges BEGIN ${bump(`'*'`, edge("NEW"))} ${logEdge("NEW")} END;`);
+    db.exec(`CREATE TRIGGER change_feed_edges_update AFTER UPDATE ON edges WHEN ${changed("edges")} BEGIN
+      ${bump(`'*'`, edge("NEW"))}
+      INSERT INTO change_seq(scope, seq) SELECT ${edge("OLD")}, 1 WHERE OLD.type IS NOT NEW.type
+        ON CONFLICT(scope) DO UPDATE SET seq = seq + 1;
+      ${logEdge("NEW")}
+    END;`);
+    db.exec(`CREATE TRIGGER change_feed_edges_delete AFTER DELETE ON edges BEGIN ${bump(`'*'`, edge("OLD"))} ${logEdge("OLD")} END;`);
+    db.prepare("INSERT OR REPLACE INTO store_meta(key, value) VALUES (?, ?)").run(PRUNED_TO_KEY, String(readChangeSeq(db)));
+    db.prepare("INSERT OR REPLACE INTO store_meta(key, value) VALUES (?, ?)").run(CHANGE_FEED_KEY, columnSignature(db));
+  });
+}
+function readChangeSeq(db, scopes = [ANY_CHANGE]) {
+  if (!scopes.length) return 0;
+  const row = db.prepare(`SELECT coalesce(sum(seq), 0) AS n FROM change_seq WHERE scope IN (${scopes.map(() => "?").join(",")})`).get(...scopes);
+  return Number(row?.n ?? 0);
+}
+function changeLogCovers(db, sinceSeq) {
+  const prunedTo = Number(db.prepare("SELECT value FROM store_meta WHERE key = ?").get(PRUNED_TO_KEY)?.["value"] ?? NaN);
+  return Number.isFinite(prunedTo) && sinceSeq >= prunedTo;
+}
+function readChangedNodeIds(db, sinceSeq, labels) {
+  if (!changeLogCovers(db, sinceSeq)) return null;
+  if (!labels.length) return [];
+  const rows = db.prepare(`SELECT DISTINCT id FROM change_log WHERE change_seq > ? AND kind = 'node' AND label IN (${labels.map(() => "?").join(",")})`).all(sinceSeq, ...labels);
+  return rows.map((r) => r.id);
+}
+function readChangedAmong(db, sinceSeq, ids) {
+  if (!changeLogCovers(db, sinceSeq)) return null;
+  const out2 = [];
+  for (let i2 = 0; i2 < ids.length; i2 += 500) {
+    const chunk = ids.slice(i2, i2 + 500);
+    const rows = db.prepare(`SELECT DISTINCT id FROM change_log WHERE change_seq > ? AND kind = 'node' AND id IN (${chunk.map(() => "?").join(",")})`).all(sinceSeq, ...chunk);
+    for (const r of rows) out2.push(r.id);
+  }
+  return out2;
+}
+function readLineageChangedFiles(db, sinceSeq) {
+  if (!changeLogCovers(db, sinceSeq)) return null;
+  const rows = db.prepare(LINEAGE_CHANGED_FILES_SQL).all({ s: sinceSeq });
+  return rows.map((r) => r.id);
+}
+var LINEAGE_CHANGED_FILES_SQL = `
+  SELECT id FROM change_log WHERE change_seq > :s AND kind = 'node' AND label = 'File'
+  UNION SELECT from_id FROM change_log WHERE change_seq > :s AND kind = 'edge' AND label IN ('DEFINES','CONTAINS')
+  UNION SELECT e.from_id FROM (SELECT DISTINCT id FROM change_log WHERE change_seq > :s AND kind = 'node') c
+    CROSS JOIN edges e ON e.to_id = c.id AND e.type IN ('DEFINES','CONTAINS')
+`;
+function pruneChangeLog(db) {
+  const max = Number(db.prepare("SELECT coalesce(max(change_seq), 0) AS n FROM change_log").get()?.["n"] ?? 0);
+  const cut = max - CHANGE_LOG_KEEP;
+  if (cut <= 0) return 0;
+  let removed = 0;
+  db.transaction(() => {
+    removed = Number(db.prepare("DELETE FROM change_log WHERE change_seq <= ?").run(cut).changes);
+    const prev = Number(db.prepare("SELECT value FROM store_meta WHERE key = ?").get(PRUNED_TO_KEY)?.["value"] ?? 0);
+    db.prepare("INSERT OR REPLACE INTO store_meta(key, value) VALUES (?, ?)").run(PRUNED_TO_KEY, String(Math.max(prev, cut)));
+  });
+  return removed;
+}
+function changeFeedInstalled(db) {
+  return db.prepare("SELECT value FROM store_meta WHERE key = ?").get(CHANGE_FEED_KEY)?.["value"] === columnSignature(db);
+}
+function columns(db, table) {
+  return db.prepare(`SELECT name FROM pragma_table_info('${table}') ORDER BY cid`).all().map((r) => r.name);
+}
+function columnSignature(db) {
+  return `5|${columns(db, "nodes").join(",")}|${columns(db, "edges").join(",")}|${EXPOSURE_ATTRS.join(",")}`;
+}
+
+// ../../packages/local-graph/src/lineage-integrity.ts
+var statements = /* @__PURE__ */ new WeakMap();
+function stmt(db, sql) {
+  let byDb = statements.get(db);
+  if (!byDb) statements.set(db, byDb = /* @__PURE__ */ new Map());
+  let s = byDb.get(sql);
+  if (!s) byDb.set(sql, s = db.prepare(sql));
+  return s;
+}
+var HISTORY_EDGE_TYPES = [
+  "SUPERSEDED_BY",
+  "CONTINUES",
+  "FORKED_FROM",
+  "REGRESSION_OF",
+  "SPLIT_INTO",
+  "REVEALED_BY"
+];
+var LINEAGE_INTEGRITY_KEY = "lineage-integrity-v1";
+var HISTORY_SQL = HISTORY_EDGE_TYPES.map((t) => `'${t}'`).join(",");
+var NOT_HISTORY = `type NOT IN (${HISTORY_SQL})`;
+var NOT_HISTORICAL_ROW = `json_type(attrs_json, '$.historical') IS NOT 'true'`;
+var RETAINS_EDGES = (n) => `(${n}.label = 'Problem'
+  AND json_type(${n}.attrs_json, '$.resolvedAt') IS NOT NULL
+  AND COALESCE(json_extract(${n}.attrs_json, '$.resolvedAs'), '') NOT IN ('duplicate', 'false_positive'))`;
+var PRESENT = (n) => `(${n}.valid_to IS NULL OR ${RETAINS_EDGES(n)})`;
+var STRANDED_EDGE_PREDICATE = `e.valid_to IS NULL AND e.${NOT_HISTORY}
+  AND (NOT EXISTS (SELECT 1 FROM nodes f WHERE f.id = e.from_id AND ${PRESENT("f")})
+    OR NOT EXISTS (SELECT 1 FROM nodes t WHERE t.id = e.to_id AND ${PRESENT("t")}))`;
+function countStrandedEdges(db) {
+  const rows = db.prepare(`SELECT e.type AS type, count(*) AS n FROM edges e WHERE ${STRANDED_EDGE_PREDICATE} GROUP BY e.type ORDER BY n DESC`).all();
+  const byType = {};
+  let total = 0;
+  for (const r of rows) {
+    byType[r.type] = Number(r.n);
+    total += Number(r.n);
+  }
+  return { total, byType };
+}
+function countLiveHeadConflicts(db) {
+  const row = db.prepare(
+    `SELECT count(*) AS n FROM (
+         SELECT COALESCE(logical_id, id) AS lid FROM nodes
+         WHERE valid_to IS NULL AND ${NOT_HISTORICAL_ROW}
+         GROUP BY lid HAVING count(*) > 1)`
+  ).get();
+  return Number(row?.n ?? 0);
+}
+function closeIncidentEdges(db, id, t) {
+  let closed = 0;
+  for (const side of ["from_id", "to_id"]) {
+    const r = stmt(db, `UPDATE edges SET valid_to = MAX(valid_from, ?) WHERE ${side} = ? AND valid_to IS NULL AND ${NOT_HISTORY}`).run(t, id);
+    closed += Number(r.changes);
+  }
+  return closed;
+}
+function reopenCascadeClosedEdges(db, id, closedAt) {
+  let reopened = 0;
+  for (const [side, other] of [["from_id", "to_id"], ["to_id", "from_id"]]) {
+    const r = stmt(
+      db,
+      `UPDATE edges SET valid_to = NULL
+       WHERE ${side} = ? AND valid_to = ? AND ${NOT_HISTORY}
+         AND EXISTS (SELECT 1 FROM nodes o WHERE o.id = edges.${other} AND o.valid_to IS NULL)`
+    ).run(id, closedAt);
+    reopened += Number(r.changes);
+  }
+  return reopened;
+}
+function collapseLiveHeads(db, logicalIds, t) {
+  const headsOf = db.prepare(
+    `SELECT id, version, valid_from FROM (
+       SELECT id, version, valid_from, attrs_json FROM nodes WHERE logical_id = ?1 AND valid_to IS NULL
+       UNION
+       SELECT id, version, valid_from, attrs_json FROM nodes WHERE id = ?1 AND logical_id IS NULL AND valid_to IS NULL
+     ) WHERE ${NOT_HISTORICAL_ROW}`
+  );
+  const continuesInto = db.prepare(
+    `SELECT to_id FROM edges WHERE from_id = ? AND type = 'CONTINUES' AND valid_to IS NULL`
+  );
+  const rekeyHead = db.prepare(`UPDATE nodes SET logical_id = ?1 WHERE id = ?1`);
+  const rekeyCopies = db.prepare(
+    `UPDATE nodes SET logical_id = ?1 WHERE logical_id = ?2 AND substr(id, 1, length(?1) + 2) = ?1 || '@v'`
+  );
+  const lineageMembers = db.prepare(
+    `SELECT id FROM nodes WHERE logical_id = ?1 UNION SELECT id FROM nodes WHERE id = ?1`
+  );
+  const closeContinues = db.prepare(
+    `UPDATE edges SET valid_to = MAX(valid_from, ?) WHERE from_id = ? AND to_id = ? AND type = 'CONTINUES' AND valid_to IS NULL`
+  );
+  let split = 0;
+  const queue = [...new Set(logicalIds)];
+  for (let i2 = 0; i2 < queue.length; i2++) {
+    const lid = queue[i2];
+    const heads = headsOf.all(lid);
+    if (heads.length < 2) continue;
+    const members = new Set(lineageMembers.all(lid).map((r) => r.id));
+    const splitOff = (h) => {
+      for (const { to_id } of continuesInto.all(h.id)) {
+        if (members.has(to_id)) closeContinues.run(t, h.id, to_id);
+      }
+      rekeyHead.run(h.id);
+      rekeyCopies.run(h.id, lid);
+      queue.push(h.id);
+      split++;
+    };
+    const kept = new Set(heads.map((h) => h.id));
+    for (const h of heads) {
+      if (h.id === lid) continue;
+      const refuted = continuesInto.all(h.id).some(
+        (e) => e.to_id !== h.id && kept.has(e.to_id)
+      );
+      if (refuted && kept.size > 1) {
+        splitOff(h);
+        kept.delete(h.id);
+      }
+    }
+    let remaining = heads.filter((h) => kept.has(h.id));
+    if (remaining.length < 2) continue;
+    remaining = [...remaining].sort(
+      (a, b) => Number(b.id === lid) - Number(a.id === lid) || Number(b.version) - Number(a.version) || Number(b.valid_from) - Number(a.valid_from) || (a.id < b.id ? -1 : 1)
+    );
+    for (const h of remaining.slice(1)) splitOff(h);
+  }
+  return split;
+}
+function repairLineageIntegrity(db, now) {
+  const historicalRowsClosed = Number(
+    db.prepare(
+      `UPDATE nodes SET valid_to = MAX(valid_from, COALESCE(
+           (SELECT s.valid_from FROM edges s WHERE s.id = 'edge_superseded_' || nodes.id), ?))
+         WHERE valid_to IS NULL AND json_type(attrs_json, '$.historical') = 'true'`
+    ).run(now).changes
+  );
+  const conflicted = db.prepare(
+    `SELECT COALESCE(logical_id, id) AS lid FROM nodes
+         WHERE valid_to IS NULL AND ${NOT_HISTORICAL_ROW}
+         GROUP BY lid HAVING count(*) > 1`
+  ).all().map((r) => r.lid);
+  const headsSplit = collapseLiveHeads(db, conflicted, now);
+  const strandedEdgesClosed = Number(
+    db.prepare(
+      `UPDATE edges SET valid_to = MAX(valid_from, COALESCE(
+           (SELECT min(v) FROM (
+              SELECT f.valid_to AS v FROM nodes f WHERE f.id = edges.from_id AND NOT ${PRESENT("f")}
+              UNION ALL
+              SELECT t.valid_to FROM nodes t WHERE t.id = edges.to_id AND NOT ${PRESENT("t")})), ?))
+         WHERE id IN (SELECT e.id FROM edges e WHERE ${STRANDED_EDGE_PREDICATE})`
+    ).run(now).changes
+  );
+  return { historicalRowsClosed, headsSplit, strandedEdgesClosed };
+}
+function installLineageIntegrityRepair(db, now = Date.now()) {
+  if (db.prepare("SELECT value FROM store_meta WHERE key = ?").get(LINEAGE_INTEGRITY_KEY)) return null;
+  return db.transaction(() => {
+    const report = repairLineageIntegrity(db, now);
+    db.prepare("INSERT OR REPLACE INTO store_meta (key, value) VALUES (?, ?)").run(
+      LINEAGE_INTEGRITY_KEY,
+      JSON.stringify({ at: now, ...report })
+    );
+    return report;
+  });
+}
+
 // ../../packages/math/src/pagerank.ts
 function pagerank(input) {
   const damping = input.damping ?? 0.85;
@@ -25961,6 +26976,177 @@ function pagerankLocal(input) {
   return { scores, iterations: iter, converged };
 }
 
+// ../../packages/local-graph/src/node-select.ts
+var SELECT_INDEXES = [
+  "nodes_live_local_community",
+  "nodes_live_fold_candidate",
+  "nodes_live_resolved",
+  "nodes_live_fix_candidate",
+  "nodes_live_anchor_hint"
+];
+var EMBEDDING_DIM_SQL = "(CASE WHEN length(embedding_blob) >= 4 THEN length(embedding_blob) / 4 ELSE COALESCE(json_array_length(embedding_json), 0) END)";
+var KEY = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
+var COLUMNS = /* @__PURE__ */ new Set([
+  "created_at",
+  "last_updated_at",
+  "page_rank",
+  "created_at_seq",
+  "last_reinforced_at_seq",
+  "cumulative_hits",
+  "extraction_confidence"
+]);
+function path(key) {
+  if (!KEY.test(key)) throw new Error(`selectNodes: bad attr key ${key}`);
+  return `'$.${key}'`;
+}
+function selectIndex(i2) {
+  if (!SELECT_INDEXES.includes(i2)) throw new Error(`selectNodes: bad index ${i2}`);
+  return i2;
+}
+function column(c) {
+  if (!COLUMNS.has(c)) throw new Error(`selectNodes: bad column ${c}`);
+  return c;
+}
+function compileNodeWhere(q) {
+  if (q.labels.length === 0) throw new Error("selectNodes: no labels");
+  const params = [...q.labels];
+  const byId = (q.where ?? []).some((w) => "idIn" in w || "idPrefix" in w && w.idPrefix.length > 0);
+  const unindexed = byId ? "+" : "";
+  const conds = [`${unindexed}label IN (${q.labels.map(() => "?").join(", ")})`];
+  if (!q.includeClosed) conds.push(`${unindexed}valid_to IS NULL`);
+  for (const w of q.where ?? []) {
+    if ("embedding" in w) {
+      conds.push(`${EMBEDDING_DIM_SQL} ${w.embedding === "present" ? ">" : "="} 0`);
+    } else if ("idPrefix" in w) {
+      conds.push("substr(id, 1, ?) = ?");
+      params.push(w.idPrefix.length, w.idPrefix);
+      if (w.idPrefix.length > 0) {
+        const last = w.idPrefix.charCodeAt(w.idPrefix.length - 1);
+        conds.push("id >= ? AND id < ?");
+        params.push(w.idPrefix, w.idPrefix.slice(0, -1) + String.fromCharCode(last + 1));
+      }
+    } else if ("idIn" in w) {
+      if (w.idIn.length === 0) conds.push("0");
+      else {
+        conds.push(`id IN (${w.idIn.map(() => "?").join(", ")})`);
+        params.push(...w.idIn);
+      }
+    } else if ("descriptionIn" in w) {
+      if (w.descriptionIn.length === 0) conds.push("0");
+      else {
+        conds.push(`description IN (${w.descriptionIn.map(() => "?").join(", ")})`);
+        params.push(...w.descriptionIn);
+      }
+    } else if ("column" in w) {
+      const c = column(w.column);
+      for (const [op, sym] of [["gte", ">="], ["gt", ">"], ["lte", "<="], ["lt", "<"]]) {
+        const v = w[op];
+        if (v !== void 0) {
+          conds.push(`${c} ${sym} ?`);
+          params.push(v);
+        }
+      }
+    } else {
+      const p = path(w.attr);
+      if ("absent" in w) conds.push(`json_type(attrs_json, ${p}) IS NULL`);
+      else if ("present" in w) conds.push(`json_type(attrs_json, ${p}) IS NOT NULL`);
+      else if ("nullish" in w) conds.push(`json_extract(attrs_json, ${p}) IS NULL`);
+      else if ("notNullish" in w) conds.push(`json_extract(attrs_json, ${p}) IS NOT NULL`);
+      else if ("eq" in w || "ne" in w) {
+        const v = "eq" in w ? w.eq : w.ne;
+        const neg = "ne" in w;
+        if (typeof v === "boolean") {
+          conds.push(`json_type(attrs_json, ${p}) ${neg ? "IS NOT" : "="} ?`);
+          params.push(v ? "true" : "false");
+        } else {
+          conds.push(neg ? `json_extract(attrs_json, ${p}) IS NOT ?` : `json_extract(attrs_json, ${p}) = ?`);
+          params.push(v);
+        }
+      }
+    }
+  }
+  return { where: conds.join(" AND "), params };
+}
+function attrValueSql(p, doc = "attrs_json") {
+  return `CASE json_type(${doc}, ${p}) WHEN 'integer' THEN CAST(json_extract(${doc}, ${p}) AS REAL) ELSE json_extract(${doc}, ${p}) END`;
+}
+function attrDocSql(key) {
+  return isExposureAttr(key) ? exposureDocSql(key) : "attrs_json";
+}
+function nodeSelectFrom(q) {
+  if (q.indexedBy) return `nodes INDEXED BY ${selectIndex(q.indexedBy)}`;
+  const where = q.where ?? [];
+  if (!q.includeClosed && where.some((w) => "descriptionIn" in w && w.descriptionIn.length > 0) && !where.some((w) => "idIn" in w)) {
+    return "nodes INDEXED BY nodes_live_description";
+  }
+  return "nodes";
+}
+function compileNodeSelect(q) {
+  const { where, params } = compileNodeWhere(q);
+  const attrs = q.attrs ?? [];
+  const attrCols = attrs.map((k, i2) => `, ${attrValueSql(path(k), attrDocSql(k))} AS a${i2}, json_type(${attrDocSql(k)}, ${path(k)}) AS t${i2}`).join("");
+  let order;
+  if (q.orderBy && "column" in q.orderBy) {
+    order = `${column(q.orderBy.column)} ${q.orderBy.desc ? "DESC" : "ASC"}, rowid`;
+  } else if (q.orderBy) {
+    const p = path(q.orderBy.attr);
+    order = `json_extract(attrs_json, ${p}) IS NULL, json_extract(attrs_json, ${p}) ${q.orderBy.desc ? "DESC" : "ASC"}, rowid`;
+  } else if (q.labels.length > 1) {
+    order = `CASE label ${q.labels.map((_, i2) => `WHEN ? THEN ${i2}`).join(" ")} END, rowid`;
+  } else {
+    order = "rowid";
+  }
+  const orderParams = !q.orderBy && q.labels.length > 1 ? [...q.labels] : [];
+  const limit = q.limit !== void 0 ? ` LIMIT ${Math.max(0, Math.floor(q.limit))}` : "";
+  const sql = `SELECT id, label, description, created_at, last_updated_at, page_rank, cumulative_hits, extraction_confidence, extraction_source, community, created_at_seq, last_reinforced_at_seq, valid_to, logical_id, version, ${EMBEDDING_DIM_SQL} AS embedding_dim${q.withEmbedding ? ", embedding_blob, embedding_json" : ""}${attrCols} FROM ${nodeSelectFrom(q)} WHERE ${where} ORDER BY ${order}${limit}`;
+  return { sql, params: [...params, ...orderParams] };
+}
+function decodeAttr(value, type) {
+  switch (type) {
+    case null:
+    case void 0:
+      return void 0;
+    case "true":
+      return true;
+    case "false":
+      return false;
+    case "null":
+      return null;
+    case "object":
+    case "array":
+      return typeof value === "string" ? JSON.parse(value) : value;
+    default:
+      return value;
+  }
+}
+function decodeSelectedRow(r, attrs, decodeVector) {
+  const out2 = {};
+  attrs.forEach((k, i2) => {
+    const v = decodeAttr(r[`a${i2}`], r[`t${i2}`]);
+    if (v !== void 0) out2[k] = v;
+  });
+  return {
+    id: r["id"],
+    label: r["label"],
+    description: r["description"] ?? "",
+    createdAt: r["created_at"],
+    lastUpdatedAt: r["last_updated_at"],
+    pageRank: r["page_rank"],
+    cumulativeHits: r["cumulative_hits"],
+    extractionConfidence: r["extraction_confidence"],
+    extractionSource: r["extraction_source"],
+    community: r["community"] ?? null,
+    ...r["created_at_seq"] != null ? { createdAtSeq: r["created_at_seq"] } : {},
+    ...r["last_reinforced_at_seq"] != null ? { lastReinforcedAtSeq: r["last_reinforced_at_seq"] } : {},
+    validTo: r["valid_to"] ?? null,
+    logicalId: r["logical_id"] ?? r["id"],
+    version: Number(r["version"] ?? 1),
+    embeddingDim: Number(r["embedding_dim"] ?? 0),
+    ...decodeVector ? { embedding: decodeVector(r["embedding_blob"], r["embedding_json"] ?? "[]") } : {},
+    attrs: out2
+  };
+}
+
 // ../../packages/local-graph/src/store.ts
 var PAGE_RANK_SCALE_KEY = "pageRankScale.p95.v1";
 var TEXT_SEARCH_COLUMNS = `id, label, description, page_rank,
@@ -26015,6 +27201,7 @@ function localEdgeViolation(fromLabel, type, toLabel) {
 }
 var SCHEMA_VERSION = 6;
 var SESSION_REPAIR_KEY = "session-evidence-v1";
+var EXPOSURE_SIDE_KEY = "exposure-side-rows-1";
 var SESSION_EVIDENCE_PREDICATE = SESSION_EVIDENCE_FIELDS.map((field) => `instr(attrs_json, '${JSON.stringify(field)}') > 0`).join(" OR ");
 var SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS schema_version (
@@ -26078,8 +27265,13 @@ CREATE TABLE IF NOT EXISTS nodes (
 );
 
 CREATE INDEX IF NOT EXISTS nodes_label ON nodes(label);
-CREATE INDEX IF NOT EXISTS nodes_memory_tier ON nodes(memory_tier);
-CREATE INDEX IF NOT EXISTS nodes_page_rank ON nodes(page_rank DESC);
+-- Dropped: no query plans through them (every prepared statement across the
+-- local-graph, indexer, context-writer, generalizer and daemon suites was
+-- planned with and without them, 2026-10-21), and each write that touches
+-- memory_tier / page_rank (every node upsert, every rescore) paid to maintain
+-- them. nodes_live_page_rank serves the live page-rank orderings.
+DROP INDEX IF EXISTS nodes_memory_tier;
+DROP INDEX IF EXISTS nodes_page_rank;
 
 CREATE TABLE IF NOT EXISTS edges (
   id TEXT PRIMARY KEY,
@@ -26101,7 +27293,10 @@ CREATE TABLE IF NOT EXISTS edges (
   FOREIGN KEY (to_id) REFERENCES nodes(id) ON DELETE CASCADE
 );
 
-CREATE INDEX IF NOT EXISTS edges_from ON edges(from_id, type);
+-- Dropped: a prefix of edges_triple (from_id, type, to_id), which every
+-- from-side lookup and foreign-key check already plans through; it cost 47 MB
+-- and an index write on every edge write.
+DROP INDEX IF EXISTS edges_from;
 CREATE INDEX IF NOT EXISTS edges_to ON edges(to_id, type);
 CREATE INDEX IF NOT EXISTS edges_type ON edges(type);
 CREATE UNIQUE INDEX IF NOT EXISTS edges_triple ON edges(from_id, type, to_id);
@@ -26109,8 +27304,41 @@ CREATE UNIQUE INDEX IF NOT EXISTS edges_triple ON edges(from_id, type, to_id);
 var TEMPORAL_INDEX_SQL = `
 CREATE INDEX IF NOT EXISTS nodes_live ON nodes(label, valid_to);
 CREATE INDEX IF NOT EXISTS nodes_live_count ON nodes(valid_to);
-CREATE INDEX IF NOT EXISTS nodes_live_recent ON nodes(label, last_updated_at DESC) WHERE valid_to IS NULL;
+-- Problems by recency (the only label read newest-first). Over every live row,
+-- each write that stamps last_updated_at moved a code symbol's entry from a
+-- scattered leaf: ~19 KB per position-only symbol rewrite on a 1.1 GB store.
+-- label stays the leading column so label = 'Problem' plans without a sort.
+DROP INDEX IF EXISTS nodes_live_recent;
+CREATE INDEX IF NOT EXISTS nodes_live_problem_recent ON nodes(label, last_updated_at DESC) WHERE valid_to IS NULL AND label = 'Problem';
+-- "Anything created since the watermark?" guards (the fold, regression and
+-- canonical-bind sweeps run one per session boundary). Without it the planner
+-- walks nodes_live and reads every live row of the label to test created_at:
+-- 56 MB per guard on a 1.1 GB store, to learn there was nothing to do. valid_to
+-- is a key column so the planner prefers this over nodes_live (one more term).
+CREATE INDEX IF NOT EXISTS nodes_live_created ON nodes(label, valid_to, created_at) WHERE valid_to IS NULL;
+-- Community members (the skills pull reads them twice per session boundary):
+-- ~15% of semantic nodes carry a localCommunity, and without this every live
+-- semantic row was read to find them (168 MB \u2192 18 MB per read).
+CREATE INDEX IF NOT EXISTS nodes_live_local_community ON nodes(label, valid_to, json_extract(attrs_json, '$.localCommunity')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.localCommunity') IS NOT NULL;
+-- Problems parked for the fold judge (read every settle boundary): ~1 in 5 open
+-- Problems; without it every live Problem was read to find them (56 MB).
+CREATE INDEX IF NOT EXISTS nodes_live_fold_candidate ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_type(attrs_json, '$.foldCandidate') IS NOT NULL;
+-- Render impressions, one row per node id (exposure-attrs.ts): a render bumps
+-- ~40 of these, which in the node row rewrote each whole row and its indexes.
+CREATE TABLE IF NOT EXISTS node_exposure (
+  id TEXT PRIMARY KEY,
+  attrs_json TEXT NOT NULL DEFAULT '{}'
+) WITHOUT ROWID;
+-- The semantic-maintenance sweeps' own filters (closed, asked, hinted): each read
+-- every Problem row (~30 MB on a 1.1 GB store) for the few hundred that match,
+-- several times a run, and a run follows most writes (2026-10-20).
+CREATE INDEX IF NOT EXISTS nodes_live_resolved ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.resolvedAt') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_live_fix_candidate ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_type(attrs_json, '$.fixCandidateAt') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_live_anchor_hint ON nodes(label, valid_to) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.anchorHint') IS NOT NULL;
 CREATE INDEX IF NOT EXISTS nodes_session_evidence ON nodes(id) WHERE ${SESSION_EVIDENCE_PREDICATE};
+-- Rows carrying a calibration counter, any version: the logical nodes wm
+-- calibration can count (~3k), found without reading every citable row.
+CREATE INDEX IF NOT EXISTS nodes_wm_counted ON nodes(logical_id, version, valid_to, label, ${WM_CALIBRATION_KEYS.map(wmCounterSql).join(", ")}) WHERE ${WM_COUNTED_PREDICATE};
 CREATE INDEX IF NOT EXISTS edges_session_evidence ON edges(id) WHERE ${SESSION_EVIDENCE_PREDICATE};
 -- Covering + partial index for labelFingerprint over the instance labels: the
 -- live-push probe runs it per workspace on a timer, and each hit used to read
@@ -26124,31 +27352,70 @@ CREATE INDEX IF NOT EXISTS nodes_instance_fingerprint_v2 ON nodes(label, last_up
 CREATE INDEX IF NOT EXISTS nodes_live_page_rank ON nodes(valid_to, page_rank);
 CREATE INDEX IF NOT EXISTS nodes_logical ON nodes(logical_id, version);
 CREATE INDEX IF NOT EXISTS edges_live ON edges(valid_to);
+-- Newest live edges first, so a "recent N matching edges" read stops early instead
+-- of matching and sorting every live edge (the hourly liveness check: 163 MB \u2192
+-- 69 MB). Named by recentEdgeAttrCoverage; the planner keeps edges_live otherwise.
+CREATE INDEX IF NOT EXISTS edges_live_created ON edges(created_at) WHERE valid_to IS NULL;
+-- Live prior-tag edges by recency: the liveness corroboration check reads the
+-- newest 100 of ~300, and walking all live edges newest-first to find them read
+-- 69 MB. Its predicate is the one recentEdgeAttrCoverage uses for that marker.
+CREATE INDEX IF NOT EXISTS edges_live_prior_tag ON edges(created_at) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.priorTag') = 1;
 -- Expression index on the per-node relPath (stored in attrs_json) so the
 -- incremental reindex can fetch just the changed files' symbols instead of
 -- scanning every versioned node. Partial: only live rows are ever queried.
 CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.relPath')) WHERE valid_to IS NULL;
+-- Symbols by qname and doc comments by the symbol they attach to: the drain's
+-- symbol lexicon resolves the names in the text it ships one at a time, instead
+-- of reading every Function/Method/Class/Interface/Const and Comment row on each
+-- live push (~300 MB of a 1.1 GB store per push, 2026-10-20).
+CREATE INDEX IF NOT EXISTS nodes_live_qname ON nodes(json_extract(attrs_json, '$.qname')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_live_attached_to ON nodes(json_extract(attrs_json, '$.attachedTo')) WHERE valid_to IS NULL AND label = 'Comment';
+-- The attrs the cloud drain gates every instance row on, so it reads them from
+-- the index alone: pulled cloud rows are most of these labels (7,105 of 7,708
+-- Solutions on the live store) at ~10 KB of attrs each, and five full scans for
+-- two attrs read ~220 MB per push to find the few local rows that can ship.
+-- created_at leads so the index order is findNodeFieldsByLabel's.
+CREATE INDEX IF NOT EXISTS nodes_live_instance_gate ON nodes(label, created_at, json_extract(attrs_json, '$.source'), json_extract(attrs_json, '$.privateFinding'), json_extract(attrs_json, '$.resolvedAs'), id) WHERE valid_to IS NULL AND label IN ('Problem', 'Vulnerability', 'Solution', 'RootCause');
+-- Closed rows by relPath, for reviveReobserved (every incremental reindex): the
+-- live-only index above cannot serve it, so it scanned the whole table (~275 MB
+-- of a 1.1 GB store per reindex, 2026-10-20).
+CREATE INDEX IF NOT EXISTS nodes_closed_relpath ON nodes(json_extract(attrs_json, '$.relPath'), last_updated_at) WHERE valid_to IS NOT NULL;
 -- Live rows by name, for looking up the few symbols a statement mentions
 -- instead of hydrating every code symbol per minted problem.
 CREATE INDEX IF NOT EXISTS nodes_live_description ON nodes(description, label) WHERE valid_to IS NULL;
+-- The six single-attr lookups below are partial on the attr being present: each
+-- is read only by equality (or IN), which implies it. Keyed on NULL for the ~95%
+-- of rows that lack the attr, every write to such a row's attrs rewrote its NULL
+-- entry: ~25 KB per position-only symbol rewrite on a 1.1 GB store (2026-10-21).
+DROP INDEX IF EXISTS nodes_anchor_hint_path;
+DROP INDEX IF EXISTS nodes_command_signature;
+DROP INDEX IF EXISTS nodes_diag_command;
+DROP INDEX IF EXISTS nodes_lsp_rel_path;
+DROP INDEX IF EXISTS nodes_cloud_node_id;
+DROP INDEX IF EXISTS nodes_enrichment_pending;
 -- Problems by the file their anchor hint names: the harvest upgrades hints for
 -- every edited file of every turn, and a scan parses every Problem's attrs.
-CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_anchor_hint_path_v2 ON nodes(json_extract(attrs_json, '$.anchorHint.path')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.anchorHint.path') IS NOT NULL;
 -- Problems by the command / checker / file that opened them. The generalizer
 -- looked these up per shell or tool EVENT by hydrating every Problem: ~12s of
 -- every minute of daemon main-thread time on a 3.4k-Problem store (2026-10-05).
-CREATE INDEX IF NOT EXISTS nodes_command_signature ON nodes(json_extract(attrs_json, '$.commandSignature')) WHERE valid_to IS NULL;
-CREATE INDEX IF NOT EXISTS nodes_diag_command ON nodes(json_extract(attrs_json, '$.diagCommand')) WHERE valid_to IS NULL;
-CREATE INDEX IF NOT EXISTS nodes_lsp_rel_path ON nodes(json_extract(attrs_json, '$.lspRelPath')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_command_signature_v2 ON nodes(json_extract(attrs_json, '$.commandSignature')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.commandSignature') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_diag_command_v2 ON nodes(json_extract(attrs_json, '$.diagCommand')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.diagCommand') IS NOT NULL;
+CREATE INDEX IF NOT EXISTS nodes_lsp_rel_path_v2 ON nodes(json_extract(attrs_json, '$.lspRelPath')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.lspRelPath') IS NOT NULL;
 -- Local nodes by the cloud twin their upload receipt recorded. Every burst /
 -- search fusion folds the Network copy of the caller's own knowledge back onto
 -- the local node; unindexed, the reverse lookup was a ~300ms attrs scan per call.
-CREATE INDEX IF NOT EXISTS nodes_cloud_node_id ON nodes(json_extract(attrs_json, '$.cloudNodeId')) WHERE valid_to IS NULL;
+CREATE INDEX IF NOT EXISTS nodes_cloud_node_id_v2 ON nodes(json_extract(attrs_json, '$.cloudNodeId')) WHERE valid_to IS NULL AND json_extract(attrs_json, '$.cloudNodeId') IS NOT NULL;
 -- Nodes still waiting on a root-cause ask. The MCP server checks this on EVERY
 -- tool response (the enrichment piggyback), so it must not parse every
--- Solution's and Problem's attrs per call. Not partial: the Problem pull reads
+-- Solution's and Problem's attrs per call. Any version: the Problem pull reads
 -- closed versions too.
-CREATE INDEX IF NOT EXISTS nodes_enrichment_pending ON nodes(json_extract(attrs_json, '$.enrichmentPending'));
+CREATE INDEX IF NOT EXISTS nodes_enrichment_pending_v2 ON nodes(json_extract(attrs_json, '$.enrichmentPending')) WHERE json_extract(attrs_json, '$.enrichmentPending') IS NOT NULL;
+-- Revisit flags, any label, any version: listNeedsRevisit's as-of read runs on
+-- every context render and otherwise json-checks every row (10.3 s on a 324k-row
+-- store, to return zero flags). The predicate must stay textually identical to
+-- nodesAsOfWhereTrue's or the planner will not use it.
+CREATE INDEX IF NOT EXISTS nodes_revisit_true ON nodes(valid_from) WHERE json_type(attrs_json, '$.revisit') = 'true';
 `;
 function encodeEmbedding(emb) {
   if (!emb || emb.length === 0) return null;
@@ -26209,12 +27476,39 @@ function rowToEdge(r) {
 }
 var FINGERPRINT_INDEXED_LABELS = ["Problem", "Vulnerability", "Solution", "RootCause"];
 var NODE_LABELS_CHUNK = 256;
+var NODE_UPSERT_COLUMNS = [
+  "label",
+  "description",
+  "extraction_confidence",
+  "embedding_json",
+  "embedding_blob",
+  "cumulative_surprise",
+  "peak_surprise",
+  "cumulative_hits",
+  "last_updated_at",
+  "memory_tier",
+  "page_rank",
+  "is_landmark",
+  "community",
+  "stability",
+  "last_reinforced_at_seq",
+  "attrs_json"
+];
+var EDGE_UPSERT_COLUMNS = ["confidence", "last_seen_at", "nav_successes", "nav_failures", "valid_to", "attrs_json"];
+function sameSqlValue(a, b) {
+  if (a === b || a == null && b == null) return true;
+  if (a instanceof Uint8Array && b instanceof Uint8Array) return Buffer.compare(a, b) === 0;
+  return false;
+}
+var PRIOR_TAG_MARKER = '"priorTag":true';
 var SqliteGraphStore = class {
   db;
   // Typed edge lookups build their SQL from the number of types asked for, and
   // used to prepare it on every call: ~600ms of a 2.5s drain build on a live
   // 225k-node store was statement compilation alone. Keyed by the SQL text.
   typedEdgeStmts = /* @__PURE__ */ new Map();
+  /** Narrow merge updates, keyed by table and the columns they set. */
+  changedColumnStmts = /* @__PURE__ */ new Map();
   stmts;
   /** Unified graph-mutation counter (see GraphStore.mutationCount). Bumped on
    *  every node/edge upsert — code-index and capture alike — so the consolidation
@@ -26233,6 +27527,8 @@ var SqliteGraphStore = class {
   initialPageRankScale;
   constructor(opts) {
     this.db = openDatabase(opts.path);
+    this.db.exec("PRAGMA cache_size = -32768");
+    this.db.exec("PRAGMA mmap_size = 2147483648");
     this.db.exec(SCHEMA_SQL);
     const versionRow = this.db.prepare("SELECT version FROM schema_version LIMIT 1").get();
     if (!versionRow) {
@@ -26249,12 +27545,15 @@ var SqliteGraphStore = class {
     installEditPlaceholderRetirement(this.db);
     installCloudAttrCompaction(this.db);
     installHistoryAttrSlim(this.db);
+    installTextIndex(this.db);
     if (!this.db.prepare("SELECT value FROM store_meta WHERE key = ?").get(SESSION_REPAIR_KEY)) {
       this.db.transaction(() => {
         this.repairSessionAliases();
         this.db.prepare("INSERT OR REPLACE INTO store_meta (key, value) VALUES (?, 'done')").run(SESSION_REPAIR_KEY);
       });
     }
+    installLineageIntegrityRepair(this.db);
+    installChangeFeed(this.db);
     this.stmts = {
       insertNode: this.db.prepare(`
         INSERT INTO nodes (
@@ -26293,7 +27592,19 @@ var SqliteGraphStore = class {
           last_reinforced_at_seq = excluded.last_reinforced_at_seq,
           attrs_json = excluded.attrs_json
       `),
-      getNode: this.db.prepare("SELECT * FROM nodes WHERE id = ?"),
+      nodeUpsertTarget: this.db.prepare(`SELECT rowid AS rid, ${NODE_UPSERT_COLUMNS.join(", ")} FROM nodes WHERE id = ?`),
+      edgeUpsertTarget: this.db.prepare(`SELECT rowid AS rid, ${EDGE_UPSERT_COLUMNS.join(", ")} FROM edges WHERE from_id = ? AND type = ? AND to_id = ?`),
+      getNode: this.db.prepare("SELECT nodes.*, (SELECT x.attrs_json FROM node_exposure x WHERE x.id = nodes.id) AS exposure_json FROM nodes WHERE id = ?"),
+      exposureOf: this.db.prepare("SELECT attrs_json FROM node_exposure WHERE id = ?"),
+      writeExposure: this.db.prepare("INSERT INTO node_exposure(id, attrs_json) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET attrs_json = excluded.attrs_json"),
+      lastUpdatedOf: this.db.prepare("SELECT last_updated_at AS t, attrs_json FROM nodes WHERE id = ?"),
+      labelOf: this.db.prepare("SELECT label FROM nodes WHERE id = ?"),
+      nodeContent: this.db.prepare(
+        "SELECT label, description, extraction_confidence, extraction_source, stability, valid_to, attrs_json FROM nodes WHERE id = ?"
+      ),
+      edgeContent: this.db.prepare(
+        "SELECT confidence, valid_to, attrs_json FROM edges WHERE from_id = ? AND type = ? AND to_id = ?"
+      ),
       // Single-column fast paths for the nightly pass — writing 100k pageRank
       // values through the 18-column COALESCE updateNode took ~30s; these are ~10x
       // cheaper (one bound column, no COALESCE evaluation per row).
@@ -26450,6 +27761,7 @@ var SqliteGraphStore = class {
         "INSERT INTO store_meta (key, value) VALUES ('ingest_seq', :v) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
       )
     };
+    this.moveExposureToSideRows();
     const seqRow = this.db.prepare("SELECT value FROM store_meta WHERE key = 'ingest_seq'").get();
     this.ingestSeq = seqRow ? Number(seqRow.value) : 0;
   }
@@ -26465,6 +27777,93 @@ var SqliteGraphStore = class {
         AND (t.id IS NULL OR t.valid_to IS NOT NULL)
     `).all();
   }
+  strandedSymbolsForFiles(fileIds) {
+    const out2 = [];
+    for (let i2 = 0; i2 < fileIds.length; i2 += 500) {
+      const slice = fileIds.slice(i2, i2 + 500);
+      if (slice.length === 0) continue;
+      out2.push(...this.db.prepare(`
+        SELECT f.id AS fileId, e.to_id AS symbolId
+        FROM nodes f CROSS JOIN edges e ON e.from_id = f.id
+        LEFT JOIN nodes t ON t.id = e.to_id
+        WHERE f.id IN (${slice.map(() => "?").join(",")}) AND f.label = 'File' AND f.valid_to IS NULL AND e.valid_to IS NULL
+          AND e.type IN ('DEFINES', 'CONTAINS')
+          AND (t.id IS NULL OR t.valid_to IS NOT NULL)
+      `).all(...slice));
+    }
+    return out2;
+  }
+  firstLiveByNameOrQname(labels, name2) {
+    if (labels.length === 0) return null;
+    const inLabels = labels.map(() => "?").join(",");
+    const probe = (index, match) => this.db.prepare(
+      `SELECT rowid AS rid, created_at AS at, label, description, json_extract(attrs_json, '$.qname') AS qname FROM nodes INDEXED BY ${index}
+          WHERE ${match} = ? AND label IN (${inLabels}) AND valid_to IS NULL`
+    ).all(name2, ...labels);
+    const rank = (r) => [labels.indexOf(r.label), r.at, r.rid];
+    const before = (a, b) => a[0] < b[0] || a[0] === b[0] && (a[1] < b[1] || a[1] === b[1] && a[2] < b[2]);
+    let best;
+    for (const r of [...probe("nodes_live_description", "description"), ...probe("nodes_live_qname", "json_extract(attrs_json, '$.qname')")]) {
+      if (!best || before(rank(r), rank(best))) best = r;
+    }
+    return best ? { label: best.label, description: best.description, qname: typeof best.qname === "string" ? best.qname : null } : null;
+  }
+  instanceGateRows(label) {
+    return this.db.prepare(
+      `SELECT id, json_extract(attrs_json, '$.source') AS source, json_extract(attrs_json, '$.privateFinding') AS privateFinding,
+              json_extract(attrs_json, '$.resolvedAs') AS resolvedAs
+         FROM nodes INDEXED BY nodes_live_instance_gate
+        WHERE label IN ('Problem', 'Vulnerability', 'Solution', 'RootCause') AND label = ? AND valid_to IS NULL
+        ORDER BY label, created_at, rowid`
+    ).all(label);
+  }
+  wmCalibrationRows(labels) {
+    const counted = this.db.prepare(
+      `SELECT rowid AS rid, logical_id, version, valid_to, label, ${WM_CALIBRATION_KEYS.map((k, i2) => `${wmCounterSql(k)} AS c${i2}`).join(", ")}
+         FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE}`
+    ).all();
+    const exposed = this.db.prepare(
+      `SELECT n.rowid AS rid, n.logical_id, n.version, n.valid_to, n.label, x.attrs_json AS exposure
+         FROM node_exposure x JOIN nodes n ON n.id = x.id`
+    ).all();
+    const others = this.db.prepare(
+      `SELECT rowid AS rid, logical_id, version, valid_to, label FROM nodes WHERE rowid IN (
+         SELECT n.rowid FROM nodes AS n INDEXED BY nodes_logical
+          WHERE n.logical_id IN (SELECT logical_id FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE}
+                                 UNION SELECT n2.logical_id FROM node_exposure x2 JOIN nodes n2 ON n2.id = x2.id)
+         EXCEPT SELECT rowid FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE}
+         EXCEPT SELECT n3.rowid FROM node_exposure x3 JOIN nodes n3 ON n3.id = x3.id)`
+    ).all();
+    const byRid = /* @__PURE__ */ new Map();
+    for (const r of [...counted, ...others]) {
+      const attrs = {};
+      WM_CALIBRATION_KEYS.forEach((k, i2) => {
+        const v = r[`c${i2}`];
+        if (typeof v === "number") attrs[k] = v;
+      });
+      byRid.set(r.rid, { row: r, attrs });
+    }
+    for (const r of exposed) {
+      const side = JSON.parse(r.exposure);
+      const entry = byRid.get(r.rid) ?? { row: r, attrs: {} };
+      for (const k of WM_CALIBRATION_KEYS) if (typeof side[k] === "number" && Number.isFinite(side[k])) entry.attrs[k] = side[k];
+      byRid.set(r.rid, entry);
+    }
+    const order = new Map(labels.map((l, i2) => [l, i2]));
+    return [...byRid.values()].filter(({ row }) => order.has(row.label)).sort((a, b) => order.get(a.row.label) - order.get(b.row.label) || a.row.rid - b.row.rid).map(({ row, attrs }) => ({ logicalId: row.logical_id, version: Number(row.version), validTo: row.valid_to ?? null, attrs }));
+  }
+  liveCommentsAttachedTo(name2) {
+    return this.db.prepare(
+      `SELECT json_extract(attrs_json, '$.kind') AS kind, json_extract(attrs_json, '$.text') AS text, description FROM nodes INDEXED BY nodes_live_attached_to
+        WHERE label = 'Comment' AND valid_to IS NULL AND json_extract(attrs_json, '$.attachedTo') = ? ORDER BY created_at, rowid`
+    ).all(name2);
+  }
+  strandedEdges() {
+    return countStrandedEdges(this.db);
+  }
+  liveHeadConflicts() {
+    return countLiveHeadConflicts(this.db);
+  }
   fileIndexStates(ids) {
     if (ids.length === 0) return [];
     if (ids.length > 500) throw new RangeError("fileIndexStates accepts at most 500 ids per read");
@@ -26563,7 +27962,7 @@ var SqliteGraphStore = class {
   }
   mergeNode(node) {
     this.mutations++;
-    this.stmts.insertNode.run({
+    const values = {
       id: node.id,
       label: node.label,
       description: node.description,
@@ -26589,8 +27988,37 @@ var SqliteGraphStore = class {
       logical_id: node.logicalId ?? node.id,
       created_at_seq: node.createdAtSeq ?? null,
       last_reinforced_at_seq: node.lastReinforcedAtSeq ?? null,
-      attrs_json: JSON.stringify(node.attrs ?? {})
-    });
+      attrs_json: this.nodeAttrsJson(node.id, node.attrs ?? {})
+    };
+    const current = this.stmts.nodeUpsertTarget.get(node.id);
+    if (current) this.writeChangedColumns("nodes", NODE_UPSERT_COLUMNS, current, values);
+    else this.stmts.insertNode.run(values);
+  }
+  /** What the upsert's ON CONFLICT would write over `current`, setting only the
+   *  columns whose value moves (NODE_UPSERT_COLUMNS says why). */
+  writeChangedColumns(table, columns2, current, next) {
+    const changed = columns2.filter((c) => !sameSqlValue(current[c], next[c]));
+    if (changed.length === 0) return;
+    const key = `${table}:${changed.join(",")}`;
+    let stmt2 = this.changedColumnStmts.get(key);
+    if (!stmt2) {
+      stmt2 = this.db.prepare(`UPDATE ${table} SET ${changed.map((c) => `${c} = :${c}`).join(", ")} WHERE rowid = :rid`);
+      this.changedColumnStmts.set(key, stmt2);
+    }
+    stmt2.run({ rid: current["rid"], ...Object.fromEntries(changed.map((c) => [c, next[c]])) });
+  }
+  /** mergeNode, unless the live row already holds this content. Content is what
+   *  the columns a merge rewrites from the producer (label, description, attrs,
+   *  confidence, stability);
+   *  rank, community, landmark, surprise, hits, tier and the vector belong to
+   *  the passes that compute them, and a skipped write leaves them as they are
+   *  where a merge would have reset them to the producer's defaults. Returns
+   *  whether it wrote. */
+  mergeNodeIfChanged(node) {
+    const row = this.stmts.nodeContent.get(node.id);
+    if (row && row.valid_to === null && row.label === node.label && row.description === node.description && row.extraction_confidence === node.extractionConfidence && row.stability === node.stability && !EXPOSURE_ATTRS.some((k) => node.attrs?.[k] !== void 0) && row.attrs_json === JSON.stringify(node.attrs ?? {})) return false;
+    this.mergeNode(node);
+    return true;
   }
   updateNode(id, patch) {
     const hasEmbedding = patch.embedding !== void 0 && patch.embedding.length > 0;
@@ -26615,7 +28043,37 @@ var SqliteGraphStore = class {
       logical_id: patch.logicalId ?? null,
       created_at_seq: patch.createdAtSeq ?? null,
       last_reinforced_at_seq: patch.lastReinforcedAtSeq ?? null,
-      attrs_json: patch.attrs ? JSON.stringify(patch.attrs) : null
+      attrs_json: patch.attrs ? this.nodeAttrsJson(id, patch.attrs) : null
+    });
+  }
+  /**
+   * The node-row attrs of a write, after handing any exposure keys to the side
+   * row (exposure-attrs.ts). `getNode` returns exposure merged into attrs, so a
+   * read-modify-write carries it; kept in the row it would re-bloat the row and
+   * drift from the side row. Unchanged exposure costs no write.
+   */
+  nodeAttrsJson(id, attrs) {
+    if (!EXPOSURE_ATTRS.some((k) => attrs[k] !== void 0)) return JSON.stringify(attrs);
+    const current = this.stmts.exposureOf.get(id);
+    const next = JSON.stringify({ ...current ? JSON.parse(current.attrs_json) : {}, ...pickExposure(attrs) });
+    if (current?.attrs_json !== next) this.stmts.writeExposure.run(id, next);
+    const rest = { ...attrs };
+    for (const k of EXPOSURE_ATTRS) delete rest[k];
+    return JSON.stringify(rest);
+  }
+  /** One-time: exposure keys written to node rows before the side table existed
+   *  move to it. Only rows carrying a counter can carry exposure, and those are
+   *  what nodes_wm_counted holds, so this reads the index, not the table. */
+  moveExposureToSideRows() {
+    if (this.db.prepare("SELECT value FROM store_meta WHERE key = ?").get(EXPOSURE_SIDE_KEY)) return;
+    const rows = this.db.prepare(`SELECT id, attrs_json FROM nodes INDEXED BY nodes_wm_counted WHERE ${WM_COUNTED_PREDICATE}`).all();
+    const move = this.db.prepare("UPDATE nodes SET attrs_json = ? WHERE id = ?");
+    this.db.transaction(() => {
+      for (const r of rows) {
+        const stripped = this.nodeAttrsJson(r.id, JSON.parse(r.attrs_json));
+        if (stripped !== r.attrs_json) move.run(stripped, r.id);
+      }
+      this.db.prepare("INSERT OR REPLACE INTO store_meta(key, value) VALUES (?, 'done')").run(EXPOSURE_SIDE_KEY);
     });
   }
   /** Fast single-column writes for the nightly pass (avoid the 18-column COALESCE
@@ -26626,26 +28084,30 @@ var SqliteGraphStore = class {
   setLandmark(id, isLandmark) {
     this.stmts.setLandmark.run({ id, v: isLandmark ? 1 : 0 });
   }
-  setLocalCommunity(id, community, column) {
-    this.stmts.setLocalCommunity.run({ id, v: community, col: column ? 1 : 0 });
+  setLocalCommunity(id, community, column2) {
+    this.stmts.setLocalCommunity.run({ id, v: community, col: column2 ? 1 : 0 });
   }
   fieldStmts = /* @__PURE__ */ new Map();
   findNodeFieldsByLabel(label, attrKeys) {
     for (const k of attrKeys) if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(k)) throw new Error(`findNodeFieldsByLabel: bad attr key ${k}`);
     const cacheKey = attrKeys.join(",");
-    let stmt = this.fieldStmts.get(cacheKey);
-    if (!stmt) {
-      const cols = attrKeys.map((k, i2) => `, json_extract(attrs_json, '$.${k}') AS a${i2}`).join("");
-      stmt = this.db.prepare(
-        `SELECT id, description, community, extraction_confidence${cols} FROM nodes WHERE label = ? AND valid_to IS NULL`
+    let stmt2 = this.fieldStmts.get(cacheKey);
+    if (!stmt2) {
+      const cols = attrKeys.map((k, i2) => `, ${attrValueSql(`'$.${k}'`)} AS a${i2}, json_type(attrs_json, '$.${k}') AS t${i2}`).join("");
+      stmt2 = this.db.prepare(
+        // Ordered, not left to the planner: readers take "first row wins" (the
+        // symbol lexicon's name winner and doc pick), and the order otherwise
+        // followed whichever partial index the planner chose. nodes_live_created
+        // serves this order without a sort.
+        `SELECT id, description, community, extraction_confidence${cols} FROM nodes WHERE label = ? AND valid_to IS NULL ORDER BY created_at, rowid`
       );
-      this.fieldStmts.set(cacheKey, stmt);
+      this.fieldStmts.set(cacheKey, stmt2);
     }
-    return stmt.all(label).map((r) => {
+    return stmt2.all(label).map((r) => {
       const attrs = {};
       attrKeys.forEach((k, i2) => {
-        const v = r[`a${i2}`];
-        if (v !== null && v !== void 0) attrs[k] = v;
+        const v = decodeAttr(r[`a${i2}`], r[`t${i2}`]);
+        if (v !== void 0) attrs[k] = v;
       });
       return {
         id: r["id"],
@@ -26656,6 +28118,15 @@ var SqliteGraphStore = class {
       };
     });
   }
+  selectNodes(q) {
+    const { sql, params } = compileNodeSelect(q);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => decodeSelectedRow(r, q.attrs ?? [], q.withEmbedding ? decodeEmbedding : void 0));
+  }
+  countNodes(q) {
+    const { where, params } = compileNodeWhere(q);
+    return Number(this.db.prepare(`SELECT COUNT(*) AS n FROM ${nodeSelectFrom(q)} WHERE ${where}`).get(...params).n);
+  }
   setCommunity(id, community) {
     this.stmts.setCommunity.run({ id, v: community });
   }
@@ -26668,7 +28139,7 @@ var SqliteGraphStore = class {
       return;
     }
     this.mutations++;
-    this.stmts.insertEdge.run({
+    const values = {
       id: edge.id,
       from_id: edge.from,
       to_id: edge.to,
@@ -26682,8 +28153,33 @@ var SqliteGraphStore = class {
       valid_from: edge.validFrom ?? edge.createdAt,
       valid_to: edge.validTo ?? null,
       attrs_json: JSON.stringify(edge.attrs ?? {})
+    };
+    const current = this.stmts.edgeUpsertTarget.get(edge.from, edge.type, edge.to);
+    if (!current) {
+      this.stmts.insertEdge.run(values);
+      return;
+    }
+    this.writeChangedColumns("edges", EDGE_UPSERT_COLUMNS, current, {
+      ...values,
+      confidence: Math.max(current["confidence"], edge.confidence),
+      valid_to: null
     });
   }
+  /** mergeEdge, unless the live edge already holds this content: same attrs, and
+   *  a confidence the upsert's MAX would keep. Its navigation posteriors and
+   *  last-seen stamp stay as they are where a merge would have reset them. The
+   *  ontology gate runs first either way, so refusals are recorded as before.
+   *  Returns whether it wrote (or refused). */
+  mergeEdgeIfChanged(edge) {
+    if (!this.edgeRuleViolation(edge)) {
+      const row = this.stmts.edgeContent.get(edge.from, edge.type, edge.to);
+      if (row && row.valid_to === null && row.confidence >= edge.confidence && row.attrs_json === JSON.stringify(edge.attrs ?? {})) {
+        return false;
+      }
+    }
+    this.mergeEdge(edge);
+    return true;
+  }
   /** EDGE_RULES check against the stored endpoints' labels, with the LOCAL
    *  overlay consulted first. Returns the reason string on a documented-
    *  forbidden combination, else null. Point lookups on the id PK — negligible
@@ -26728,11 +28224,13 @@ var SqliteGraphStore = class {
     }
   }
   edgeRuleViolation(edge) {
-    return localEdgeViolation(
-      this.getNode(edge.from)?.label,
-      edge.type,
-      this.getNode(edge.to)?.label
-    );
+    return localEdgeViolation(this.labelOf(edge.from), edge.type, this.labelOf(edge.to));
+  }
+  /** An endpoint's label, any version, as `getNode(id)?.label` reads it. Every
+   *  edge write checks both endpoints, and hydrating them (attrs + vector) to
+   *  read one leading column was most of an incremental reindex's reads. */
+  labelOf(id) {
+    return this.stmts.labelOf.get(id)?.label;
   }
   updateEdge(id, patch) {
     this.stmts.updateEdge.run({
@@ -26748,18 +28246,38 @@ var SqliteGraphStore = class {
   }
   getNode(id) {
     const row = this.stmts.getNode.get(id);
-    return row ? rowToNode(row) : null;
+    if (!row) return null;
+    const node = rowToNode(row);
+    if (row.exposure_json) Object.assign(node.attrs, JSON.parse(row.exposure_json));
+    return node;
+  }
+  /** A node's render exposure: the side row's keys over the node row's own
+   *  (exposure-attrs.ts), plus the node's `lastUpdatedAt` (the "shown since
+   *  touch" counter is relative to it) — without reading the node's attrs. */
+  exposureOf(id) {
+    const row = this.stmts.lastUpdatedOf.get(id);
+    if (!row) return null;
+    const side = this.stmts.exposureOf.get(id);
+    return {
+      attrs: { ...pickExposure(JSON.parse(row.attrs_json)), ...side ? JSON.parse(side.attrs_json) : {} },
+      lastUpdatedAt: row.t
+    };
+  }
+  /** Replace a node's exposure (only EXPOSURE_ATTRS keys belong here). Touches
+   *  neither the node row nor its indexes, nor the change feed. */
+  writeExposure(id, attrs) {
+    this.stmts.writeExposure.run(id, JSON.stringify(attrs));
   }
   nodeLabels(ids) {
     const width = NODE_LABELS_CHUNK;
-    const stmt = this.typedEdgeStmt(
+    const stmt2 = this.typedEdgeStmt(
       `SELECT id, label FROM nodes WHERE id IN (${Array.from({ length: width }, () => "?").join(",")})`
     );
     const labels = /* @__PURE__ */ new Map();
     for (let i2 = 0; i2 < ids.length; i2 += width) {
       const chunk = ids.slice(i2, i2 + width);
       while (chunk.length < width) chunk.push(null);
-      for (const row of stmt.all(...chunk)) labels.set(row.id, row.label);
+      for (const row of stmt2.all(...chunk)) labels.set(row.id, row.label);
     }
     return labels;
   }
@@ -26776,7 +28294,21 @@ var SqliteGraphStore = class {
    *  per project per request; the materializing form held the daemon's event
    *  loop for seconds at scale. */
   countNodesByLabel(label) {
-    return Number(this.stmts.countByLabel.get(label).n);
+    return this.countAt(`label:${label}`, [nodeScope(label)], () => Number(this.stmts.countByLabel.get(label).n));
+  }
+  /** Counts asked for on every status poll (/health, `errata status`, the
+   *  dashboards): a live-node COUNT(*) reads the whole liveness index, ~3 MB per
+   *  call on a 1.1 GB store, to recount a set that moves only on a write. Each is
+   *  kept with the change-feed reading of the rows it counts — triggers bump it on
+   *  every write from any connection, so a hit is exact, not a TTL guess. */
+  counts = /* @__PURE__ */ new Map();
+  countAt(key, scopes, count) {
+    const seq = readChangeSeq(this.db, scopes);
+    const hit = this.counts.get(key);
+    if (hit && hit.seq === seq) return hit.n;
+    const n = count();
+    this.counts.set(key, { seq, n });
+    return n;
   }
   /** Live rows for a label with attrs and creation stamps only — for scans that
    *  read attrs and never the vector. `findNodesByLabel` decodes every embedding
@@ -26785,16 +28317,39 @@ var SqliteGraphStore = class {
   findNodeStampsByLabel(label, attrKey) {
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(attrKey)) throw new Error(`findNodeStampsByLabel: bad attr key ${attrKey}`);
     const rows = this.db.prepare(
-      `SELECT id, created_at, created_at_seq, json_type(attrs_json, '$.${attrKey}') IS NOT NULL AS has
+      `SELECT id, created_at, created_at_seq, json_type(${attrDocSql(attrKey)}, '$.${attrKey}') IS NOT NULL AS has,
+                COALESCE(json_extract(attrs_json, '$.source') = 'cloud', 0) AS cloud
            FROM nodes WHERE label = ? AND valid_to IS NULL`
     ).all(label);
     return rows.map((r) => ({
       id: r.id,
       createdAt: r.created_at,
       ...r.created_at_seq != null ? { createdAtSeq: r.created_at_seq } : {},
-      has: r.has === 1
+      has: r.has === 1,
+      cloud: r.cloud === 1
     }));
   }
+  findNodeStampsByLabelAttrs(label, attrKeys) {
+    for (const k of attrKeys) if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(k)) throw new Error(`findNodeStampsByLabelAttrs: bad attr key ${k}`);
+    const keys = [...new Set(attrKeys)];
+    const rows = this.db.prepare(
+      `SELECT id, created_at, created_at_seq,
+                ${keys.map((k, i2) => `json_type(${attrDocSql(k)}, '$.${k}') IS NOT NULL AS h${i2}`).join(", ")}${keys.length ? "," : ""}
+                COALESCE(json_extract(attrs_json, '$.source') = 'cloud', 0) AS cloud
+           FROM nodes WHERE label = ? AND valid_to IS NULL`
+    ).all(label);
+    const out2 = new Map(keys.map((k) => [k, []]));
+    for (const r of rows) {
+      keys.forEach((k, i2) => out2.get(k).push({
+        id: r.id,
+        createdAt: r.created_at,
+        ...r.created_at_seq != null ? { createdAtSeq: r.created_at_seq } : {},
+        has: r[`h${i2}`] === 1,
+        cloud: r.cloud === 1
+      }));
+    }
+    return out2;
+  }
   findNodeAttrsByLabel(label) {
     const rows = this.stmts.attrsByLabel.all(label);
     return rows.map((r) => ({
@@ -26822,8 +28377,8 @@ var SqliteGraphStore = class {
       after = rows[rows.length - 1].rid;
     }
   }
-  recentNodeIds(label, limit) {
-    const rows = this.db.prepare("SELECT id FROM nodes WHERE label = ? AND valid_to IS NULL ORDER BY last_updated_at DESC LIMIT ?").all(label, Math.max(0, limit));
+  recentProblemIds(limit) {
+    const rows = this.db.prepare("SELECT id FROM nodes WHERE label = 'Problem' AND valid_to IS NULL ORDER BY last_updated_at DESC LIMIT ?").all(Math.max(0, limit));
     return rows.map((r) => r.id);
   }
   recentOpenProblemCandidates(opts) {
@@ -26903,6 +28458,20 @@ var SqliteGraphStore = class {
   }
   searchTextCandidates(terms) {
     if (terms.length === 0) return [];
+    const indexed = terms.filter((t) => t.length >= TEXT_INDEX_MIN_TERM);
+    if (indexed.length > 0 && textIndexReady(this.db)) {
+      const short = terms.filter((t) => t.length < TEXT_INDEX_MIN_TERM).map((t) => t.toLowerCase());
+      const rows2 = this.db.prepare(`WITH hits AS MATERIALIZED (
+        SELECT t.rowid AS rid, COUNT(*) AS matched FROM json_each(:terms) q, nodes_text t
+        WHERE t.description LIKE '%' || q.value || '%' GROUP BY t.rowid
+      ) SELECT ${TEXT_SEARCH_COLUMNS}, hits.matched FROM hits JOIN nodes ON nodes.rowid = hits.rid
+        WHERE nodes.valid_to IS NULL ORDER BY page_rank DESC, last_updated_at DESC`).all({ terms: JSON.stringify(indexed) });
+      return rows2.map((row) => {
+        const text = row.description.toLowerCase();
+        const extra = short.filter((t) => text.includes(t)).length;
+        return { node: textSearchNode(row), matched: row.matched + extra };
+      });
+    }
     const rows = this.db.prepare(`WITH matches AS MATERIALIZED (
       SELECT n.id, COUNT(*) AS matched FROM nodes n INDEXED BY nodes_live_description, json_each(:terms) t
       WHERE n.valid_to IS NULL AND n.description LIKE '%' || t.value || '%'
@@ -26911,6 +28480,18 @@ var SqliteGraphStore = class {
       JOIN matches USING (id) ORDER BY page_rank DESC, last_updated_at DESC`).all({ terms: JSON.stringify(terms) });
     return rows.map((row) => ({ node: textSearchNode(row), matched: row.matched }));
   }
+  commentAnchors(commentIds) {
+    const out2 = /* @__PURE__ */ new Map();
+    if (commentIds.length === 0) return out2;
+    const rows = this.db.prepare(`WITH a AS MATERIALIZED (
+      SELECT q.value AS cid, COALESCE(
+        (SELECT to_id FROM edges WHERE from_id = q.value AND type IN ('EXPLAINS', 'ANNOTATES') AND valid_to IS NULL LIMIT 1),
+        (SELECT from_id FROM edges WHERE to_id = q.value AND type = 'DOCUMENTED_BY' AND valid_to IS NULL LIMIT 1)
+      ) AS aid FROM json_each(:ids) q
+    ) SELECT a.cid AS cid, ${TEXT_SEARCH_COLUMNS} FROM a JOIN nodes ON nodes.id = a.aid AND nodes.valid_to IS NULL`).all({ ids: JSON.stringify(commentIds) });
+    for (const row of rows) out2.set(row.cid, textSearchNode(row));
+    return out2;
+  }
   getTextSearchNode(id) {
     const row = this.db.prepare(`SELECT ${TEXT_SEARCH_COLUMNS} FROM nodes WHERE id = ? AND valid_to IS NULL`).get(id);
     return row ? textSearchNode(row) : null;
@@ -26930,12 +28511,12 @@ var SqliteGraphStore = class {
     return scale;
   }
   typedEdgeStmt(sql) {
-    let stmt = this.typedEdgeStmts.get(sql);
-    if (!stmt) {
-      stmt = this.db.prepare(sql);
-      this.typedEdgeStmts.set(sql, stmt);
+    let stmt2 = this.typedEdgeStmts.get(sql);
+    if (!stmt2) {
+      stmt2 = this.db.prepare(sql);
+      this.typedEdgeStmts.set(sql, stmt2);
     }
-    return stmt;
+    return stmt2;
   }
   outEdges(nodeId, types) {
     if (!types || types.length === 0) {
@@ -26994,21 +28575,54 @@ var SqliteGraphStore = class {
     return out2;
   }
   nodeCount() {
-    return Number(this.stmts.nodeCount.get().n);
+    return this.countAt("nodes", [ANY_CHANGE], () => Number(this.stmts.nodeCount.get().n));
   }
   mutationCount() {
     return this.mutations;
   }
+  changeStamp() {
+    const { data_version } = this.db.pragma("data_version");
+    const { n } = this.db.prepare("SELECT total_changes() AS n").get();
+    return `${data_version}:${n}`;
+  }
+  changeSeq(scopes) {
+    return readChangeSeq(this.db, scopes);
+  }
+  lineageChangedFiles(sinceSeq) {
+    return readLineageChangedFiles(this.db, sinceSeq);
+  }
+  changedNodeIds(sinceSeq, labels) {
+    return readChangedNodeIds(this.db, sinceSeq, labels);
+  }
+  changedAmong(sinceSeq, ids) {
+    return readChangedAmong(this.db, sinceSeq, ids);
+  }
+  pruneChangeLog() {
+    return pruneChangeLog(this.db);
+  }
+  fileRowStates(ids) {
+    if (ids.length === 0) return [];
+    if (ids.length > 500) throw new RangeError("fileRowStates accepts at most 500 ids per read");
+    return this.db.prepare(`SELECT id, last_updated_at AS lastUpdatedAt, valid_to AS validTo FROM nodes WHERE id IN (${ids.map(() => "?").join(",")})`).all(...ids);
+  }
+  // Read and advanced in SQL, never from a per-connection copy: pass workers and
+  // MCP processes open their own connections and advance the same row, so a
+  // copy loaded at open went stale, and `copy + 1` wrote a duplicate or a
+  // backwards seq from whichever connection had fallen behind.
   currentIngestSeq() {
+    const row = this.db.prepare("SELECT value FROM store_meta WHERE key = 'ingest_seq'").get();
+    this.ingestSeq = row ? Number(row.value) : 0;
     return this.ingestSeq;
   }
   nextIngestSeq() {
-    this.ingestSeq += 1;
-    this.stmts.setIngestSeq.run({ v: String(this.ingestSeq) });
+    const row = this.db.prepare(
+      "INSERT INTO store_meta (key, value) VALUES ('ingest_seq', '1') ON CONFLICT(key) DO UPDATE SET value = CAST(value AS INTEGER) + 1 RETURNING value"
+    ).get();
+    this.ingestSeq = Number(row.value);
     return this.ingestSeq;
   }
   edgeCount() {
-    return Number(this.stmts.edgeCount.get().n);
+    return this.countAt("edges", [ANY_CHANGE], () => Number(this.stmts.edgeCount.get().n));
   }
   // Lightweight whole-graph scans — select only the columns the caller needs so a
   // 100k-node pass skips the per-row attrs JSON.parse + embedding decode rowToNode
@@ -27136,28 +28750,63 @@ var SqliteGraphStore = class {
     }
   }
   reviveReobserved(relPaths, workspaceId, since) {
-    let revived = 0;
+    const revived = [];
     const CHUNK = 400;
     for (let i2 = 0; i2 < relPaths.length; i2 += CHUNK) {
       const slice = relPaths.slice(i2, i2 + CHUNK);
       if (slice.length === 0) continue;
-      const r = this.db.prepare(
-        `UPDATE nodes SET valid_to = NULL
+      const rows = this.db.prepare(
+        `SELECT id, valid_to AS closedAt, COALESCE(logical_id, id) AS lid FROM nodes
              WHERE valid_to IS NOT NULL
                AND last_updated_at >= ?
                AND json_extract(attrs_json, '$.workspaceId') = ?
-               AND json_extract(attrs_json, '$.relPath') IN (${slice.map(() => "?").join(",")})`
-      ).run(since, workspaceId, ...slice);
-      revived += Number(r.changes);
-    }
-    if (revived > 0) this.mutations++;
-    return revived;
+               AND json_extract(attrs_json, '$.relPath') IN (${slice.map(() => "?").join(",")})
+               AND json_type(attrs_json, '$.historical') IS NOT 'true'`
+      ).all(since, workspaceId, ...slice);
+      revived.push(...rows);
+    }
+    if (revived.length === 0) return 0;
+    const reopen = this.db.prepare("UPDATE nodes SET valid_to = NULL WHERE id = ? AND valid_to IS NOT NULL");
+    for (const r of revived) reopen.run(r.id);
+    for (const r of revived) reopenCascadeClosedEdges(this.db, r.id, Number(r.closedAt));
+    collapseLiveHeads(this.db, revived.map((r) => r.lid), since);
+    this.mutations++;
+    return revived.length;
+  }
+  incomingEdgeCoverage(label, edgeTypes, cloudOnly) {
+    if (edgeTypes.length === 0) return { count: 0, total: 0 };
+    const r = this.db.prepare(
+      `SELECT COUNT(*) AS total,
+                COALESCE(SUM(CASE WHEN EXISTS (
+                  SELECT 1 FROM edges e WHERE e.to_id = n.id AND e.valid_to IS NULL
+                    AND e.type IN (${edgeTypes.map(() => "?").join(",")})
+                ) THEN 1 ELSE 0 END), 0) AS count
+           FROM nodes n
+          WHERE n.label = ? AND n.valid_to IS NULL
+            AND (? = 0 OR json_extract(n.attrs_json, '$.source') = 'cloud')`
+    ).get(...edgeTypes, label, cloudOnly ? 1 : 0);
+    return { count: Number(r.count), total: Number(r.total) };
+  }
+  liveEdgeTargets(edgeTypes) {
+    if (edgeTypes.length === 0) return [];
+    const rows = this.db.prepare(`SELECT DISTINCT to_id FROM edges INDEXED BY edges_type WHERE type IN (${edgeTypes.map(() => "?").join(",")}) AND valid_to IS NULL`).all(...edgeTypes);
+    return rows.map((r) => r.to_id);
   }
   recentEdgeAttrCoverage(marker, attr, limit) {
+    if (marker === PRIOR_TAG_MARKER) {
+      const r2 = this.db.prepare(
+        `SELECT COUNT(*) AS total,
+                  COALESCE(SUM(CASE WHEN json_extract(attrs_json, '$.' || ?) = 1 THEN 1 ELSE 0 END), 0) AS count
+             FROM (SELECT attrs_json FROM edges INDEXED BY edges_live_prior_tag
+                    WHERE valid_to IS NULL AND json_extract(attrs_json, '$.priorTag') = 1
+                    ORDER BY created_at DESC LIMIT ?)`
+      ).get(attr, limit);
+      return { count: Number(r2.count), total: Number(r2.total) };
+    }
     const r = this.db.prepare(
       `SELECT COUNT(*) AS total,
                 COALESCE(SUM(CASE WHEN json_extract(attrs_json, '$.' || ?) = 1 THEN 1 ELSE 0 END), 0) AS count
-           FROM (SELECT attrs_json FROM edges
+           FROM (SELECT attrs_json FROM edges INDEXED BY edges_live_created
                   WHERE valid_to IS NULL AND attrs_json LIKE ?
                   ORDER BY created_at DESC LIMIT ?)`
     ).get(attr, `%${marker}%`, limit);
@@ -27170,7 +28819,7 @@ var SqliteGraphStore = class {
       const slice = cloudIds.slice(i2, i2 + CHUNK);
       if (slice.length === 0) continue;
       const rows = this.db.prepare(
-        `SELECT id, json_extract(attrs_json, '$.cloudNodeId') AS cloud FROM nodes INDEXED BY nodes_cloud_node_id WHERE json_extract(attrs_json, '$.cloudNodeId') IN (${slice.map(() => "?").join(",")}) AND valid_to IS NULL ORDER BY id`
+        `SELECT id, json_extract(attrs_json, '$.cloudNodeId') AS cloud FROM nodes INDEXED BY nodes_cloud_node_id_v2 WHERE json_extract(attrs_json, '$.cloudNodeId') IN (${slice.map(() => "?").join(",")}) AND valid_to IS NULL ORDER BY id`
       ).all(...slice);
       for (const r of rows) out2.set(r.cloud, [...out2.get(r.cloud) ?? [], r.id]);
     }
@@ -27283,8 +28932,9 @@ var SqliteGraphStore = class {
     this.stmts.advanceLive.run({ live_id: liveId, t });
     return frozenId;
   }
-  closeNode(id, t) {
-    this.stmts.closeNode.run({ id, t });
+  closeNode(id, t, opts = {}) {
+    const r = this.stmts.closeNode.run({ id, t });
+    if (Number(r.changes) > 0 && !opts.retainEdges) closeIncidentEdges(this.db, id, t);
   }
   closeEdge(id, t) {
     this.stmts.closeEdge.run({ id, t });
@@ -27304,9 +28954,11 @@ var SqliteGraphStore = class {
    *  so it must be a plain identifier. */
   nodesAsOfWhereTrue(t, attr) {
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(attr)) throw new Error(`nodesAsOfWhereTrue: bad attr ${JSON.stringify(attr)}`);
+    const indexed = attr === "revisit" ? " INDEXED BY nodes_revisit_true" : "";
     const rows = this.db.prepare(
-      `SELECT * FROM nodes WHERE valid_from <= :t AND (valid_to IS NULL OR valid_to > :t)
-           AND json_type(attrs_json, '$.${attr}') = 'true'`
+      `SELECT * FROM nodes${indexed} WHERE valid_from <= :t AND (valid_to IS NULL OR valid_to > :t)
+           AND json_type(attrs_json, '$.${attr}') = 'true'
+         ORDER BY rowid`
     ).all({ t });
     return rows.map(rowToNode);
   }
@@ -27390,19 +29042,16 @@ function conditionOf(node) {
 }
 function clearAnsweredRevisits(store2, ts) {
   const report = { cleared: 0, standing: 0 };
-  for (const label of SEMANTIC_NODE_LABELS) {
-    for (const row of store2.findNodeFieldsByLabel(label, ["revisit"])) {
-      if (row.attrs["revisit"] !== 1 && row.attrs["revisit"] !== true) continue;
-      const node = store2.getNode(row.id);
-      if (!node || node.attrs["revisit"] !== true) continue;
-      const condition = conditionOf(node);
-      if (condition === void 0 || !isRevisitAnswered(store2, node, condition)) {
-        report.standing++;
-        continue;
-      }
-      clearRevisit(store2, node.id, ts);
-      report.cleared++;
+  const semantic = new Set(SEMANTIC_NODE_LABELS);
+  for (const node of store2.nodesAsOfWhereTrue(ts, "revisit")) {
+    if (!semantic.has(node.label) || node.validTo != null) continue;
+    const condition = conditionOf(node);
+    if (condition === void 0 || !isRevisitAnswered(store2, node, condition)) {
+      report.standing++;
+      continue;
     }
+    clearRevisit(store2, node.id, ts);
+    report.cleared++;
   }
   return report;
 }
@@ -27566,7 +29215,7 @@ var NAME_SEPARATOR = /[@/\-._]/;
 var MIN_NAME_LEN = 3;
 function buildPackageIndex(store2) {
   const idx = /* @__PURE__ */ new Map();
-  for (const n of store2.findNodesByLabel("Package")) {
+  for (const n of store2.selectNodes({ labels: ["Package"], attrs: ["name", "resolved"] })) {
     const name2 = String(n.attrs["name"] ?? "").trim();
     if (!name2) continue;
     const key = name2.toLowerCase();
@@ -27633,7 +29282,7 @@ function backfillProblemPackageLinks(store2, ts) {
   const report = { problems: 0, edges: 0 };
   const idx = buildPackageIndex(store2);
   if (idx.size === 0) return report;
-  for (const p of store2.findNodesByLabel("Problem")) {
+  for (const p of store2.selectNodes({ labels: ["Problem"], attrs: ["resolvedAs"] })) {
     if (p.attrs["resolvedAs"] === "false_positive") continue;
     const { linked } = linkProblemToPackages(store2, p.id, problemText(store2, p), ts, idx);
     if (linked.length > 0) {
@@ -27673,7 +29322,7 @@ function deriveContextFromAnchors(store2, problemId, ts, pkgIndex) {
   if (!p || p.label !== "Problem" && p.label !== "Vulnerability") return report;
   const files = store2.outEdges(problemId, ["ANCHORED_AT"]).map((e) => store2.getNode(e.to)).filter((n) => !!n && n.label === "File");
   if (files.length === 0) return report;
-  const idx = pkgIndex ?? buildPackageIndex(store2);
+  let idx = pkgIndex;
   const haveLang = new Set(store2.outEdges(problemId, ["OCCURS_IN"]).map((e) => e.to));
   const havePkg = new Set(store2.outEdges(problemId, ["DEPENDS_ON"]).map((e) => e.to));
   for (const file2 of files) {
@@ -27712,7 +29361,7 @@ function deriveContextFromAnchors(store2, problemId, ts, pkgIndex) {
       if (!mod) continue;
       const name2 = specToPackageName(mod.description);
       if (!name2) continue;
-      const pkg = idx.get(name2);
+      const pkg = (idx ??= buildPackageIndex(store2)).get(name2);
       if (!pkg || havePkg.has(pkg.id)) continue;
       addDependency(store2, {
         fromId: problemId,
@@ -27731,7 +29380,7 @@ function deriveContextFromAnchors(store2, problemId, ts, pkgIndex) {
 function backfillProblemContext(store2, ts) {
   const report = { problems: 0, edges: 0 };
   const idx = buildPackageIndex(store2);
-  for (const p of store2.findNodesByLabel("Problem")) {
+  for (const p of store2.selectNodes({ labels: ["Problem"], attrs: ["resolvedAs"] })) {
     if (p.attrs["resolvedAs"] === "false_positive") continue;
     const r = deriveContextFromAnchors(store2, p.id, ts, idx);
     const n = r.languages.length + r.packages.length;
@@ -27757,6 +29406,11 @@ var REDIRECT_EDGES = [
   "MANIFESTED_IN",
   "EVIDENCED_BY"
 ];
+var OPEN_PROBLEM_WHERE = [
+  { attr: "resolvedAt", nullish: true },
+  { attr: "mergedInto", absent: true }
+];
+var OPEN_PROBLEM_KEYS = ["kind", "corroborations"];
 function corroborations(n) {
   return Number(n.attrs["corroborations"] ?? 0);
 }
@@ -27770,7 +29424,7 @@ function mergeDuplicateProblems(store2, opts) {
   const minOverlap = opts.minOverlap ?? 0.85;
   const minTokens = opts.minTokens ?? 4;
   const report = { clusters: 0, merged: 0 };
-  const open = store2.findNodesByLabel("Problem").filter((p) => p.attrs["resolvedAt"] == null && p.attrs["mergedInto"] === void 0);
+  const open = store2.selectNodes({ labels: ["Problem"], attrs: OPEN_PROBLEM_KEYS, where: OPEN_PROBLEM_WHERE });
   const tokens = /* @__PURE__ */ new Map();
   for (const p of open) tokens.set(p.id, new Set(retrievalTokens(p.description)));
   const consumed = /* @__PURE__ */ new Set();
@@ -27794,8 +29448,9 @@ function mergeDuplicateProblems(store2, opts) {
       if (cluster.length < 2) continue;
       report.clusters++;
       cluster.sort((x, y) => corroborations(y) - corroborations(x) || x.createdAt - y.createdAt);
-      const survivor = cluster[0];
-      for (const dup of cluster.slice(1)) {
+      const members = cluster.map((m) => store2.getNode(m.id)).filter((n) => n !== null);
+      const survivor = members[0];
+      for (const dup of members.slice(1)) {
         foldDuplicateProblem(store2, dup, survivor, opts.ts);
         report.merged++;
       }
@@ -27808,16 +29463,19 @@ function foldDuplicateProblem(store2, dup, survivor, ts) {
   if (!surv) return;
   const sources = new Set(surv.attrs["sources"] ?? []);
   for (const s of dup.attrs["sources"] ?? []) sources.add(s);
-  const dupSeq = dup.attrs["createdAtSeq"] ?? store2.currentIngestSeq();
-  const exposure = priorExposure(store2, survivor.id, dupSeq);
-  const expField = `reinforce${exposure[0].toUpperCase()}${exposure.slice(1)}Count`;
+  const samePass = dup.createdAt === surv.createdAt;
+  const [held, restated] = dup.createdAt < surv.createdAt ? [dup, surv] : [surv, dup];
+  const at = {
+    seq: restated.createdAtSeq ?? restated.attrs["createdAtSeq"] ?? store2.currentIngestSeq(),
+    ts: restated.createdAt
+  };
+  const exposure = samePass ? null : priorExposure(store2, held.id, at);
   store2.updateNode(survivor.id, {
     attrs: {
       ...surv.attrs,
       sources: [...sources],
       corroborations: corroborations(surv) + corroborations(dup) + 1,
-      [expField]: (surv.attrs[expField] ?? 0) + 1,
-      lastReinforceExposure: exposure
+      ...exposure ? exposureOutcomeAttrs(surv, exposure, at) : {}
     },
     cumulativeHits: (surv.cumulativeHits ?? 0) + (dup.cumulativeHits ?? 0),
     lastUpdatedAt: ts
@@ -27848,11 +29506,21 @@ function isConstraintProblem(node) {
   return node.attrs["kind"] === "constraint";
 }
 var RECURRENCE_DEBOUNCE_MS = 60 * 60 * 1e3;
-function resolveFileNode(store2, path, workspaceId) {
-  const want = path.trim().replace(/^\.?\//, "");
-  for (const n of store2.findNodesByLabel("File")) {
-    if (n.attrs["workspaceId"] && n.attrs["workspaceId"] !== workspaceId) continue;
-    if (n.attrs["relPath"] === want || n.description === want) return n;
+function resolveFileNode(store2, path2, workspaceId) {
+  const want = path2.trim().replace(/^\.?\//, "");
+  const id = firstFileByPath(store2, want, (a) => !(a["workspaceId"] && a["workspaceId"] !== workspaceId));
+  return id ? store2.getNode(id) : null;
+}
+function firstFileByPath(store2, want, accept) {
+  const byPath = store2.selectNodes({ labels: ["File"], attrs: ["workspaceId"], where: [{ attr: "relPath", eq: want }] }).find((r) => accept(r.attrs))?.id;
+  const described = store2.liveNodesByDescription([want], ["File"]).filter((n) => accept(n.attrs));
+  const byDescription = described.length === 1 ? described[0].id : void 0;
+  if (described.length <= 1 && (byPath === void 0 || byDescription === void 0 || byPath === byDescription)) {
+    return byPath ?? byDescription ?? null;
+  }
+  for (const r of store2.selectNodes({ labels: ["File"], attrs: ["workspaceId", "relPath"] })) {
+    if (!accept(r.attrs)) continue;
+    if (r.attrs["relPath"] === want || r.description === want) return r.id;
   }
   return null;
 }
@@ -27868,13 +29536,8 @@ function isAutoMinted(n) {
 }
 function priorsForFile(store2, relPath) {
   const want = relPath.trim().replace(/^\.?\//, "");
-  let file2 = null;
-  for (const n of store2.findNodesByLabel("File")) {
-    if (n.description === want || n.attrs["relPath"] === want) {
-      file2 = n;
-      break;
-    }
-  }
+  const fileId = firstFileByPath(store2, want, () => true);
+  const file2 = fileId ? store2.getNode(fileId) : null;
   if (!file2) return null;
   const openProblems = [];
   const constraints = [];
@@ -28064,10 +29727,10 @@ function openAnchorHint(p) {
   if (!h || typeof h.path !== "string" || h.upgradedAt) return null;
   return { path: h.path, ts: typeof h.ts === "number" ? h.ts : 0 };
 }
-function consumeAnchorHint(store2, p, ts) {
+function consumeAnchorHint(store2, p, ts, pkgIndex) {
   const hint = p.attrs["anchorHint"];
   store2.updateNode(p.id, { attrs: { ...p.attrs, anchorHint: { ...hint, upgradedAt: ts } } });
-  deriveContextFromAnchors(store2, p.id, ts);
+  deriveContextFromAnchors(store2, p.id, ts, pkgIndex);
 }
 function upgradeAnchorHints(store2, workspaceId, ts) {
   let upgraded = 0;
@@ -28075,14 +29738,21 @@ function upgradeAnchorHints(store2, workspaceId, ts) {
   let unresolvable = 0;
   let blocked = 0;
   const filesByPath = /* @__PURE__ */ new Map();
-  for (const f of store2.findNodesByLabel("File")) {
+  for (const f of store2.selectNodes({ labels: ["File"], attrs: ["workspaceId", "relPath", "contentChangedAt"] })) {
     if (f.attrs["workspaceId"] && f.attrs["workspaceId"] !== workspaceId) continue;
     const rel = typeof f.attrs["relPath"] === "string" ? f.attrs["relPath"] : f.description;
     if (rel && !filesByPath.has(rel)) filesByPath.set(rel, f);
   }
-  for (const p of store2.findNodesByLabel("Problem")) {
-    if (p.validTo != null || p.attrs["resolvedAt"]) continue;
-    const hint = openAnchorHint(p);
+  let pkgIndex;
+  const hinted = store2.selectNodes({
+    labels: ["Problem"],
+    attrs: ["resolvedAt", "anchorHint"],
+    where: [{ attr: "anchorHint", notNullish: true }],
+    indexedBy: "nodes_live_anchor_hint"
+  });
+  for (const row of hinted) {
+    if (row.attrs["resolvedAt"]) continue;
+    const hint = openAnchorHint(row);
     if (!hint) continue;
     const file2 = filesByPath.get(hint.path.trim().replace(/^\.?\//, ""));
     if (!file2 || !isAnchorableCodePath(hint.path)) {
@@ -28092,8 +29762,10 @@ function upgradeAnchorHints(store2, workspaceId, ts) {
     standing++;
     const changedAt = Number(file2.attrs["contentChangedAt"] ?? 0);
     if (changedAt <= hint.ts) continue;
+    const p = store2.getNode(row.id);
+    if (!p) continue;
     if (anchorProblemToWorkingFile(store2, p.id, hint.path, workspaceId, ts, "hint-confirmed")) {
-      consumeAnchorHint(store2, p, ts);
+      consumeAnchorHint(store2, p, ts, pkgIndex ??= buildPackageIndex(store2));
       upgraded++;
       standing--;
     } else {
@@ -28104,7 +29776,13 @@ function upgradeAnchorHints(store2, workspaceId, ts) {
 }
 function reopenAutoClosedProblems(store2, t) {
   const report = { reopened: 0, alreadySuspect: 0, agentDescribed: 0 };
-  for (const p of store2.findNodesByLabel("Problem")) {
+  const closed = store2.selectNodes({
+    labels: ["Problem"],
+    attrs: ["resolvedAt", "resolvedAs", "mergedInto", "resolutionWitnessed", "retiredEditPlaceholder", "resolutionSuspect"],
+    where: [{ attr: "resolvedAt", notNullish: true }, { attr: "resolvedAs", nullish: true }, { attr: "mergedInto", absent: true }],
+    indexedBy: "nodes_live_resolved"
+  });
+  for (const p of closed) {
     if (p.attrs["resolvedAt"] == null) continue;
     if (p.attrs["resolvedAs"] != null) continue;
     if (p.attrs["mergedInto"] !== void 0) continue;
@@ -28119,7 +29797,9 @@ function reopenAutoClosedProblems(store2, t) {
       continue;
     }
     if (p.attrs["resolutionSuspect"] === true) report.alreadySuspect++;
-    const attrs = { ...p.attrs };
+    const node = store2.getNode(p.id);
+    if (!node) continue;
+    const attrs = { ...node.attrs };
     delete attrs["resolvedAt"];
     attrs["reopenedFrom"] = "auto-close";
     attrs["reopenedAt"] = t;
@@ -28130,7 +29810,12 @@ function reopenAutoClosedProblems(store2, t) {
 }
 function markFixCandidates(store2, t) {
   let resolved = 0;
-  for (const p of store2.findNodesByLabel("Problem")) {
+  const candidates = store2.selectNodes({
+    labels: ["Problem"],
+    attrs: ["resolvedAt", "kind", "fixCandidateClearedAt", "fixCandidateAt"],
+    where: [{ idPrefix: "dprob_" }]
+  });
+  for (const p of candidates) {
     if (!p.id.startsWith("dprob_")) continue;
     if (p.attrs["resolvedAt"]) continue;
     if (isConstraintProblem(p)) continue;
@@ -28157,9 +29842,11 @@ function markFixCandidates(store2, t) {
       return s !== null && !String(s.description ?? "").startsWith(AUTO_MINT_PREFIX);
     }))
       continue;
+    const node = store2.getNode(p.id);
+    if (!node) continue;
     store2.updateNode(p.id, {
       attrs: {
-        ...p.attrs,
+        ...node.attrs,
         // The cue, kept as structured data so the render can name the file it is
         // asking about. Deliberately NOT `resolvedAt` — this is a question.
         fixCandidateAt: t,
@@ -28169,7 +29856,7 @@ function markFixCandidates(store2, t) {
         // measurable. `shownCount` is the node's LIFETIME count across every
         // band, so comparing it raw would retire a fresh ask on a
         // frequently-surfaced problem before anyone had seen the question once.
-        fixCandidateShownBase: Number(p.attrs["shownCount"] ?? 0)
+        fixCandidateShownBase: Number(node.attrs["shownCount"] ?? 0)
       }
       // No `lastUpdatedAt`: raising a question is bookkeeping, not a new
       // observation of the problem, and the passive block's recent-problems band
@@ -28182,7 +29869,10 @@ function markFixCandidates(store2, t) {
 var FIX_CANDIDATE_ASK_LIMIT = 5;
 function clearSettledFixCandidates(store2, t) {
   const report = { answered: 0, ignored: 0, unsubstantiated: 0, standing: 0 };
-  for (const p of store2.findNodesByLabel("Problem")) {
+  const asked = store2.selectNodes({ labels: ["Problem"], where: [{ attr: "fixCandidateAt", present: true }], indexedBy: "nodes_live_fix_candidate" });
+  for (const row of asked) {
+    const p = store2.getNode(row.id);
+    if (!p) continue;
     if (p.attrs["fixCandidateAt"] === void 0) continue;
     const fileAnchors = store2.outEdges(p.id, ["ANCHORED_AT"]).filter((e) => e.attrs?.["mention"] !== true && e.attrs?.["anchorProvenance"] !== "legacy").map((e) => store2.getNode(e.to)).filter((n) => n !== null && n.label === "File");
     const unsubstantiated = fileAnchors.length > 0 && fileAnchors.every((f) => f.attrs["contentChangedAt"] === void 0);
@@ -28211,16 +29901,77 @@ function clearSettledFixCandidates(store2, t) {
   }
   return report;
 }
-function priorExposure(store2, nodeId, atSeq) {
+function exposureLog(attrs) {
+  const raw = attrs["exposureLog"];
+  if (!Array.isArray(raw)) return [];
+  return raw.filter(
+    (e) => Array.isArray(e) && typeof e[0] === "number" && (e[1] === "r" || e[1] === "c" || e[1] === "e")
+  );
+}
+function priorExposure(store2, nodeId, at) {
   const n = store2.getNode(nodeId);
   if (!n || !n.attrs) return "unshown";
-  const shownSeq = n.attrs["lastShownAtSeq"];
-  if (shownSeq !== void 0 && shownSeq <= atSeq) return "shown";
-  const evictedSeq = n.attrs["lastEvictedAtSeq"];
-  if (evictedSeq !== void 0 && evictedSeq <= atSeq) return "evicted";
-  if ((n.attrs["evictedCount"] ?? 0) > 0) return "evicted";
+  const a = n.attrs;
+  const num2 = (k) => typeof a[k] === "number" ? a[k] : void 0;
+  const since = num2("lastOutcomeAt");
+  const outOfOrder = since !== void 0 && at.ts <= since;
+  const lo = outOfOrder || since === void 0 ? -Infinity : since;
+  const kinds = ["r", "c", "e"];
+  const seen = { r: false, c: false, e: false };
+  const maybe = { r: outOfOrder, c: outOfOrder, e: outOfOrder };
+  for (const [t, kind] of exposureLog(a)) if (t > lo && t <= at.ts) seen[kind] = true;
+  const logSince = num2("exposureLogSince");
+  const trimmed = a["exposureTrimmed"] ?? {};
+  if (logSince !== void 0 && lo < logSince) {
+    for (const k of kinds) {
+      const t = trimmed[k];
+      if (typeof t !== "number" || t <= lo) continue;
+      if (t <= at.ts) seen[k] = true;
+      else maybe[k] = true;
+    }
+  }
+  const firstShownAt = num2("firstShownAt");
+  const firstEvictedAt = num2("firstEvictedAt");
+  const legacyShowSeq = num2("firstShownAtSeq") ?? num2("lastShownAtSeq");
+  const legacyShown = firstShownAt === 0 || firstShownAt === void 0 && legacyShowSeq !== void 0;
+  const legacyEvicted = firstEvictedAt === 0 || firstEvictedAt === void 0 && (num2("lastEvictedAtSeq") !== void 0 || (num2("evictedCount") ?? 0) > 0);
+  const logStart = num2("exposureLogStart");
+  const beforeLog = logStart === void 0 || lo < logStart;
+  if (beforeLog && legacyShown) maybe.r = true;
+  if (beforeLog && legacyEvicted) maybe.e = true;
+  const first = a["exposureFirst"] ?? {};
+  const legacyBy = (seq) => logStart !== void 0 && at.ts >= logStart ? true : seq !== void 0 && seq <= at.seq;
+  const happenedBy = {
+    r: typeof first["r"] === "number" && first["r"] <= at.ts || legacyShown && legacyBy(legacyShowSeq),
+    c: typeof first["c"] === "number" && first["c"] <= at.ts,
+    e: typeof first["e"] === "number" && first["e"] <= at.ts || legacyEvicted && (legacyBy(num2("lastEvictedAtSeq")) || a["lastEvictedAtSeq"] === void 0 && (num2("evictedCount") ?? 0) > 0)
+  };
+  const present = (k) => seen[k] || maybe[k] && happenedBy[k];
+  if (present("r")) return "shown";
+  if (present("c")) return "recent";
+  if (present("e")) return "evicted";
   return "unshown";
 }
+function passivelyShowable(n) {
+  const quality = n.attrs["historyQuality"];
+  const evaluatedAt = quality && typeof quality === "object" ? quality["evaluatedAtCommit"] : void 0;
+  return historyReadPolicy(n, {
+    mode: "passive",
+    atCommit: typeof evaluatedAt === "string" ? evaluatedAt : void 0
+  }).allow;
+}
+function exposureOutcomeAttrs(node, exposure, at) {
+  const attrs = node.attrs;
+  const field = `reinforce${exposure[0].toUpperCase()}${exposure.slice(1)}Count`;
+  const prev = attrs["lastOutcomeAt"];
+  const queryOnly = exposure === "unshown" && !passivelyShowable(node);
+  return {
+    [field]: (attrs[field] ?? 0) + 1,
+    ...queryOnly ? { reinforceUnshownQueryOnlyCount: (attrs["reinforceUnshownQueryOnlyCount"] ?? 0) + 1 } : {},
+    lastReinforceExposure: exposure,
+    lastOutcomeAt: typeof prev === "number" ? Math.max(prev, at.ts) : at.ts
+  };
+}
 
 // ../../packages/local-graph/src/intent.ts
 init_src();
@@ -28237,9 +29988,9 @@ var STATEMENT_PATH_RE = new RegExp(
 );
 function filePathResolver(store2) {
   const byPath = /* @__PURE__ */ new Map();
-  for (const f of store2.findNodesByLabel("File")) {
-    const path = String(f.attrs["relPath"] ?? f.description ?? "");
-    if (path) byPath.set(path, { id: f.id, path });
+  for (const f of store2.selectNodes({ labels: ["File"], attrs: ["relPath"] })) {
+    const path2 = String(f.attrs["relPath"] ?? f.description ?? "");
+    if (path2) byPath.set(path2, { id: f.id, path: path2 });
   }
   return (named) => {
     const exact = byPath.get(named);
@@ -28283,7 +30034,7 @@ function repairLegacyAnchorsFromStatement(store2, ts) {
     alreadyCorrect: 0
   };
   const resolvePath = filePathResolver(store2);
-  for (const p of store2.findNodesByLabel("Problem")) {
+  for (const p of store2.selectNodes({ labels: ["Problem"] })) {
     try {
       const anchors = store2.outEdges(p.id, ["ANCHORED_AT"]);
       const legacy = anchors.filter((e) => e.attrs?.["anchorProvenance"] === "legacy");
@@ -28347,10 +30098,12 @@ function backfillLegacyAnchors(store2, ts) {
     suspects: []
   };
   let resolvePath;
-  for (const p of store2.findNodesByLabel("Problem")) {
-    const resolved = p.attrs["resolvedAt"] !== void 0;
-    const legacy = store2.outEdges(p.id, ["ANCHORED_AT"]).filter((e) => isLegacyAnchor(e.attrs) || !resolved && e.attrs?.["anchorProvenance"] === "legacy");
+  for (const row of store2.selectNodes({ labels: ["Problem"], attrs: ["resolvedAt"] })) {
+    const resolved = row.attrs["resolvedAt"] !== void 0;
+    const legacy = store2.outEdges(row.id, ["ANCHORED_AT"]).filter((e) => isLegacyAnchor(e.attrs) || !resolved && e.attrs?.["anchorProvenance"] === "legacy");
     if (legacy.length === 0) continue;
+    const p = store2.getNode(row.id);
+    if (!p) continue;
     try {
       if (!resolved) {
         resolvePath ??= filePathResolver(store2);
@@ -28365,8 +30118,8 @@ function backfillLegacyAnchors(store2, ts) {
         const retired = legacy.filter((e) => !(target && e.to === target.id));
         for (const e of retired) {
           const file2 = store2.getNode(e.to);
-          const path = String(file2?.attrs["relPath"] ?? file2?.description ?? "");
-          if (path) recordAnchorHint(store2, p.id, path, "legacy", ts);
+          const path2 = String(file2?.attrs["relPath"] ?? file2?.description ?? "");
+          if (path2) recordAnchorHint(store2, p.id, path2, "legacy", ts);
           store2.closeEdge(e.id, ts);
           report.demotedEdges++;
         }
@@ -28491,7 +30244,7 @@ function detectLocalCommunities(store2, opts = {}) {
     for (const n of unowned) {
       const pulled = n.attrs["source"] === "cloud";
       const clearColumn = !!n.community && !pulled;
-      if (n.attrs["localCommunity"] === void 0 && !clearColumn) continue;
+      if (n.attrs["localCommunity"] == null && !clearColumn) continue;
       store2.setLocalCommunity(n.id, null, clearColumn);
       if (clearColumn) report.cleared++;
     }
@@ -28559,13 +30312,13 @@ function detectLocalCommunities(store2, opts = {}) {
 // ../../packages/local-graph/src/tools.ts
 init_src();
 function rankToolsForHandles(store2, limit = 5) {
-  const scored = store2.findNodesByLabel("Tool").map((node) => ({
-    node,
-    concerns: store2.inEdges(node.id, ["CONCERNS"]).length,
-    hits: node.cumulativeHits ?? 0
+  const scored = store2.selectNodes({ labels: ["Tool"] }).map((row) => ({
+    id: row.id,
+    concerns: store2.inEdges(row.id, ["CONCERNS"]).length,
+    hits: row.cumulativeHits ?? 0
   }));
   scored.sort((a, b) => b.concerns - a.concerns || b.hits - a.hits);
-  return scored.slice(0, Math.max(0, limit)).map((s) => s.node);
+  return scored.slice(0, Math.max(0, limit)).map((s) => store2.getNode(s.id)).filter((n) => n !== null);
 }
 
 // ../../packages/local-graph/src/principle-sync.ts
@@ -28621,6 +30374,7 @@ var MECHANISMS = [
   },
   {
     id: "fix-candidate-ask",
+    requiresNodes: ["Problem"],
     what: "asks an agent whether an edit to a problem's anchor fixed it",
     pass: "semantic-maintenance",
     // markFixCandidates fails CLOSED on a File anchor with no contentChangedAt —
@@ -28672,7 +30426,12 @@ var MECHANISMS = [
       // the producer was verifiably stamping every new node.
       minFraction: 0.9,
       recent: 200,
-      sinceFirstStamp: true
+      sinceFirstStamp: true,
+      // The anchor-feed pull lands cloud mirrors by the hundreds every ten
+      // minutes (createdAt = pull time, no local seq — stamping them would age
+      // every local node by Δseq). On 2026-10-09 1,146 mirrors in a few hours
+      // dragged this to 62% and toasted "ingest-sequence DEAD" with effect 41.
+      localOnly: true
     },
     effectCounter: "seqAdvanced",
     note: "column, not attr; measured over nodes born since the first stamp in the recent window"
@@ -28710,6 +30469,28 @@ var MECHANISMS = [
     // climbs while `accepted` stays flat is the shape of a silently-closed door.
     backlogCounter: "candidates"
   },
+  {
+    id: "edge-park-replay",
+    what: "parks causal/anchor edges the door refused as unresolvable, replays them when due, drops them with a disposition",
+    pass: "ship",
+    // FED = a source whose whole binding-edge family LANDED: the digest is
+    // stamped only when every edge in it came back created/reinforced, so it is
+    // the store-side proof that edges (not just nodes) cross. Live dev
+    // 2026-10-12 sat with the same 241 refusals re-sent every drain and this
+    // stamp frozen — nodes crossed, their causal wiring did not.
+    fed: {
+      labels: ["Problem", "RootCause"],
+      attr: "semanticEdgesContributedDigest",
+      minFraction: 0.01
+    },
+    // A parked edge that later LANDED — the replay doing its job.
+    effectCounter: "edgesReplayLanded",
+    // Outstanding parked edges (a level). Flat-and-nonzero while replays keep
+    // re-parking is an endpoint that never resolves; it drains to tombstones
+    // (`edgesDroppedExhausted`) instead of being resent forever.
+    backlogCounter: "edgeParkSize",
+    note: "edge-park.ts; quiet (no-effect) is healthy when nothing is refused \u2014 read edgesParked/edgesDropped* on the ship row"
+  },
   {
     id: "orphan-reap",
     what: "closes File nodes whose path the indexer no longer covers",
@@ -28764,12 +30545,31 @@ var MECHANISMS = [
     // the bar is "the field is written at all", the revisit-sweep precedent.
     fed: { labels: ["Problem"], attr: "foldCandidate", minFraction: 0 },
     effectCounter: "folded",
-    // Standing nominations ARE the judge-less backlog — without the gauge a
-    // deployment with no judge configured reads as "nothing to fold".
-    backlogCounter: "standing",
+    // The open-nomination POOL is the backlog. It used to be `standing`, which
+    // only counts what the pass examined — capped at the per-run limit — so it
+    // read a flat 8 for weeks while 824 nominations sat open (2026-10-12): the
+    // gauge could not see past the slice it was meant to be measuring.
+    backlogCounter: "pending",
     configCounter: "judgeConfigured",
     note: "the ambiguous band needs the opt-in judge: set ERRATA_FOLD_JUDGE=1 + a configured chat provider (azure env), or leave it off and the nominations stand"
   },
+  {
+    id: "fold-candidate-coverage",
+    what: "rotates the fold-judge pass through every open nomination (never-examined first, standing ones re-examined on new evidence)",
+    // Judge-INDEPENDENT on purpose — no configCounter. The embedding-certain
+    // bands fold/reject with no judge at all, and the defect this watches is
+    // the pass re-reading the same oldest 8 forever (101 runs, 8 distinct
+    // nodes, 816 of 824 nominations never looked at). That starves those
+    // bands on a judge-less daemon exactly as much as on a judged one, so an
+    // opt-in being off must not excuse it.
+    pass: "fold-judge",
+    fed: { labels: ["Problem"], attr: "foldCandidate", minFraction: 0 },
+    effectCounter: "firstExamined",
+    // A LEVEL: open nominations never examined. Flat-and-positive with no
+    // first examinations across the stall window = the rotation is stuck.
+    backlogCounter: "neverExamined",
+    note: "neverExamined must drain while the pass runs; flat means the selection is re-reading the same slice"
+  },
   {
     id: "cite-anchor-accrual",
     what: "accrues cite-context anchor evidence on anchorless cited priors; two distinct sessions promote a cite-confirmed ANCHORED_AT",
@@ -28817,6 +30617,7 @@ var MECHANISMS = [
   },
   {
     id: "liveness-watch",
+    inputOptional: true,
     what: "the daemon-side schedule of this very verdict \u2014 alarms when a mechanism stops working",
     // The watcher is itself a row: a probe that only runs when a human remembers
     // is how the original six defects shipped, and a scheduled watch that
@@ -28831,12 +30632,46 @@ var MECHANISMS = [
     // reading is IDLE — correct, and it declares no backlog on purpose.
     effectCounter: "alarms",
     note: "steady-state IDLE is healthy; the row exists for its invocation age"
+  },
+  {
+    id: "project-causal-sync",
+    what: "lands the cloud project stratum's SOLVED_BY/FIXED_BY edges onto the knowledge the anchor feed mirrors",
+    // PRODUCER: the anchor feed's causal leg — `fetchProjectAnchors` returns the
+    // edges, `syncProjectAnchors` (apps/daemon/src/project-reanchor.ts) lands or
+    // parks them, on the `anchor-pull` beat. CONSUMERS: every local walk that
+    // crosses Problem→Solution — errata_trace/why/burst over the store, and the
+    // passive priming block that renders a problem with its fix. Before
+    // PJ-sync-causal the feed mirrored 5,054 cloud Solutions on the dev checkout
+    // with not one incoming SOLVED_BY: this row would have read 0.0% for months.
+    pass: "anchor-pull",
+    fedIncoming: { label: "Solution", edgeTypes: ["SOLVED_BY", "FIXED_BY"], cloudOnly: true, minFraction: 0.5 },
+    effectCounter: "edgesLanded",
+    // Parked edges waiting on an endpoint — a flat, non-zero backlog is a stratum
+    // whose other ends never arrive here (a cap, or a gate that refuses them).
+    backlogCounter: "edgesPending",
+    requiresNodes: ["Problem"],
+    note: "an orphaned cloud Solution reads as a fix with no problem; the one-time causal re-walk lifts this after the server ships the leg"
   }
 ];
 var COLUMN_INPUTS = {
   __createdAtSeq: (n) => n.createdAtSeq !== void 0 && n.createdAtSeq !== null
 };
-function evaluateFed(store2, d) {
+function evaluateFed(store2, d, stamps) {
+  const incomingRows = d.fedIncoming && store2.liveEdgeTargets ? stamps?.(d.fedIncoming.label, "source") : void 0;
+  if (d.fedIncoming && incomingRows) {
+    const targets = new Set(store2.liveEdgeTargets(d.fedIncoming.edgeTypes));
+    const rows = d.fedIncoming.cloudOnly ? incomingRows.filter((r) => r.cloud) : incomingRows;
+    const count2 = rows.filter((r) => targets.has(r.id)).length;
+    return { count: count2, total: rows.length, fraction: rows.length === 0 ? 0 : count2 / rows.length };
+  }
+  if (d.fedIncoming) {
+    const { count: count2, total } = store2.incomingEdgeCoverage?.(
+      d.fedIncoming.label,
+      d.fedIncoming.edgeTypes,
+      d.fedIncoming.cloudOnly
+    ) ?? { count: 0, total: 0 };
+    return { count: count2, total, fraction: total === 0 ? 0 : count2 / total };
+  }
   if (d.fedEdges) {
     const { count: count2, total } = store2.recentEdgeAttrCoverage(
       d.fedEdges.marker,
@@ -28846,10 +30681,12 @@ function evaluateFed(store2, d) {
     return { count: count2, total, fraction: total === 0 ? 0 : count2 / total };
   }
   if (!d.fed) return { count: 0, total: 0, fraction: 0 };
-  const column = COLUMN_INPUTS[d.fed.attr];
+  const column2 = COLUMN_INPUTS[d.fed.attr];
   const fed = d.fed;
-  const nodes = fed.labels.flatMap((label) => store2.findNodeStampsByLabel ? store2.findNodeStampsByLabel(label, fed.attr) : store2.findNodeAttrsByLabel(label));
-  const has = (n) => column ? column(n) : n.has ?? n.attrs?.[fed.attr] !== void 0;
+  const all = fed.labels.flatMap((label) => stamps?.(label, fed.attr) ?? (store2.findNodeStampsByLabel ? store2.findNodeStampsByLabel(label, fed.attr) : store2.findNodeAttrsByLabel(label)));
+  const isCloudMirror = (n) => n.cloud ?? n.attrs?.["source"] === "cloud";
+  const nodes = fed.localOnly ? all.filter((n) => !isCloudMirror(n)) : all;
+  const has = (n) => column2 ? column2(n) : n.has ?? n.attrs?.[fed.attr] !== void 0;
   let window2 = nodes;
   if (fed.recent !== void 0) {
     window2 = [...nodes].sort((a, b) => b.createdAt - a.createdAt).slice(0, fed.recent);
@@ -28864,8 +30701,21 @@ function evaluateFed(store2, d) {
   return { count, total: window2.length, fraction: window2.length === 0 ? 0 : count / window2.length };
 }
 function evaluateMechanisms(store2, invocations = /* @__PURE__ */ new Map(), mechanisms = MECHANISMS) {
+  const counts = /* @__PURE__ */ new Map();
+  const count = (label) => {
+    if (!counts.has(label)) counts.set(label, store2.countNodesByLabel(label));
+    return counts.get(label);
+  };
+  const wanted = /* @__PURE__ */ new Map();
+  for (const d of mechanisms) for (const l of d.fed?.labels ?? []) wanted.set(l, (wanted.get(l) ?? /* @__PURE__ */ new Set()).add(d.fed.attr));
+  for (const d of mechanisms) if (d.fedIncoming) wanted.set(d.fedIncoming.label, (wanted.get(d.fedIncoming.label) ?? /* @__PURE__ */ new Set()).add("source"));
+  const byLabel = /* @__PURE__ */ new Map();
+  const stamps = store2.findNodeStampsByLabelAttrs ? (label, attr) => {
+    if (!byLabel.has(label)) byLabel.set(label, store2.findNodeStampsByLabelAttrs(label, [...wanted.get(label) ?? [attr]]));
+    return byLabel.get(label).get(attr);
+  } : void 0;
   return mechanisms.map((d) => {
-    const fed = evaluateFed(store2, d);
+    const fed = evaluateFed(store2, d, stamps);
     const inv = invocations.get(d.pass);
     const effectCount = d.effectIsLevel ? Math.max(
       0,
@@ -28876,9 +30726,12 @@ function evaluateMechanisms(store2, invocations = /* @__PURE__ */ new Map(), mec
     const span = inv?.firstTs === void 0 ? 0 : inv.lastTs - inv.firstTs;
     const stalled = backlog !== void 0 && backlog > 0 && effectCount === 0 && (inv?.runs ?? 0) >= STALL_MIN_RUNS && span >= STALL_MIN_SPAN_MS && (backlogWas === void 0 || backlog >= backlogWas);
     let verdict;
-    if (!inv || inv.runs === 0) verdict = "never-invoked";
-    else if (d.configCounter && inv.lastTotals?.[d.configCounter] === 0) verdict = "unconfigured";
-    else if (fed.fraction < (d.fedEdges?.minFraction ?? d.fed?.minFraction ?? 0)) verdict = "starved";
+    const hasInput = fed.total > 0 || Boolean(d.fed?.sinceFirstStamp && d.fed.labels.some((label) => count(label) > 0));
+    const missingRequiredNodes = d.requiresNodes?.some((label) => count(label) === 0) ?? false;
+    if (d.configCounter && inv?.lastTotals?.[d.configCounter] === 0) verdict = "unconfigured";
+    else if ((backlog ?? 0) === 0 && (!hasInput && !d.inputOptional || missingRequiredNodes)) verdict = "no-input";
+    else if (!inv || inv.runs === 0) verdict = "never-invoked";
+    else if (fed.fraction < minFractionOf(d)) verdict = "starved";
     else if (stalled) verdict = "stalled";
     else if (effectCount === 0) verdict = "no-effect";
     else verdict = "ok";
@@ -28889,7 +30742,7 @@ function evaluateMechanisms(store2, invocations = /* @__PURE__ */ new Map(), mec
       fedCount: fed.count,
       fedTotal: fed.total,
       fedFraction: fed.fraction,
-      minFraction: d.fedEdges?.minFraction ?? d.fed?.minFraction ?? 0,
+      minFraction: minFractionOf(d),
       ...inv ? { lastInvokedMs: inv.lastTs } : {},
       runs: inv?.runs ?? 0,
       effectCount,
@@ -28901,57 +30754,8 @@ function evaluateMechanisms(store2, invocations = /* @__PURE__ */ new Map(), mec
     };
   });
 }
-
-// ../../packages/local-graph/src/wm-calibration.ts
-var WM_CALIBRATION_LABELS = [
-  "Problem",
-  "Solution",
-  "RootCause",
-  "Pattern",
-  "Technique",
-  "AntiPattern"
-];
-var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
-var WM_CALIBRATION_KEYS = [
-  "shownCount",
-  "evictedCount",
-  "reinforceShownCount",
-  "reinforceEvictedCount",
-  "reinforceUnshownCount"
-];
-function wmCalibrationCells(store2) {
-  const cells = {
-    shownNodes: 0,
-    shownImpressions: 0,
-    evictedNodes: 0,
-    evictedImpressions: 0,
-    reinforceShown: 0,
-    reinforceEvicted: 0,
-    reinforceUnshown: 0,
-    reinforcedNodes: 0
-  };
-  for (const label of WM_CALIBRATION_LABELS) {
-    for (const n of store2.findNodeFieldsByLabel(label, WM_CALIBRATION_KEYS)) {
-      const shown = num(n.attrs["shownCount"]);
-      const evicted = num(n.attrs["evictedCount"]);
-      if (shown > 0) {
-        cells.shownNodes++;
-        cells.shownImpressions += shown;
-      }
-      if (evicted > 0) {
-        cells.evictedNodes++;
-        cells.evictedImpressions += evicted;
-      }
-      const rs = num(n.attrs["reinforceShownCount"]);
-      const re = num(n.attrs["reinforceEvictedCount"]);
-      const ru = num(n.attrs["reinforceUnshownCount"]);
-      cells.reinforceShown += rs;
-      cells.reinforceEvicted += re;
-      cells.reinforceUnshown += ru;
-      if (rs + re + ru > 0) cells.reinforcedNodes++;
-    }
-  }
-  return cells;
+function minFractionOf(d) {
+  return d.fedIncoming?.minFraction ?? d.fedEdges?.minFraction ?? d.fed?.minFraction ?? 0;
 }
 
 // ../../packages/generalizer/src/generalizer.ts
@@ -29036,14 +30840,12 @@ function promoteMotifs(store2, t) {
   }
   report.communities = byCommunity.size;
   const existing = /* @__PURE__ */ new Map();
-  for (const label of MOTIF_LABELS) {
-    for (const node of store2.findNodesByLabel(label)) {
-      if (!node.id.startsWith("motif_")) continue;
-      const edges = store2.inEdges(node.id, ["INSTANCE_OF"]).filter(isDerived);
-      const remembered = node.attrs["memberIds"];
-      const members = new Set(Array.isArray(remembered) ? remembered : edges.map((e) => e.from));
-      existing.set(node.id, { node, edges, members });
-    }
+  for (const row of store2.selectNodes({ labels: MOTIF_LABELS, where: [{ idPrefix: "motif_" }] })) {
+    const node = store2.getNode(row.id);
+    const edges = store2.inEdges(node.id, ["INSTANCE_OF"]).filter(isDerived);
+    const remembered = node.attrs["memberIds"];
+    const members = new Set(Array.isArray(remembered) ? remembered : edges.map((e) => e.from));
+    existing.set(node.id, { node, edges, members });
   }
   const pairs = [];
   for (const [cid, members] of byCommunity) {
@@ -29484,24 +31286,129 @@ var AGENTS_POINTER_BODY = [
 // ../../packages/context-writer/src/render.ts
 init_src2();
 init_src();
+
+// ../../packages/context-writer/src/snapshot-inputs.ts
+var SNAPSHOT_NODE_LABELS = [
+  "Problem",
+  "Vulnerability",
+  "Solution",
+  "Pattern",
+  "Technique",
+  "AntiPattern",
+  "Language",
+  "Package",
+  "Tool"
+];
+var SNAPSHOT_EDGE_TYPES = [
+  "ANCHORED_AT",
+  "CAUSED_BY",
+  "CONCERNS",
+  "DEPENDS_ON",
+  "EVIDENCED_BY",
+  "MANIFESTED_IN",
+  "OCCURS_IN",
+  "PERTAIN_TO",
+  "REGRESSION_OF",
+  "SOLVED_BY"
+];
+var SNAPSHOT_READ_GUARD = typeof process !== "undefined" && Boolean(process.env["VITEST"]);
+var LABELS = new Set(SNAPSHOT_NODE_LABELS);
+var EDGES = new Set(SNAPSHOT_EDGE_TYPES);
+function guardSnapshotReads(store2) {
+  const fail = (what) => {
+    throw new Error(`buildSnapshot read ${what}, outside SNAPSHOT_NODE_LABELS/SNAPSHOT_EDGE_TYPES (snapshot-inputs.ts)`);
+  };
+  const label = (l, via) => {
+    if (typeof l === "string" && !LABELS.has(l)) fail(`label ${l} via ${via}`);
+  };
+  const types = (t, via) => {
+    if (!Array.isArray(t) || t.length === 0) fail(`every edge type via ${via}`);
+    for (const x of t) if (!EDGES.has(String(x))) fail(`edge type ${String(x)} via ${via}`);
+  };
+  const nodes = (r, via) => {
+    for (const n of Array.isArray(r) ? r : r ? [r] : []) label(n.label, via);
+    return r;
+  };
+  const allowed = {
+    getNode: (id) => nodes(store2.getNode(id), "getNode"),
+    selectNodes: (q) => {
+      for (const l of q.labels) label(l, "selectNodes");
+      return store2.selectNodes(q);
+    },
+    countNodes: (q) => {
+      for (const l of q.labels) label(l, "countNodes");
+      return store2.countNodes(q);
+    },
+    findLiveNodesByAttr: (l, ...rest) => {
+      label(l, "findLiveNodesByAttr");
+      return store2.findLiveNodesByAttr(l, ...rest);
+    },
+    outEdges: (id, t) => {
+      types(t, "outEdges");
+      return store2.outEdges(id, t);
+    },
+    inEdges: (id, t) => {
+      types(t, "inEdges");
+      return store2.inEdges(id, t);
+    },
+    inDegreeByType: (t) => {
+      types(t, "inDegreeByType");
+      return store2.inDegreeByType(t);
+    },
+    nodesAsOfWhereTrue: (asOf, attr) => {
+      if (attr !== "revisit") fail(`nodesAsOfWhereTrue(${String(attr)})`);
+      return store2.nodesAsOfWhereTrue(asOf, attr);
+    }
+  };
+  return new Proxy(store2, {
+    get(target, prop) {
+      if (typeof prop === "string" && prop in allowed) return allowed[prop];
+      const v = Reflect.get(target, prop, target);
+      if (typeof v === "function") return () => fail(`store.${String(prop)}()`);
+      return v;
+    }
+  });
+}
+
+// ../../packages/context-writer/src/render.ts
 var MOTIF_BAND = 10;
 var MOTIF_POOL = 1e3;
 function rankMotifs(pool, signal, k = MOTIF_BAND) {
   if (!signal) return pool.slice(0, k);
   return pool.filter((m) => (signal.get(m.id) ?? 0) > 0).sort((a, b) => signal.get(b.id) - signal.get(a.id) || b.pageRank - a.pageRank).slice(0, k);
 }
+var HISTORY_POLICY_ATTRS = ["source", "extractionSource", "historyQuality", "validationSource", "attrsJson"];
+function passiveAllowed(row, atCommit) {
+  return historyReadPolicy({ extractionSource: row.extractionSource, attrs: row.attrs }, { mode: "passive", atCommit }).allow;
+}
+var PROBLEM_BAND_ATTRS = [
+  "mergedInto",
+  "resolvedAt",
+  "resolvedAs",
+  "kind",
+  "shownSinceTouch",
+  "shownSinceTouchAt",
+  ...HISTORY_POLICY_ATTRS
+];
 function buildSnapshot(opts) {
-  const problems = [...opts.store.findNodesByLabel("Problem"), ...opts.store.findNodesByLabel("Vulnerability")].filter((p) => p.attrs["mergedInto"] === void 0 && historyReadPolicy(p, { mode: "passive", atCommit: opts.atCommit }).allow);
+  const codeStore = opts.store;
+  if (SNAPSHOT_READ_GUARD) opts = { ...opts, store: guardSnapshotReads(opts.store) };
+  const hydrate = (id) => opts.store.getNode(id);
+  const problems = opts.store.selectNodes({ labels: ["Problem", "Vulnerability"], attrs: PROBLEM_BAND_ATTRS }).filter((p) => p.attrs["mergedInto"] === void 0 && passiveAllowed(p, opts.atCommit));
   const stillOpen = problems.filter((p) => p.attrs["resolvedAt"] == null);
   const allProblems = rankRecentBand(stillOpen.filter((p) => !isConstraintProblem(p)));
-  const openPool = allProblems.slice(0, RECENT_OPEN * SCOPE_POOL_FACTOR).map((p) => ({
-    node: p,
+  const openPool = allProblems.slice(0, Math.max(RECENT_OPEN * SCOPE_POOL_FACTOR, RECENT_WINDOW_BANDS * RECENT_OPEN)).map((p) => ({
+    node: hydrate(p.id),
     anchors: opts.store.outEdges(p.id, ["MANIFESTED_IN", "EVIDENCED_BY"])
   }));
   const recent = openPool.slice(0, RECENT_OPEN);
-  const constraintPool = rankRecentBand(stillOpen.filter((p) => isConstraintProblem(p)), { window: RECENT_WINDOW_BANDS * RECENT_CONSTRAINTS }).slice(0, RECENT_CONSTRAINTS * SCOPE_POOL_FACTOR);
+  const constraintPool = rankRecentBand(stillOpen.filter((p) => isConstraintProblem(p)), { window: RECENT_WINDOW_BANDS * RECENT_CONSTRAINTS }).slice(0, Math.max(RECENT_CONSTRAINTS * SCOPE_POOL_FACTOR, RECENT_WINDOW_BANDS * RECENT_CONSTRAINTS)).map((p) => hydrate(p.id));
   const recentConstraints = constraintPool.slice(0, RECENT_CONSTRAINTS);
-  const regressions = problems.filter((p) => p.attrs["resolvedAt"] == null && p.attrs["mergedInto"] === void 0).flatMap(
+  const regressionSources = /* @__PURE__ */ new Set();
+  for (const target of opts.store.inDegreeByType(["REGRESSION_OF"]).keys()) {
+    for (const e of opts.store.inEdges(target, ["REGRESSION_OF"])) regressionSources.add(e.from);
+  }
+  const regressions = problems.filter((p) => p.attrs["resolvedAt"] == null && p.attrs["mergedInto"] === void 0 && regressionSources.has(p.id)).map((p) => hydrate(p.id)).flatMap(
     (open) => opts.store.outEdges(open.id, ["REGRESSION_OF"]).flatMap((e) => {
       const closed = opts.store.getNode(e.to);
       if (!closed || closed.attrs["resolutionSuspect"] !== true || closed.attrs["resolvedAt"] == null) {
@@ -29516,18 +31423,14 @@ function buildSnapshot(opts) {
   const resolvedPool = problems.filter((p) => p.attrs["resolvedAt"] != null && p.attrs["resolvedAs"] == null).filter((p) => !regressionClosedIds.has(p.id)).sort((a, b) => Number(b.attrs["resolvedAt"] ?? 0) - Number(a.attrs["resolvedAt"] ?? 0)).slice(0, RECENT_RESOLVED * SCOPE_POOL_FACTOR).map((p) => {
     const solEdge = opts.store.outEdges(p.id, ["SOLVED_BY"])[0];
     const solution = solEdge ? opts.store.getNode(solEdge.to) ?? void 0 : void 0;
-    return { node: p, ...solution ? { solution } : {} };
+    return { node: hydrate(p.id), ...solution ? { solution } : {} };
   });
   const recentResolved = resolvedPool.slice(0, RECENT_RESOLVED);
-  const motifPool = [
-    ...opts.store.findNodesByLabel("Pattern"),
-    ...opts.store.findNodesByLabel("Technique"),
-    ...opts.store.findNodesByLabel("AntiPattern")
-  ].filter((n) => historyReadPolicy(n, { mode: "passive", atCommit: opts.atCommit }).allow).filter((n) => !(Number(n.attrs["missedRuns"] ?? 0) > 0)).sort((a, b) => b.pageRank - a.pageRank).slice(0, MOTIF_POOL).map((n) => n.embedding.length > 0 ? { ...n, embedding: [] } : n);
+  const motifPool = opts.store.selectNodes({ labels: ["Pattern", "Technique", "AntiPattern"], attrs: ["missedRuns", ...HISTORY_POLICY_ATTRS] }).filter((n) => passiveAllowed(n, opts.atCommit)).filter((n) => !(Number(n.attrs["missedRuns"] ?? 0) > 0)).sort((a, b) => b.pageRank - a.pageRank).slice(0, MOTIF_POOL).map((r) => hydrate(r.id)).map((n) => n.embedding.length > 0 ? { ...n, embedding: [] } : n);
   const motifs = rankMotifs(motifPool, void 0);
-  const workingFile = opts.workingFile ? sliceForFile(opts.store, opts.workingFile, opts.atCommit) : void 0;
+  const workingFile = opts.workingFile ? sliceForFile(codeStore, opts.workingFile, opts.atCommit) : void 0;
   const byEpisode = /* @__PURE__ */ new Map();
-  for (const sol of opts.store.findNodesByLabel("Solution")) {
+  for (const sol of opts.store.findLiveNodesByAttr("Solution", "enrichmentPending", 1)) {
     if (!historyReadPolicy(sol, { mode: "passive", atCommit: opts.atCommit }).allow) continue;
     if (sol.attrs["enrichmentPending"] !== true) continue;
     const ep = sol.attrs["episodeId"] ?? sol.id;
@@ -29558,13 +31461,14 @@ function buildSnapshot(opts) {
   const matchNode = (cands, key) => {
     const k = norm(key);
     if (k.length < 2) return null;
-    return cands.find((n) => norm(n.description ?? "") === k) ?? cands.find((n) => {
+    const hit = cands.find((n) => norm(n.description ?? "") === k) ?? cands.find((n) => {
       const d = norm(n.description ?? "");
       return d.length >= 2 && (d.includes(k) || k.includes(d));
-    }) ?? null;
+    });
+    return hit ? hydrate(hit.id) : null;
   };
-  const langNodes = opts.store.findNodesByLabel("Language");
-  const pkgNodes = opts.store.findNodesByLabel("Package");
+  const langNodes = opts.store.selectNodes({ labels: ["Language"] });
+  const pkgNodes = opts.store.selectNodes({ labels: ["Package"] });
   const toolNodes = rankToolsForHandles(opts.store, 5);
   const profileContext = {
     languages: opts.profile.languages.map((name2) => ({ name: name2, node: matchNode(langNodes, name2) })),
@@ -29615,8 +31519,8 @@ var RECENT_RESOLVED = 4;
 var RECENT_CONSTRAINTS = 3;
 var SCOPE_POOL_FACTOR = 3;
 function sliceForFile(store2, relPath, atCommit) {
-  const candidates = store2.findNodesByLabel("File");
-  const file2 = candidates.find((n) => n.description === relPath);
+  const hit = store2.selectNodes({ labels: ["File"], where: [{ descriptionIn: [relPath] }], limit: 1 })[0];
+  const file2 = hit ? store2.getNode(hit.id) : null;
   if (!file2) return void 0;
   const symbols = [];
   for (const e of store2.outEdges(file2.id, ["DEFINES"])) {
@@ -29794,11 +31698,20 @@ function listSourceFiles(root) {
   return gitSourceFiles(root) ?? walkSource(root);
 }
 var SCAN_YIELD_EVERY = 100;
-async function findStaleFiles(store2, rootPath, workspaceId) {
+async function findStaleFiles(store2, rootPath, workspaceId, lineageVerifiedAt) {
   const stale = [];
+  const changed = lineageVerifiedAt !== void 0 && store2.fileRowStates ? store2.lineageChangedFiles?.(lineageVerifiedAt) : null;
+  const relineage = changed ? new Set(changed) : null;
   let pending = [];
   const check2 = () => {
-    const states = new Map(store2.fileIndexStates(pending.map((f) => f.id)).map((s) => [s.id, s]));
+    const full = relineage ? pending.filter((f) => relineage.has(f.id)) : pending;
+    const states = new Map(
+      store2.fileIndexStates(full.map((f) => f.id)).map((s) => [s.id, s])
+    );
+    if (relineage) {
+      const rowOnly = pending.filter((f) => !relineage.has(f.id)).map((f) => f.id);
+      for (const s of store2.fileRowStates(rowOnly)) states.set(s.id, { ...s, complete: true });
+    }
     for (const f of pending) {
       const state = states.get(f.id);
       if (!state || state.validTo !== null || state.lastUpdatedAt < f.mtimeMs || !state.complete) stale.push(f.abs);
@@ -29820,9 +31733,34 @@ async function findStaleFiles(store2, rootPath, workspaceId) {
   check2();
   return stale;
 }
+var FILE_DECLARATION_LABELS = [
+  "Function",
+  "Class",
+  "Method",
+  "Module",
+  "Interface",
+  "Const",
+  "Static",
+  "Property",
+  "TypeAlias",
+  "Namespace",
+  "Enum",
+  "Annotation",
+  "Comment"
+];
+var DECLARATION_LABEL_SET = new Set(FILE_DECLARATION_LABELS);
+var LINEAGE_VERIFIED_KEY = "pass-inputs:reconcile-lineage";
 async function reconcileStaleFiles(store2, rootPath, workspaceId) {
-  const stale = await findStaleFiles(store2, rootPath, workspaceId);
-  if (stale.length === 0) return 0;
+  const startedAt = store2.changeSeq?.();
+  const verified = Number(store2.getMeta?.(LINEAGE_VERIFIED_KEY) ?? NaN);
+  const stale = await findStaleFiles(store2, rootPath, workspaceId, Number.isFinite(verified) ? verified : void 0);
+  const verify = () => {
+    if (startedAt !== void 0) store2.setMeta?.(LINEAGE_VERIFIED_KEY, String(startedAt));
+  };
+  if (stale.length === 0) {
+    verify();
+    return 0;
+  }
   let total = 0;
   let failedBatches = 0;
   const BATCH = 20;
@@ -29840,11 +31778,15 @@ async function reconcileStaleFiles(store2, rootPath, workspaceId) {
   }
   if (failedBatches > 0) {
     console.warn(`[errata] reconcile: ${failedBatches} batch(es) failed; ${total} file(s) reindexed`);
+  } else {
+    verify();
   }
   return total;
 }
 
 // src/workspace-maintenance.ts
+var WM_CALIBRATION_AT_KEY = "wm-calibration-at";
+var WM_CALIBRATION_INTERVAL_MS = 30 * 6e4;
 function runWorkspaceMaintenance(store2, workspaceId) {
   const seqBefore = store2.currentIngestSeq();
   const report = runSemanticMaintenance(store2);
@@ -29855,9 +31797,13 @@ function runWorkspaceMaintenance(store2, workspaceId) {
   }
   let calibration = null;
   const calibrationStarted = Date.now();
-  try {
-    calibration = wmCalibrationCells(store2);
-  } catch {
+  const lastCalibration = Number(store2.getMeta?.(WM_CALIBRATION_AT_KEY) ?? 0);
+  if (!(calibrationStarted - lastCalibration < WM_CALIBRATION_INTERVAL_MS)) {
+    try {
+      calibration = wmCalibrationCells(store2);
+      store2.setMeta?.(WM_CALIBRATION_AT_KEY, String(calibrationStarted));
+    } catch {
+    }
   }
   return {
     report,
@@ -30114,9 +32060,9 @@ function readDirectDependencies(root) {
   const hit = directCache.get(root);
   if (hit && hit.key === key) return hit.direct;
   const direct = [];
-  for (const { c, path } of found) {
+  for (const { c, path: path2 } of found) {
     try {
-      direct.push(...c.parse(readFileSync3(path, "utf8")).direct ?? []);
+      direct.push(...c.parse(readFileSync3(path2, "utf8")).direct ?? []);
     } catch {
     }
   }
@@ -30199,7 +32145,7 @@ function scanManifests(root) {
   try {
     const spine = buildSpine("workspace", [...texts.keys()], (p) => texts.get(p) ?? "");
     scan2.deps = Object.values(spine.manifests).flat();
-    for (const [path, text] of texts) scan2.self.push(...parseManifestSelf(path, text));
+    for (const [path2, text] of texts) scan2.self.push(...parseManifestSelf(path2, text));
   } catch {
     scan2.deps = [];
     scan2.self = [];