@omgbase/core 0.27.1 → 0.29.0

package/dist/src/graph/link-health.d.ts

@@ -2,14 +2,14 @@ import type { Store } from "../core/store/store.js";
 export type StaleReason = "dangling_doc" | "dangling_block" | "broken_anchor";
 export interface StaleLink {
     /** source document id */
-    doc_id: string;
+    _doc_id: string;
     /** source document path in the reference form */
-    path: string;
+    _path: string;
     /** source block id (null for frontmatter-level edges) */
-    block_id: string | null;
-    predicate: string;
-    provenance: string;
-    dst_kind: string;
+    _block_id: string | null;
+    _predicate: string;
+    _provenance: string;
+    _dst_kind: string;
     /** the canonical target path in the reference form (phantom prefix stripped,
      *  rooted), e.g. "/guides/old.md" — spec/surface §1 "Paths" */
     target: string;
@@ -17,7 +17,7 @@ export interface StaleLink {
      * — paste-ready as `links_repair.from`. null when it can't be recovered (frontmatter
      * edges have no block; a projected node no longer matches). */
     authored: string | null;
-    anchor: string | null;
+    _anchor: string | null;
     reason: StaleReason;
 }
 /** links_stale summary mode: counts only, no per-row output. */
@@ -29,9 +29,9 @@ export interface LinkHealthSummary {
         target: string;
         count: number;
     }[];
-    /** source documents carrying dangling links, most first (ties by path); `path` the reference form */
+    /** source documents carrying dangling links, most first (ties by path); `_path` the reference form */
     bySource: {
-        path: string;
+        _path: string;
         count: number;
     }[];
     externalCount: number;

package/dist/src/graph/link-health.js

@@ -88,18 +88,18 @@ export function linksStale(store, repoId, opts = {}) {
     const stale = page.map((r) => {
         // Strip the "phantom:" prefix to expose the canonical path.
         const target = r.dstNode.slice("phantom:".length);
-        // The surface speaks the reference form: `path` and `target` rooted;
+        // The surface speaks the reference form: `_path` and `target` rooted;
         // `authored` stays exactly as written in the source.
         return {
-            doc_id: r.srcDoc,
-            path: referencePath(r.srcPath),
-            block_id: r.srcBlock,
-            predicate: r.predicate,
-            provenance: r.provenance,
-            dst_kind: r.dstKind,
+            _doc_id: r.srcDoc,
+            _path: referencePath(r.srcPath),
+            _block_id: r.srcBlock,
+            _predicate: r.predicate,
+            _provenance: r.provenance,
+            _dst_kind: r.dstKind,
             target: referencePath(target),
             authored: authoredFor(r.srcBlock, r.srcPath, target, r.anchor),
-            anchor: r.anchor,
+            _anchor: r.anchor,
             // All phantom targets are dangling DOCUMENTS in this data model (cross-doc
             // block refs collapse to document phantoms carrying an anchor). We tag rows
             // that also carry an anchor as such, but the miss is still a missing doc.
@@ -140,7 +140,7 @@ export function linksStaleSummary(store, repoId, opts = {}) {
     const bySource = store.db
         .prepare(`SELECT d.path AS srcPath, count(*) AS count ${phantom} GROUP BY d.path ORDER BY count DESC, d.path`)
         .all(...params)
-        .map((r) => ({ path: referencePath(r.srcPath), count: r.count }));
+        .map((r) => ({ _path: referencePath(r.srcPath), count: r.count }));
     return {
         staleCount: byTarget.reduce((n, t) => n + t.count, 0),
         byTarget,

package/dist/src/graph/links.d.ts

@@ -1,15 +1,15 @@
 import type { Store } from "../core/store/store.js";
 export interface LinkEdge {
-    predicate: string;
+    _predicate: string;
     /** the other endpoint (dst for out-edges, src for in-edges): a doc id, an external node id or `phantom:<path>` */
-    doc_id: string;
+    _doc_id: string;
     kind: string;
     /** how many underlying block-grain edges this doc-grain row rolls up */
     count: number;
     /** sample source block ids (out-edges only) */
     samples?: string[];
     /** block-grain (`blocks: true`): the source block of this edge (null for a frontmatter edge) */
-    block_id?: string | null;
+    _block_id?: string | null;
 }
 export interface LinksResult {
     out: LinkEdge[];

package/dist/src/graph/links.js

@@ -13,7 +13,7 @@ export function docLinks(store, docId, opts = {}) {
                 .all(docId);
             for (const r of rows)
                 if (inPred(r.predicate))
-                    out.push({ predicate: r.predicate, doc_id: r.dst_node, kind: r.dst_kind, count: 1, block_id: r.src_block });
+                    out.push({ _predicate: r.predicate, _doc_id: r.dst_node, kind: r.dst_kind, count: 1, _block_id: r.src_block });
         }
         else {
             const rows = store.db
@@ -23,7 +23,7 @@ export function docLinks(store, docId, opts = {}) {
             for (const r of rows) {
                 if (!inPred(r.predicate))
                     continue;
-                out.push({ predicate: r.predicate, doc_id: r.dst_node, kind: r.dst_kind, count: r.count, samples: JSON.parse(r.samples) });
+                out.push({ _predicate: r.predicate, _doc_id: r.dst_node, kind: r.dst_kind, count: r.count, samples: JSON.parse(r.samples) });
             }
         }
     }
@@ -35,7 +35,7 @@ export function docLinks(store, docId, opts = {}) {
                 .all(docId);
             for (const r of rows)
                 if (inPred(r.predicate))
-                    inbound.push({ predicate: r.predicate, doc_id: r.src_doc, kind: "document", count: 1, block_id: r.src_block });
+                    inbound.push({ _predicate: r.predicate, _doc_id: r.src_doc, kind: "document", count: 1, _block_id: r.src_block });
         }
         else {
             const rows = store.db
@@ -45,7 +45,7 @@ export function docLinks(store, docId, opts = {}) {
                 .all(docId);
             for (const r of rows)
                 if (inPred(r.predicate))
-                    inbound.push({ predicate: r.predicate, doc_id: r.src_doc, kind: "document", count: r.cnt });
+                    inbound.push({ _predicate: r.predicate, _doc_id: r.src_doc, kind: "document", count: r.cnt });
         }
     }
     return { out, in: inbound };

package/dist/src/mcp/arguments.d.ts

@@ -31,10 +31,17 @@ export declare function jsonArrayString(s: string): {
  * arguments with any `undefined` members dropped; throws the first failure.
  */
 export declare function validateArguments(tool: string, shape: ArgShape, raw: unknown): Record<string, unknown>;
+/** Whether `key` is a bare engine-field name whose `_` spelling the tool takes. */
+export declare function bareEngineArgument(key: string, shape: ArgShape): boolean;
+/** The call with every bare engine-field argument respelled to its `_` form (the `fix` of the no-tolerance error). */
+export declare function respellEngineArguments(args: Record<string, unknown>, shape: ArgShape): Record<string, unknown>;
 /**
- * What to say about an argument name the tool does not take. The names 3.0
- * retired are called out with their replacement (`doc` → `id`/`path`,
- * `block`/`node` → `id`, `heading` → `section`, `markdown` → `text`) when the
+ * What to say about an argument name the tool does not take. A bare engine
+ * field (`id`, `path`, `ids`) where the tool takes its `_` spelling is the
+ * no-tolerance error of 5.0 (spec/surface §4 "Arguments": the bare namespace is
+ * the user's, an engine field is matched by its exact name). The names 3.0
+ * retired are called out with their replacement (`doc` → `_id`/`_path`,
+ * `block`/`node` → `_id`, `heading` → `section`, `markdown` → `text`) when the
  * tool has the replacement, and so are the inputs 4.0 retired (spec/surface
  * §4; ADR-021's retirement release): `ops` on a tool that takes `effects`
  * (the kernel ops are a library/fixture contract), `dry_run` on any tool (the

package/dist/src/mcp/arguments.js

@@ -77,8 +77,13 @@ export function validateArguments(tool, shape, raw) {
         throw argumentError(tool, "arguments must be an object", shape);
     const args = raw;
     for (const key of Object.keys(args).sort(cmpBytes)) {
-        if (!(key in shape))
-            throw argumentError(tool, unknownArgumentMessage(key, shape), shape);
+        if (key in shape)
+            continue;
+        // (5.0) A bare engine-field name where the tool takes its `_` spelling:
+        // the error carries the corrected call (every bare `id`/`path`/`ids` the
+        // call holds respelled at once), never a silent acceptance.
+        const fix = bareEngineArgument(key, shape) ? canonicalJson(respellEngineArguments(args, shape)) : undefined;
+        throw argumentError(tool, unknownArgumentMessage(key, shape), shape, fix);
     }
     const out = {};
     for (const key of Object.keys(shape).sort(cmpBytes)) {
@@ -135,10 +140,26 @@ function issueMessage(key, schema, issues) {
     const expected = { string: "a string", number: "an integer", boolean: "a boolean", object: "an object", array: "an array" };
     return `\`${at}\` must be ${issue.expected !== undefined ? (expected[issue.expected] ?? issue.expected) : "valid"}`;
 }
+/** The bare engine-field names a tool may be called with by mistake (spec/surface §4, 5.0): each has its `_` spelling in the shape. */
+const BARE_ENGINE_ARGUMENTS = ["id", "path", "ids", "paths"];
+/** Whether `key` is a bare engine-field name whose `_` spelling the tool takes. */
+export function bareEngineArgument(key, shape) {
+    return BARE_ENGINE_ARGUMENTS.includes(key) && `_${key}` in shape;
+}
+/** The call with every bare engine-field argument respelled to its `_` form (the `fix` of the no-tolerance error). */
+export function respellEngineArguments(args, shape) {
+    const out = {};
+    for (const [k, v] of Object.entries(args))
+        out[bareEngineArgument(k, shape) ? `_${k}` : k] = v;
+    return out;
+}
 /**
- * What to say about an argument name the tool does not take. The names 3.0
- * retired are called out with their replacement (`doc` → `id`/`path`,
- * `block`/`node` → `id`, `heading` → `section`, `markdown` → `text`) when the
+ * What to say about an argument name the tool does not take. A bare engine
+ * field (`id`, `path`, `ids`) where the tool takes its `_` spelling is the
+ * no-tolerance error of 5.0 (spec/surface §4 "Arguments": the bare namespace is
+ * the user's, an engine field is matched by its exact name). The names 3.0
+ * retired are called out with their replacement (`doc` → `_id`/`_path`,
+ * `block`/`node` → `_id`, `heading` → `section`, `markdown` → `text`) when the
  * tool has the replacement, and so are the inputs 4.0 retired (spec/surface
  * §4; ADR-021's retirement release): `ops` on a tool that takes `effects`
  * (the kernel ops are a library/fixture contract), `dry_run` on any tool (the
@@ -148,10 +169,12 @@ function issueMessage(key, schema, issues) {
 export function unknownArgumentMessage(key, shape) {
     const has = (n) => n in shape;
     const retired = (replacement) => `\`${key}\` is no longer an argument — pass ${replacement}`;
-    if (key === "doc" && has("id") && has("path"))
-        return retired("`id` or `path`");
-    if ((key === "block" || key === "node") && has("id"))
-        return retired("`id`");
+    if (bareEngineArgument(key, shape))
+        return `\`${key}\` is not an argument — the engine field is \`_${key}\` (the bare namespace is the user's); pass \`_${key}\``;
+    if (key === "doc" && has("_id") && has("_path"))
+        return retired("`_id` or `_path`");
+    if ((key === "block" || key === "node") && has("_id"))
+        return retired("`_id`");
     if (key === "heading" && has("section"))
         return retired("`section` (the heading's text), or blocks_append with the heading's `id`");
     if (key === "markdown" && has("text"))

package/dist/src/mcp/errors.d.ts

@@ -1,4 +1,4 @@
-export type ErrorCode = "stale_expectation" | "parent_missing" | "target_missing" | "block_missing" | "doc_missing" | "cycle_move" | "opaque_block" | "not_contiguous" | "type_mismatch" | "conflicted_document" | "path_taken" | "create_conflict" | "ambiguous_locator" | "ambiguous_heading" | "filter_invalid" | "budget_exceeded" | "provider_unavailable" | "embedder_failed" | "sync_conflict" | "repo_not_found" | "node_not_editable" | "seed_unresolved" | "block_not_container" | "stale_plan" | "plan_not_convergent" | "conflicting_effects" | "unsupported_plan_version" | "plan_mismatch" | "ambiguous_target" | "selection_too_large" | "revision_archived";
+export type ErrorCode = "stale_expectation" | "parent_missing" | "target_missing" | "block_missing" | "doc_missing" | "cycle_move" | "opaque_block" | "not_contiguous" | "type_mismatch" | "conflicted_document" | "path_taken" | "create_conflict" | "ambiguous_locator" | "ambiguous_heading" | "filter_invalid" | "budget_exceeded" | "provider_unavailable" | "embedder_failed" | "sync_conflict" | "repo_not_found" | "node_not_editable" | "seed_unresolved" | "block_not_container" | "stale_plan" | "plan_not_convergent" | "conflicting_effects" | "unsupported_plan_version" | "plan_mismatch" | "ambiguous_target" | "selection_too_large" | "revision_archived" | "plan_unknown";
 export interface EngineErrorBody {
     error: ErrorCode;
     message: string;

package/dist/src/mcp/graph.d.ts

@@ -11,35 +11,35 @@ export interface GraphArgs {
     /** restrict the neighborhood to documents reachable from a root via edges of
      * this predicate, within `degrees` (both the docs and the edges are filtered). */
     predicate?: string | undefined;
-    /** extra document projections (OQX select expressions, e.g. "layer", "path"). */
+    /** extra document projections (OQX select expressions, e.g. "layer", "_path"). */
     select?: string[] | undefined;
     /** cap on the distinct documents returned (default 200). */
     max_documents?: number | undefined;
 }
 /** A traversed edge: a row of the `links` target under its own field names
- *  (spec/surface §1.2, 3.0 — `id` the edge, `doc_id`/`block_id` the source,
- *  `via_id`, `dst_id` the destination node, `dst_path`/`uri` its path or URI,
- *  `field` the authoring key). No rename table: what the walk projects is what
- *  the result carries. */
+ *  (spec/surface §1.2, 5.0 — `_id` the edge, `_doc_id`/`_block_id` the source,
+ *  `_via_id`, `_dst_id` the destination node, `_dst_path`/`_uri` its path or
+ *  URI, `_field` the authoring key). No rename table: what the walk projects is
+ *  what the result carries. */
 export interface GraphEdge {
-    id: string;
-    doc_id: string;
-    block_id: string | null;
-    via_id: string | null;
-    dst_id: string;
-    dst_path: string | null;
-    uri: string | null;
-    dst_kind: string;
-    predicate: string;
-    provenance: string;
-    anchor: string | null;
-    field: string | null;
+    _id: string;
+    _doc_id: string;
+    _block_id: string | null;
+    _via_id: string | null;
+    _dst_id: string;
+    _dst_path: string | null;
+    _uri: string | null;
+    _dst_kind: string;
+    _predicate: string;
+    _provenance: string;
+    _anchor: string | null;
+    _field: string | null;
 }
-/** A reached document: `id`/`path` (the row's own names, as a `query` hit)
+/** A reached document: `_id`/`_path` (the row's own names, as a `query` hit)
  *  + walk metadata + any requested projections. */
 export interface GraphDoc {
-    id: string;
-    path: string;
+    _id: string;
+    _path: string;
     /** minimum hop distance from a root (root = 0). */
     degree: number;
     /** true when this node sits on the outer boundary (its min degree == degrees). */
@@ -53,8 +53,8 @@ export interface GraphResult {
     documents: GraphDoc[];
     links: GraphEdge[];
     frontier: {
-        id: string;
-        path: string;
+        _id: string;
+        _path: string;
         degree: number;
     }[];
     truncated: boolean;

package/dist/src/mcp/graph.js

@@ -2,8 +2,8 @@
 //
 // ADR-006: OQX `follow` is the ONE traversal engine; the removed
 // graph_traverse/path/subgraph tools are not resurrected. This macro owns NO
-// graph-walking logic — it compiles its arguments into an OQX `follow out_links
-// collect { from dst }` / `follow in_links collect { from doc }` query (the
+// graph-walking logic — it compiles its arguments into an OQX `follow _out_links
+// collect { from _dst }` / `follow _in_links collect { from _doc }` query (the
 // exact walk the `query` tool exposes over the link rows),
 // runs it through the shared runner (oqxRunAsync), and then only SHAPES the
 // walk's own output (its `$depth`/`$stop` intrinsics and projected edges) into
@@ -11,17 +11,17 @@
 // bound is `follow`'s; nothing here re-implements BFS/DFS.
 //
 // Mapping (args → follow query):
-//   roots      → the seed `where id == … or …` (refs resolved to doc ids first; literals in the AST, never spliced text)
+//   roots      → the seed `where _id == … or …` (refs resolved to doc ids first; literals in the AST, never spliced text)
 //   degrees    → `follow … collect { … depth degrees+1 }` (seed is $depth 1, so N hops = depth N+1)
-//   direction  → `follow out_links collect { from dst }` (the linked documents)
-//                | `follow in_links collect { from doc }` (the linking documents)
+//   direction  → `follow _out_links collect { from _dst }` (the linked documents)
+//                | `follow _in_links collect { from _doc }` (the linking documents)
 //                | both (two walks, unioned)
 //   predicate  → restricts the neighborhood to docs reachable via that predicate
 //                (recomputed over the walk's collected edges; no `via` clause)
 //   select     → extra doc projections spliced into the walk's `select`
 //   max_documents → a post-walk cap on the distinct document set
 //
-// Edges are surfaced by projecting the reached doc's `doc.out_links`/`doc.in_links`
+// Edges are surfaced by projecting the reached doc's `_out_links`/`_in_links`
 // in the SAME walk (a select-position collect), then keeping the induced-subgraph
 // edges (both endpoints in the neighborhood) plus dangling stubs to external/
 // phantom targets — so external (`x_…`) and phantom endpoints are never dropped,
@@ -41,8 +41,8 @@ function cmpBytes(a, b) {
 // Build the extra `select` items for caller projections. Each expression gets a
 // stable internal alias (_u0, _u1, …) so it can never collide with a reserved
 // word or the macro's own aliases; the clean output name is derived separately.
-// A bare-name selection (`layer`, `title`) is its own output key, exactly as a
-// `query` hit projects it (spec/surface §1.4, 3.0) — so `id`/`path` collapse
+// A bare-name selection (`layer`, `_title`) is its own output key, exactly as a
+// `query` hit projects it (spec/surface §1.4, 5.0) — so `_id`/`_path` collapse
 // onto the envelope keys (the engine reads the same value) and any other name
 // is an ordinary column, deduped by suffix. Anything else (an expression) is
 // `sel_<i>`, so a projection can never overwrite the envelope here.
@@ -51,16 +51,16 @@ function buildUserSelect(select) {
     const outNames = [];
     if (!select || select.length === 0)
         return { items, outNames };
-    const used = new Set(["id", "path"]);
+    const used = new Set(["_id", "_path"]);
     select.forEach((expr, i) => {
         const trimmed = expr.trim();
         if (!trimmed)
             return;
         const m = /^(\$?[A-Za-z_][A-Za-z0-9_]*)$/.exec(trimmed);
         let name = m ? m[1] : `sel_${i}`;
-        // The envelope keys are the row's own identity: an `id`/`path` selection
+        // The envelope keys are the row's own identity: an `_id`/`_path` selection
         // lands on them rather than beside them (the engine reads the same value).
-        if (name !== "id" && name !== "path") {
+        if (name !== "_id" && name !== "_path") {
             while (used.has(name))
                 name = `${name}_${i}`;
             used.add(name);
@@ -86,40 +86,47 @@ function userItems(src, alias) {
     }
     return q.select;
 }
-// The edge fields projected from doc.out_links/doc.in_links — the `links`
-// target's own names, projected under themselves (spec/surface §1.2, 3.0: no
+// The edge fields projected from `_out_links`/`_in_links` — the `links`
+// target's own names, projected under themselves (spec/surface §1.2, 5.0: no
 // rename between the language and the result) — identical for both directions
 // so a single filter handles either scan (an edge is a directional fact
 // regardless of which endpoint the walk reached it from).
 const EDGE_FIELDS = [
-    "id", "doc_id", "block_id", "via_id", "dst_id", "dst_path", "uri",
-    "dst_kind", "predicate", "provenance", "anchor", "field",
+    "_id", "_doc_id", "_block_id", "_via_id", "_dst_id", "_dst_path", "_uri",
+    "_dst_kind", "_predicate", "_provenance", "_anchor", "_field",
 ];
+// The macro's own aliases: `__oqx_`/`__omg_` (two underscores) are the runner's
+// and the selector compiler's reserved prefixes; a single underscore is the
+// engine prefix of 5.0, which an ALIAS may use freely (an alias is never a row
+// read), and keeps these off any authored key.
+const DEPTH_ALIAS = "_depth";
+const STOP_ALIAS = "_stop";
+const LINKS_ALIAS = "_links";
 // The walk, as an AST (spec/oqx/AST.md §7) printed canonically — never spliced
 // strings: the seed ids are literals, the caller's projections parsed items.
 //
-//   select _depth: $depth, _stop: $stop, _links: doc.<dir>_links collect { <edge fields> } <user items>
-//   from docs where id == <root> or … follow distinct <dir>_links collect { from <dst | doc> depth <depth> }
+//   select _depth: $depth, _stop: $stop, _links: _<dir>_links collect { <edge fields> } <user items>
+//   from docs where _id == <root> or … follow distinct _<dir>_links collect { from <_dst | _doc> depth <depth> }
 //
 // The destination block walks the link rows to the documents at their other
 // end (spec/surface §1.2, 3.0 follow-up: there are no `out`/`in` relations —
-// `dst` is a link's destination document, `doc` its source; a `from` over an
-// absent `dst` — an external or phantom target — contributes no successor).
+// `_dst` is a link's destination document, `_doc` its source; a `from` over an
+// absent `_dst` — an external or phantom target — contributes no successor).
 function buildQuery(rootIds, dir, depth, userSelect) {
-    const edges = build.op(build.path("doc", `${dir}_links`), "collect", build.subquery({
+    const edges = build.op(build.ident(`_${dir}_links`), "collect", build.subquery({
         select: EDGE_FIELDS.map((name) => build.field(name, build.ident(name))),
     }));
-    const seed = rootIds.map((id) => build.scalar(build.binary("==", build.ident("id"), build.lit(id))));
+    const seed = rootIds.map((id) => build.scalar(build.binary("==", build.ident("_id"), build.lit(id))));
     const q = build.query(build.ident("docs"), {
         select: [
-            build.field("_depth", build.ident("$depth")),
-            build.field("_stop", build.ident("$stop")),
-            build.collect("_links", edges),
+            build.field(DEPTH_ALIAS, build.ident("$depth")),
+            build.field(STOP_ALIAS, build.ident("$stop")),
+            build.collect(LINKS_ALIAS, edges),
             ...userSelect,
         ],
         where: seed.length === 1 ? seed[0] : build.or(seed),
         // `depth` is the destination block's own clause (oqx 0.20).
-        follow: build.follow([build.op(build.ident(`${dir}_links`), "collect", build.subquery({ from: [build.ident(dir === "out" ? "dst" : "doc")], depth }))], { distinct: true }),
+        follow: build.follow([build.op(build.ident(`_${dir}_links`), "collect", build.subquery({ from: [build.ident(dir === "out" ? "_dst" : "_doc")], depth }))], { distinct: true }),
     });
     return print(q);
 }
@@ -163,26 +170,26 @@ export async function graphNeighborhood(store, repoId, args, embedQuery) {
         if (res.truncated)
             queryTruncated = true;
         for (const hit of res.hits) {
-            const hopDepth = Number(hit._depth); // $depth: seed = 1
+            const hopDepth = Number(hit[DEPTH_ALIAS]); // $depth: seed = 1
             const degree = hopDepth - 1; // root = 0
-            // The walk's hits carry `id`/`path` (spec/surface §1.4, 3.0) and so
+            // The walk's hits carry `_id`/`_path` (spec/surface §1.4, 5.0) and so
             // does `graph`'s document: one notation for a document everywhere.
-            const prev = docMap.get(hit.id);
+            const prev = docMap.get(hit._id);
             if (!prev || degree < prev.degree) {
-                const doc = { id: hit.id, path: hit.path, degree, frontier: false };
+                const doc = { _id: hit._id, _path: hit._path, degree, frontier: false };
                 outNames.forEach((name, i) => {
-                    // An `id`/`path` selection is the envelope key itself (same value).
-                    if (name !== undefined && name !== "id" && name !== "path")
+                    // An `_id`/`_path` selection is the envelope key itself (same value).
+                    if (name !== undefined && name !== "_id" && name !== "_path")
                         doc[name] = hit[`_u${i}`] ?? null;
                 });
-                docMap.set(hit.id, doc);
+                docMap.set(hit._id, doc);
             }
             // Gather this node's edges; dedup by edge id (an a→b edge is reachable as
             // a's out-edge AND b's in-edge in "both" mode).
-            const raw = hit._links ?? [];
+            const raw = hit[LINKS_ALIAS] ?? [];
             for (const e of raw)
-                if (!edgeMap.has(e.id))
-                    edgeMap.set(e.id, e);
+                if (!edgeMap.has(e._id))
+                    edgeMap.set(e._id, e);
         }
     }
     // Predicate filter restricts the NEIGHBORHOOD, not just the edge list: a doc is
@@ -196,12 +203,12 @@ export async function graphNeighborhood(store, repoId, args, embedQuery) {
         const adj = new Map();
         const link = (from, to) => { (adj.get(from) ?? adj.set(from, []).get(from)).push(to); };
         for (const e of edgeMap.values()) {
-            if (e.predicate !== P)
+            if (e._predicate !== P)
                 continue;
             if (dirs.includes("out"))
-                link(e.doc_id, e.dst_id); // forward
+                link(e._doc_id, e._dst_id); // forward
             if (dirs.includes("in"))
-                link(e.dst_id, e.doc_id); // backward
+                link(e._dst_id, e._doc_id); // backward
         }
         const depthOf = new Map(rootIds.map((id) => [id, 0]));
         let wave = [...rootIds];
@@ -230,10 +237,10 @@ export async function graphNeighborhood(store, repoId, args, embedQuery) {
             docMap.set(id, d);
     }
     // Cap the distinct document set (nearest-first), then bound edges to it.
-    const allDocs = [...docMap.values()].sort((a, b) => a.degree - b.degree || cmpBytes(a.path, b.path));
+    const allDocs = [...docMap.values()].sort((a, b) => a.degree - b.degree || cmpBytes(a._path, b._path));
     const capped = allDocs.length > maxDocuments;
     const documents = allDocs.slice(0, maxDocuments);
-    const reached = new Set(documents.map((d) => d.id));
+    const reached = new Set(documents.map((d) => d._id));
     const truncated = queryTruncated || capped;
     // Mark the outer boundary: a node whose MIN degree equals the requested reach
     // was only ever touched at the edge of the walk (never expanded past). At
@@ -242,7 +249,7 @@ export async function graphNeighborhood(store, repoId, args, embedQuery) {
     for (const d of documents) {
         d.frontier = d.degree === effectiveDegrees;
         if (d.frontier)
-            frontier.push({ id: d.id, path: d.path, degree: d.degree });
+            frontier.push({ _id: d._id, _path: d._path, degree: d.degree });
     }
     // Keep the induced-subgraph edges (both endpoints in the neighborhood) plus
     // dangling stubs to external/phantom targets, so external (x_…) and phantom
@@ -251,15 +258,15 @@ export async function graphNeighborhood(store, repoId, args, embedQuery) {
     // predicate-reachable docs above).
     const edges = [];
     for (const e of edgeMap.values()) {
-        if (args.predicate && e.predicate !== args.predicate)
+        if (args.predicate && e._predicate !== args.predicate)
             continue;
-        const srcIn = reached.has(e.doc_id);
-        const dstDangling = e.dst_kind === "external" || (e.dst_kind === "document" && e.dst_path === null);
-        const dstIn = reached.has(e.dst_id) || dstDangling;
+        const srcIn = reached.has(e._doc_id);
+        const dstDangling = e._dst_kind === "external" || (e._dst_kind === "document" && e._dst_path === null);
+        const dstIn = reached.has(e._dst_id) || dstDangling;
         if (srcIn && dstIn)
             edges.push(e);
     }
-    edges.sort((a, b) => cmpBytes(a.doc_id, b.doc_id) || cmpBytes(a.id, b.id));
+    edges.sort((a, b) => cmpBytes(a._doc_id, b._doc_id) || cmpBytes(a._id, b._id));
     return {
         roots: rootIds,
         degrees: effectiveDegrees,