@inerrata-corporation/errata 2.0.6-dev.2028 → 2.0.6-dev.2047

package/consolidate-worker.mjs

@@ -16208,6 +16208,11 @@ var SqliteGraphStore = class {
       countByLabel: this.db.prepare(
         "SELECT COUNT(*) AS n FROM nodes WHERE label = ? AND valid_to IS NULL"
       ),
+      // Identity twin of findByLabel — same live-row semantics, two attrs read in
+      // SQL, no attrs JSON.parse or embedding decode (PJ-anchor-reach).
+      identitiesByLabel: this.db.prepare(
+        "SELECT id, json_extract(attrs_json, '$.relPath') AS relPath, json_extract(attrs_json, '$.qname') AS qname FROM nodes WHERE label = ? AND valid_to IS NULL"
+      ),
       // ALL versions of a label — incl frozen/closed (valid_to set). Used by the
       // clean-reindex purge so a true wipe removes history too, not just live rows.
       findByLabelAll: this.db.prepare("SELECT * FROM nodes WHERE label = ?"),
@@ -16508,6 +16513,14 @@ var SqliteGraphStore = class {
   countNodesByLabel(label) {
     return Number(this.stmts.countByLabel.get(label).n);
   }
+  findNodeIdentitiesByLabel(label) {
+    const rows = this.stmts.identitiesByLabel.all(label);
+    return rows.map((r) => ({
+      id: r.id,
+      relPath: typeof r.relPath === "string" ? r.relPath : null,
+      qname: typeof r.qname === "string" ? r.qname : null
+    }));
+  }
   findAllVersionsByLabel(label) {
     const rows = this.stmts.findByLabelAll.all(label);
     return rows.map(rowToNode);

package/errata.mjs

@@ -15962,6 +15962,9 @@ function projectSymbolId(projectSalt, projectId, relPath, qname, kind) {
   const path2 = normalizeSymbolPath(relPath);
   return `sym_${createHmac("sha256", projectSalt).update(`${projectId}:${path2}:${qname}:${kind}`).digest("hex").slice(0, 24)}`;
 }
+function projectSaltedNodeId(canonicalId, salt) {
+  return `projn_${createHmac("sha256", salt).update(canonicalId).digest("hex").slice(0, 24)}`;
+}
 function isMembraneSaltedId(id) {
   return typeof id === "string" && /^(orgn_|teamn_|projn_)/.test(id);
 }
@@ -16460,6 +16463,7 @@ __export(src_exports, {
   parsePnpmLock: () => parsePnpmLock,
   prefilterEntities: () => prefilterEntities,
   problemIdFromError: () => problemIdFromError,
+  projectSaltedNodeId: () => projectSaltedNodeId,
   projectSymbolId: () => projectSymbolId,
   provenanceBand: () => provenanceBand,
   resolveCanonical: () => resolveCanonical,
@@ -17255,6 +17259,11 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
           countByLabel: this.db.prepare(
             "SELECT COUNT(*) AS n FROM nodes WHERE label = ? AND valid_to IS NULL"
           ),
+          // Identity twin of findByLabel — same live-row semantics, two attrs read in
+          // SQL, no attrs JSON.parse or embedding decode (PJ-anchor-reach).
+          identitiesByLabel: this.db.prepare(
+            "SELECT id, json_extract(attrs_json, '$.relPath') AS relPath, json_extract(attrs_json, '$.qname') AS qname FROM nodes WHERE label = ? AND valid_to IS NULL"
+          ),
           // ALL versions of a label — incl frozen/closed (valid_to set). Used by the
           // clean-reindex purge so a true wipe removes history too, not just live rows.
           findByLabelAll: this.db.prepare("SELECT * FROM nodes WHERE label = ?"),
@@ -17555,6 +17564,14 @@ CREATE INDEX IF NOT EXISTS nodes_relpath ON nodes(json_extract(attrs_json, '$.re
       countNodesByLabel(label) {
         return Number(this.stmts.countByLabel.get(label).n);
       }
+      findNodeIdentitiesByLabel(label) {
+        const rows = this.stmts.identitiesByLabel.all(label);
+        return rows.map((r) => ({
+          id: r.id,
+          relPath: typeof r.relPath === "string" ? r.relPath : null,
+          qname: typeof r.qname === "string" ? r.qname : null
+        }));
+      }
       findAllVersionsByLabel(label) {
         const rows = this.stmts.findByLabelAll.all(label);
         return rows.map(rowToNode);
@@ -25213,6 +25230,28 @@ var init_client = __esm({
         }));
         return { nodes, edges, anchorEdges, symbolIds: res.symbolIds ?? [] };
       }
+      /**
+       * PJ-anchor-reach: one cursor page of the project's symbol anchors, newest
+       * stamp last. `since` is the cursor from the previous page (0 = from the
+       * beginning); the returned `cursor` continues it. Rank-independent — the
+       * daemon filters the page against its own checkout, and nothing about which
+       * symbols it holds is sent. Same membership gate as priors.
+       */
+      async getProjectAnchors(projectId, since, limit = 200) {
+        const res = await this.json(
+          "GET",
+          `/v2/projects/${encodeURIComponent(projectId)}/anchors?since=${String(Math.max(0, Math.floor(since)))}&limit=${String(limit)}`
+        );
+        const { nodes } = this.toCastalia({ nodes: res.nodes ?? [], edges: [] });
+        const anchors = (res.anchors ?? []).map((a) => ({
+          from: a.fromCanonicalId,
+          toSymbolId: a.toSymbolId,
+          type: a.type,
+          attrs: a.attrs ?? {},
+          stampedAt: typeof a.stampedAt === "number" ? a.stampedAt : 0
+        }));
+        return { nodes, anchors, cursor: typeof res.cursor === "number" ? res.cursor : since };
+      }
       /** Pull cloud-induced skills + the session-bootstrap prime payload. `seed` is the
        *  canonical ids of the agent's recent problems — the cloud ranks the skills whose
        *  motifs those problems match first (the rest are baseline). `techSeed`
@@ -70009,13 +70048,13 @@ function esc3(s) {
 function slug(name2) {
   return name2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
 }
-function isLive2(verb) {
+function isLive3(verb) {
   return LIVE_VERBS.has(verb);
 }
 function nextHtml(n, opts) {
   if (!n) return "";
   const cmd2 = `errata ${n.verb}${n.arg ? " " + n.arg : ""}`;
-  const live2 = isLive2(n.verb);
+  const live2 = isLive3(n.verb);
   if (!live2 && !opts.includeFutureVerbs) return "";
   const hint = n.hint ? ` \u2014 ${esc3(n.hint)}` : "";
   const cls = live2 ? "next" : "next soon";
@@ -77008,7 +77047,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.6-dev.2028" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.6-dev.2047" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -80448,42 +80487,12 @@ async function ensureProjectLink(root, profile, client) {
 }
 
 // src/project-hydrate.ts
-var DEFAULT_LIMIT = 50;
-async function hydrateProject(opts) {
-  const { root, profile, store, cloud } = opts;
-  if (!profile.projectId) return { hydrated: false, reason: "no-project" };
-  if (profile.projectHydratedAt) return { hydrated: false, reason: "already-hydrated" };
-  try {
-    const res = await cloud.getProjectPriors(profile.projectId, opts.limit ?? DEFAULT_LIMIT);
-    let landedNodes = 0;
-    for (const n of res.nodes) {
-      if (store.getNode(n.id)) continue;
-      store.mergeNode(n);
-      landedNodes++;
-    }
-    let landedEdges = 0;
-    for (const e of res.edges) {
-      if (!store.getNode(e.from) || !store.getNode(e.to)) continue;
-      if (store.getEdge(e.id)) continue;
-      store.mergeEdge(e);
-      landedEdges++;
-    }
-    profile.projectHydratedAt = Date.now();
-    saveProfile(root, profile);
-    return { hydrated: true, nodes: landedNodes, edges: landedEdges };
-  } catch (err2) {
-    return {
-      hydrated: false,
-      reason: "error",
-      detail: err2 instanceof Error ? err2.message : String(err2)
-    };
-  }
-}
+init_src11();
 
 // src/project-reanchor.ts
 init_src();
 init_src11();
-var DEFAULT_LIMIT2 = 50;
+var DEFAULT_LIMIT = 50;
 var ANCHOR_SYMBOL_KINDS = [
   "Function",
   "Class",
@@ -80506,16 +80515,92 @@ function buildReverseSymbolMap(opts) {
   const { store, salt, projectId } = opts;
   const reverse = /* @__PURE__ */ new Map();
   for (const kind of ANCHOR_SYMBOL_KINDS) {
-    for (const n of store.findNodesByLabel(kind)) {
-      const relPath = n.attrs["relPath"];
-      const qname = n.attrs["qname"];
-      if (typeof relPath !== "string" || typeof qname !== "string") continue;
-      const sym = projectSymbolId(salt, projectId, relPath, qname, n.label);
+    for (const n of store.findNodeIdentitiesByLabel(kind)) {
+      const { relPath, qname } = n;
+      if (relPath === null || qname === null) continue;
+      const sym = projectSymbolId(salt, projectId, relPath, qname, kind);
       if (!reverse.has(sym)) reverse.set(sym, n.id);
+      const twin = projectSaltedNodeId(sym, salt);
+      if (!reverse.has(twin)) reverse.set(twin, n.id);
     }
   }
   return reverse;
 }
+function anchorConfidence(attrs) {
+  const v = typeof attrs["extractionConfidence"] === "number" ? attrs["extractionConfidence"] : attrs["confidence"];
+  return typeof v === "number" && Number.isFinite(v) ? Math.max(0, Math.min(1, v)) : null;
+}
+var ANCHOR_SOURCE_KINDS = [
+  "Problem",
+  "Solution",
+  "RootCause",
+  "Pattern",
+  "Technique",
+  "AntiPattern"
+];
+function buildOwnKnowledgeMap(opts) {
+  const { store, salt } = opts;
+  const own = /* @__PURE__ */ new Map();
+  for (const kind of ANCHOR_SOURCE_KINDS) {
+    for (const n of store.findNodeIdentitiesByLabel(kind)) {
+      if (n.id.startsWith("projn_")) continue;
+      own.set(projectSaltedNodeId(n.id, salt), n.id);
+    }
+  }
+  return own;
+}
+function resolveAnchorSource(store, from, own) {
+  if (store.getNode(from)) return from;
+  return own().get(from) ?? null;
+}
+function existingAnchor(store, from, to) {
+  const matches = store.outEdges(from, ["ANCHORED_AT"]).filter((e) => e.to === to);
+  return matches.find((e) => e.attrs["source"] !== "cloud") ?? matches[0] ?? null;
+}
+var reverseCache = /* @__PURE__ */ new WeakMap();
+var ownCache = /* @__PURE__ */ new WeakMap();
+function cachedMap(cache2, store, key, build) {
+  let refreshed = false;
+  const put = () => {
+    const map2 = build();
+    cache2.set(store, { key, map: map2 });
+    return map2;
+  };
+  return {
+    get: () => {
+      const hit = cache2.get(store);
+      if (hit && hit.key === key) return hit.map;
+      refreshed = true;
+      return put();
+    },
+    refresh: () => {
+      if (refreshed) return cache2.get(store)?.map ?? put();
+      refreshed = true;
+      return put();
+    }
+  };
+}
+function lookupLive(store, m, id) {
+  const first = m.get().get(id);
+  if (first && isLive2(store, first)) return first;
+  const second = m.refresh().get(id);
+  return second && isLive2(store, second) ? second : null;
+}
+function isLive2(store, id) {
+  const n = store.getNode(id);
+  return n !== null && (n.validTo === null || n.validTo === void 0);
+}
+function lazy2(make) {
+  let value;
+  let made = false;
+  return () => {
+    if (!made) {
+      value = make();
+      made = true;
+    }
+    return value;
+  };
+}
 async function reanchorProject(opts) {
   const { root, profile, store, cloud, salt } = opts;
   if (!profile.projectId) return { reanchored: false, reason: "no-project" };
@@ -80524,8 +80609,9 @@ async function reanchorProject(opts) {
   const reverse = buildReverseSymbolMap({ store, salt, projectId: profile.projectId });
   if (reverse.size === 0) return { reanchored: false, reason: "no-local-symbols" };
   try {
-    const res = await cloud.getProjectPriors(profile.projectId, opts.limit ?? DEFAULT_LIMIT2);
+    const res = await cloud.getProjectPriors(profile.projectId, opts.limit ?? DEFAULT_LIMIT);
     const now = Date.now();
+    const own = lazy2(() => buildOwnKnowledgeMap({ store, salt }));
     let anchors = 0;
     let dropped = 0;
     for (const a of res.anchorEdges) {
@@ -80534,18 +80620,19 @@ async function reanchorProject(opts) {
         dropped++;
         continue;
       }
-      if (!store.getNode(a.from)) {
+      const from = resolveAnchorSource(store, a.from, own);
+      if (!from) {
         dropped++;
         continue;
       }
-      const id = edgeId(a.from, "ANCHORED_AT", localTo);
-      if (store.getEdge(id)) continue;
+      if (existingAnchor(store, from, localTo)) continue;
+      const id = edgeId(from, "ANCHORED_AT", localTo);
       const edge2 = {
         id,
-        from: a.from,
+        from,
         to: localTo,
         type: "ANCHORED_AT",
-        confidence: typeof a.attrs["confidence"] === "number" ? Math.max(0, Math.min(1, a.attrs["confidence"])) : 0.5,
+        confidence: anchorConfidence(a.attrs) ?? 0.5,
         extractionSource: "agent-observed",
         createdAt: now,
         lastSeenAt: now,
@@ -80570,6 +80657,136 @@ async function reanchorProject(opts) {
     };
   }
 }
+var SYNC_PAGE = 200;
+var SYNC_MAX_PAGES = 25;
+async function syncProjectAnchors(opts) {
+  const { root, profile, store, cloud, salt } = opts;
+  if (!profile.projectId) return { synced: false, reason: "no-project" };
+  const projectId = profile.projectId;
+  const key = `${projectId}|${salt}`;
+  const reverse = cachedMap(reverseCache, store, key, () => buildReverseSymbolMap({ store, salt, projectId }));
+  const own = cachedMap(ownCache, store, salt, () => buildOwnKnowledgeMap({ store, salt }));
+  const limit = opts.limit ?? SYNC_PAGE;
+  const maxPages = opts.maxPages ?? SYNC_MAX_PAGES;
+  let anchors = 0;
+  let updated = 0;
+  let dropped = 0;
+  let landed = 0;
+  let cursor = profile.projectAnchorCursor ?? 0;
+  try {
+    for (let page = 0; page < maxPages; page++) {
+      const res = await cloud.getProjectAnchors(projectId, cursor, limit);
+      if (res.anchors.length === 0) break;
+      if (reverse.get().size === 0 && reverse.refresh().size === 0) {
+        return { synced: false, reason: "no-local-symbols" };
+      }
+      const byId = new Map(res.nodes.map((n) => [n.id, n]));
+      const now = Date.now();
+      for (const a of res.anchors) {
+        if (a.type !== "ANCHORED_AT") continue;
+        const localTo = lookupLive(store, reverse, a.toSymbolId);
+        if (!localTo) {
+          dropped++;
+          continue;
+        }
+        let from = store.getNode(a.from) ? a.from : lookupLive(store, own, a.from);
+        if (!from) {
+          const node2 = byId.get(a.from);
+          if (!node2) {
+            dropped++;
+            continue;
+          }
+          store.mergeNode(node2);
+          landed++;
+          from = node2.id;
+        }
+        const existing = existingAnchor(store, from, localTo);
+        const id = existing?.id ?? edgeId(from, "ANCHORED_AT", localTo);
+        if (existing) {
+          if (existing.attrs["source"] !== "cloud") continue;
+          if (existing.attrs["symbolContentHash"] === a.attrs["symbolContentHash"] && existing.attrs["observedAtCommit"] === a.attrs["observedAtCommit"]) {
+            continue;
+          }
+        }
+        const edge2 = {
+          id,
+          from,
+          to: localTo,
+          type: "ANCHORED_AT",
+          confidence: anchorConfidence(a.attrs) ?? existing?.confidence ?? 0.5,
+          extractionSource: "agent-observed",
+          createdAt: existing?.createdAt ?? now,
+          lastSeenAt: now,
+          navSuccesses: existing?.navSuccesses ?? 0,
+          navFailures: existing?.navFailures ?? 0,
+          attrs: {
+            ...existing?.attrs ?? {},
+            ...a.attrs,
+            source: "cloud",
+            anchorState: classifyAnchorVersion(a.attrs, store.getNode(localTo))
+          }
+        };
+        store.mergeEdge(edge2);
+        if (existing) updated++;
+        else anchors++;
+      }
+      const next = typeof res.cursor === "number" && res.cursor > cursor ? res.cursor : cursor;
+      if (next !== cursor) {
+        cursor = next;
+        profile.projectAnchorCursor = cursor;
+        saveProfile(root, profile);
+      }
+      if (res.anchors.length < limit) break;
+    }
+    return { synced: true, anchors, updated, dropped, landed, cursor };
+  } catch (err2) {
+    return { synced: false, reason: "error", detail: err2 instanceof Error ? err2.message : String(err2) };
+  }
+}
+
+// src/project-hydrate.ts
+var DEFAULT_LIMIT2 = 50;
+async function hydrateProject(opts) {
+  const { root, profile, store, cloud, salt } = opts;
+  if (!profile.projectId) return { hydrated: false, reason: "no-project" };
+  if (profile.projectHydratedAt) return { hydrated: false, reason: "already-hydrated" };
+  try {
+    const res = await cloud.getProjectPriors(profile.projectId, opts.limit ?? DEFAULT_LIMIT2);
+    const own = buildOwnKnowledgeMap({ store, salt });
+    const localId = (id) => store.getNode(id) ? id : own.get(id) ?? null;
+    let landedNodes = 0;
+    let ownNodes = 0;
+    for (const n of res.nodes) {
+      if (store.getNode(n.id)) continue;
+      if (own.has(n.id)) {
+        ownNodes++;
+        continue;
+      }
+      store.mergeNode(n);
+      landedNodes++;
+    }
+    let landedEdges = 0;
+    for (const e of res.edges) {
+      const from = localId(e.from);
+      const to = localId(e.to);
+      if (!from || !to) continue;
+      if (store.outEdges(from, [e.type]).some((x) => x.to === to)) continue;
+      const id = from === e.from && to === e.to ? e.id : edgeId(from, e.type, to);
+      if (store.getEdge(id)) continue;
+      store.mergeEdge({ ...e, id, from, to });
+      landedEdges++;
+    }
+    profile.projectHydratedAt = Date.now();
+    saveProfile(root, profile);
+    return { hydrated: true, nodes: landedNodes, edges: landedEdges, own: ownNodes };
+  } catch (err2) {
+    return {
+      hydrated: false,
+      reason: "error",
+      detail: err2 instanceof Error ? err2.message : String(err2)
+    };
+  }
+}
 
 // src/project-history.ts
 init_src7();
@@ -83559,6 +83776,44 @@ async function startMultiDaemon(opts = {}) {
     // eslint-disable-next-line no-console
     log: (line) => console.log(line)
   });
+  const pullProjectAnchors = async (r, client, salt) => {
+    const sync = await syncProjectAnchors({
+      root: r.root,
+      profile: r.engine.profile,
+      store: r.engine.store,
+      cloud: client,
+      salt
+    });
+    if (sync.synced) {
+      if (sync.anchors + sync.updated > 0) {
+        r.engine.markContextDirty();
+        console.log(
+          `[errata] anchors pulled for ${r.engine.profile.name} \u2014 ${sync.anchors} new, ${sync.updated} re-versioned, ${sync.dropped} unresolved (${sync.landed} priors landed, cursor ${sync.cursor})`
+        );
+      }
+    } else if (sync.reason === "error") {
+      console.warn(`[errata] anchor pull failed for ${r.engine.profile.name}: ${sync.detail}`);
+    }
+  };
+  const ANCHOR_PULL_INTERVAL_MS = 10 * 60 * 1e3;
+  const anchorPullAll = async () => {
+    const c = loadConfig();
+    if (!c.consent.sync || !hasCloudCredential(c)) return;
+    const client = cloudNow();
+    for (const r of records) {
+      const projectId = r.engine.profile.projectId;
+      if (!projectId) continue;
+      try {
+        const { salt } = await resolveProjectSymbolSalt(client, projectId);
+        await pullProjectAnchors(r, client, salt);
+      } catch (err2) {
+        console.warn(`[errata] anchor pull skipped for ${r.engine.profile.name}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+      }
+    }
+  };
+  const anchorPull = setInterval(() => {
+    void anchorPullAll();
+  }, ANCHOR_PULL_INTERVAL_MS);
   const ambientLinkAll = async () => {
     const c = loadConfig();
     if (!c.consent.sync || !hasCloudCredential(c)) return;
@@ -83572,18 +83827,29 @@ async function startMultiDaemon(opts = {}) {
       } else if (out2.reason === "error") {
         console.warn(`[errata] project link failed for ${r.engine.profile.name}: ${out2.detail}`);
       }
-      const hyd = await hydrateProject({
+      let primeSalt = null;
+      if (r.engine.profile.projectId && !r.engine.profile.projectHydratedAt) {
+        try {
+          primeSalt = (await resolveProjectSymbolSalt(client, r.engine.profile.projectId)).salt;
+        } catch (err2) {
+          console.warn(
+            `[errata] project prime deferred for ${r.engine.profile.name}: salt unavailable (${err2 instanceof Error ? err2.message : String(err2)})`
+          );
+        }
+      }
+      const hyd = primeSalt ? await hydrateProject({
         root: r.root,
         profile: r.engine.profile,
         store: r.engine.store,
-        cloud: client
-      });
-      if (hyd.hydrated) {
+        cloud: client,
+        salt: primeSalt
+      }) : null;
+      if (hyd?.hydrated) {
         r.engine.markContextDirty();
         console.log(
-          `[errata] primed ${r.engine.profile.name} from project \u2014 ${hyd.nodes} priors, ${hyd.edges} links`
+          `[errata] primed ${r.engine.profile.name} from project \u2014 ${hyd.nodes} priors, ${hyd.edges} links (${hyd.own} already this checkout's own)`
         );
-      } else if (hyd.reason === "error") {
+      } else if (hyd && !hyd.hydrated && hyd.reason === "error") {
         console.warn(`[errata] project prime failed for ${r.engine.profile.name}: ${hyd.detail}`);
       }
       if (r.engine.profile.projectId) {
@@ -83604,6 +83870,7 @@ async function startMultiDaemon(opts = {}) {
           } else if (re.reason === "error") {
             console.warn(`[errata] project reanchor failed for ${r.engine.profile.name}: ${re.detail}`);
           }
+          await pullProjectAnchors(r, client, salt);
           if (r.engine.profile.projectHydratedAt && !historyInFlight.has(r.root)) {
             historyInFlight.add(r.root);
             const engine = r.engine;
@@ -84255,6 +84522,7 @@ async function startMultiDaemon(opts = {}) {
     async stop() {
       clearInterval(idleSweep);
       clearInterval(codexWake);
+      clearInterval(anchorPull);
       clearTimeout(codexWakeBoot);
       try {
         const cur = readFileSync30(lockPath, "utf8");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.6-dev.2028",
+  "version": "2.0.6-dev.2047",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {

package/pass-worker.mjs

@@ -24662,6 +24662,11 @@ var SqliteGraphStore = class {
       countByLabel: this.db.prepare(
         "SELECT COUNT(*) AS n FROM nodes WHERE label = ? AND valid_to IS NULL"
       ),
+      // Identity twin of findByLabel — same live-row semantics, two attrs read in
+      // SQL, no attrs JSON.parse or embedding decode (PJ-anchor-reach).
+      identitiesByLabel: this.db.prepare(
+        "SELECT id, json_extract(attrs_json, '$.relPath') AS relPath, json_extract(attrs_json, '$.qname') AS qname FROM nodes WHERE label = ? AND valid_to IS NULL"
+      ),
       // ALL versions of a label — incl frozen/closed (valid_to set). Used by the
       // clean-reindex purge so a true wipe removes history too, not just live rows.
       findByLabelAll: this.db.prepare("SELECT * FROM nodes WHERE label = ?"),
@@ -24962,6 +24967,14 @@ var SqliteGraphStore = class {
   countNodesByLabel(label) {
     return Number(this.stmts.countByLabel.get(label).n);
   }
+  findNodeIdentitiesByLabel(label) {
+    const rows = this.stmts.identitiesByLabel.all(label);
+    return rows.map((r) => ({
+      id: r.id,
+      relPath: typeof r.relPath === "string" ? r.relPath : null,
+      qname: typeof r.qname === "string" ? r.qname : null
+    }));
+  }
   findAllVersionsByLabel(label) {
     const rows = this.stmts.findByLabelAll.all(label);
     return rows.map(rowToNode);