@omgbase/core 0.10.1 → 0.11.1

package/dist/src/search/cel/compile.js

@@ -12,7 +12,7 @@ export function defaultCtx(target) {
         return { self: "d", doc: "d" };
     if (target === "blocks")
         return { self: "b", doc: "d" };
-    if (target === "edges")
+    if (target === "links")
         return { self: "e", doc: "d" };
     return { self: "n", doc: "d" };
 }
@@ -35,33 +35,14 @@ function jsonPath(segs) {
 // blob. A field access is one of: a scalar-value expression (comparisons), or
 // an existence/count predicate (membership, size, has, bool-context). All
 // correlate on `<doc>.doc_id` (the correlated docs row, present on every target).
-const PROP_SOURCES = new Set(["frontmatter", "inline", "computed"]);
+const PROP_SOURCES = new Set(["data", "frontmatter", "inline", "computed"]);
 // Computed properties surfaced as document intrinsics (12 §4). Engine-derived,
 // stored as source='computed' rows keyed by their $ name. Filterable like any
 // property (scalar ==, list(), membership) but never shadow authored keys.
 const COMPUTED_INTRINSICS = new Set(["$title", "$tags"]);
-// Base names of the document intrinsics ($id, $path, ...) MINUS their `$`. On
-// the docs open namespace (and doc.<k> reach-through), a BARE first segment
-// equal to one of these is almost always a typo for the intrinsic: it would
-// otherwise resolve to an absent frontmatter key and silently match nothing
-// (a misleading empty). We reject it with a hint instead. `title`/`tags` are
-// deliberately EXCLUDED: their $-forms are `computed` intrinsics that do not
-// shadow authored frontmatter, so bare `title`/`tags` remain legitimate key
-// access (see COMPUTED_INTRINSICS and QUERY_SYNTAX). A source-scoped form
-// (frontmatter.path / inline.path) is an explicit request for that property
-// and is likewise not caught — only the bare first-segment case is the trap.
-const RESERVED_INTRINSIC_BASENAMES = new Set([
-    "id", "path", "repo", "updated_at", "content_hash", "body",
-]);
-// Guard the docs open namespace against reserved-intrinsic collisions. `segs`
-// are the property key segments (after any doc./source scope has been peeled).
-// Throws when the FIRST segment shadows an intrinsic base name.
-function guardReservedCollision(segs) {
-    if (RESERVED_INTRINSIC_BASENAMES.has(segs[0])) {
-        const name = segs[0];
-        throw new FilterInvalid(`bare '${name}' reads a frontmatter key; did you mean the intrinsic $${name}? (use frontmatter.${name} to force the property)`, "10 §2");
-    }
-}
+// There is no reserved-basename guard any more (spec/surface §1.2, 3.0): the
+// engine attributes are bare and win on collision; an authored key of the same
+// name is reached through `data.<k>` / `frontmatter.<k>` / `inline.<k>`.
 // Validate + join identifier segments into a dotted property key. Segments come
 // from the lexer's identifier rule, so inlining is injection-safe (mirrors
 // jsonPath); keeping keys param-free preserves the "fields carry no params"
@@ -81,7 +62,7 @@ function propKey(segs) {
 function propRef(field, target) {
     let segs = field.segments;
     if (target === "docs") {
-        // Computed intrinsic ($title, $tags): route to source='computed' rows.
+        // Computed intrinsic (title, tags): route to source='computed' rows.
         if (field.intrinsic) {
             if (segs.length === 1 && COMPUTED_INTRINSICS.has(segs[0]))
                 return { key: segs[0], source: "computed" };
@@ -97,7 +78,7 @@ function propRef(field, target) {
         if (segs[0] !== "doc")
             return null;
         segs = segs.slice(1);
-        // doc.$title reach-through to a computed intrinsic.
+        // doc.title reach-through to a computed intrinsic.
         if (segs.length === 1 && COMPUTED_INTRINSICS.has(segs[0]))
             return { key: segs[0], source: "computed" };
         if (segs.length === 0 || segs[0].startsWith("$") || segs[0] === "format")
@@ -107,10 +88,6 @@ function propRef(field, target) {
         const source = segs[0];
         return { key: propKey(segs.slice(1)), source };
     }
-    // Bare (non-`$`, non-source-scoped) key: reject a first segment that shadows
-    // a reserved intrinsic base name (path/id/repo/...) so a typo for `$path`
-    // fails loud instead of silently resolving to an absent frontmatter key.
-    guardReservedCollision(segs);
     return { key: propKey(segs) };
 }
 function srcClause(source, alias = "p") {
@@ -186,13 +163,12 @@ function fieldSql(field, target, ctx) {
     if (field.intrinsic) {
         if (target === "docs") {
             switch (head) {
-                case "$id": return { expr: `${self}.doc_id` };
-                case "$path": return { expr: `${self}.path` };
-                case "$repo": return { expr: `${self}.repo_id` };
-                case "$updated_at": return { expr: `(SELECT c.ts FROM revisions r JOIN commits c ON c.commit_id = r.commit_id WHERE r.rev_id = ${self}.current_rev)` };
-                case "$content_hash": return { expr: `lower(hex(${self}.file_hash))` };
+                case "id": return { expr: `${self}.doc_id` };
+                case "path": return { expr: `${self}.path` };
+                case "updated_at": return { expr: `(SELECT c.ts FROM revisions r JOIN commits c ON c.commit_id = r.commit_id WHERE r.rev_id = ${self}.current_rev)` };
+                case "hash": return { expr: `lower(hex(${self}.file_hash))` };
                 default: {
-                    // Computed property intrinsic ($title, $tags) → properties row scalar.
+                    // Computed property intrinsic (title, tags) → properties row scalar.
                     const ref = propRef(field, target);
                     if (ref)
                         return { expr: propScalarExpr(ref, ctx) };
@@ -202,41 +178,24 @@ function fieldSql(field, target, ctx) {
         }
         else if (target === "nodes") {
             switch (head) {
-                case "$id": return { expr: `${self}.node_id` };
-                case "$node_id": return { expr: `${self}.node_id` };
-                case "$doc_id": return { expr: `${self}.doc_id` };
-                case "$block_id": return { expr: `${self}.block_id` };
-                case "$path": return { expr: `${doc}.path` };
+                case "id": return { expr: `${self}.node_id` };
+                case "path": return { expr: `${doc}.path` };
                 default: throw new FilterInvalid(`unknown intrinsic ${head} on nodes`, "10 §2");
             }
         }
-        else if (target === "edges") {
+        else if (target === "links") {
             switch (head) {
-                case "$id": return { expr: `${self}.edge_id` };
-                case "$src": return { expr: `${self}.src_doc` };
-                case "$dst": return { expr: `${self}.dst_node` };
-                case "$src_block": return { expr: `${self}.src_block` };
-                case "$via": return { expr: `${self}.via_node` };
-                case "$from_commit": return { expr: `${self}.from_commit` };
-                case "$path": return { expr: `${doc}.path` }; // source document's path
-                // Meaningful destination, resolved per dst_kind (cheap correlated lookups,
-                // NULL when not applicable): the target document's path, or the external
-                // node's URI. Lets `from edges` show real targets, not opaque node ids.
-                case "$dst_path": return { expr: `(SELECT dd.path FROM docs dd WHERE dd.doc_id = ${self}.dst_node)` };
-                case "$dst_uri": return { expr: `(SELECT xn.uri FROM external_nodes xn WHERE xn.node_id = ${self}.dst_node)` };
-                default: throw new FilterInvalid(`unknown intrinsic ${head} on edges`, "10 §2");
+                case "id": return { expr: `${self}.edge_id` };
+                case "path": return { expr: `${doc}.path` }; // source document's path
+                default: throw new FilterInvalid(`unknown intrinsic ${head} on links`, "10 §2");
             }
         }
         else {
             switch (head) {
-                case "$id": return { expr: `${self}.block_id` };
-                case "$doc": return { expr: `${self}.doc_id` };
-                case "$path": return { expr: `${doc}.path` };
-                case "$ordinal": return { expr: `${self}.ordinal` };
-                case "$depth": return { expr: `${self}.depth` };
-                case "$content_hash": return { expr: `lower(hex(${self}.raw_hash))` };
-                case "$body": return { expr: `${self}.text` };
-                case "$updated_at": return { expr: `(SELECT MAX(c.ts) FROM block_changes bc JOIN commits c ON c.commit_id = bc.commit_id WHERE bc.block_id = ${self}.block_id)` };
+                case "id": return { expr: `${self}.block_id` };
+                case "path": return { expr: `${doc}.path` };
+                case "hash": return { expr: `lower(hex(${self}.raw_hash))` };
+                case "updated_at": return { expr: `(SELECT MAX(c.ts) FROM block_changes bc JOIN commits c ON c.commit_id = bc.commit_id WHERE bc.block_id = ${self}.block_id)` };
                 default: throw new FilterInvalid(`unknown intrinsic ${head} on blocks`, "10 §2");
             }
         }
@@ -281,7 +240,7 @@ function fieldSql(field, target, ctx) {
         }
         throw new FilterInvalid(`unknown field '${segs.join(".")}' on nodes`, "10 §2");
     }
-    if (target === "edges") {
+    if (target === "links") {
         if (head === "predicate")
             return { expr: `${self}.predicate` };
         if (head === "provenance")
@@ -290,7 +249,21 @@ function fieldSql(field, target, ctx) {
             return { expr: `${self}.dst_kind` };
         if (head === "anchor")
             return { expr: `${self}.anchor` };
-        if (head === "src_field")
+        // The links target's plain fields (spec/surface §1.2, 3.0): foreign keys
+        // named for what they are, the `src_field` column as `field`.
+        if (head === "doc_id")
+            return { expr: `${self}.src_doc` };
+        if (head === "block_id")
+            return { expr: `${self}.src_block` };
+        if (head === "via_id")
+            return { expr: `${self}.via_node` };
+        if (head === "dst_id")
+            return { expr: `${self}.dst_node` };
+        if (head === "dst_path")
+            return { expr: `(SELECT dd.path FROM docs dd WHERE dd.doc_id = ${self}.dst_node)` };
+        if (head === "uri")
+            return { expr: `(SELECT xn.uri FROM external_nodes xn WHERE xn.node_id = ${self}.dst_node)` };
+        if (head === "field")
             return { expr: `${self}.src_field` };
         if (head === "doc") {
             // reach-through to the SOURCE document (edges join docs on src_doc).
@@ -305,7 +278,7 @@ function fieldSql(field, target, ctx) {
                 return { expr: propScalarExpr(ref, ctx) };
             return { expr: `json_extract(${doc}.metadata, ${jsonPath(rest)})` };
         }
-        throw new FilterInvalid(`unknown field '${segs.join(".")}' on edges`, "10 §2");
+        throw new FilterInvalid(`unknown field '${segs.join(".")}' on links`, "10 §2");
     }
     // blocks target
     if (head === "type")
@@ -674,8 +647,8 @@ function compileWithin(target, ctx) {
 // match their own row; docs match when any of their blocks does; nodes use the
 // node FTS index. Aliased by the scope so it works under OQX's per-scope aliases.
 function compileText(terms, target, ctx) {
-    if (target === "edges")
-        throw new FilterInvalid("text(...) is not available on the edges target (edges carry no text index)", "10 §5");
+    if (target === "links")
+        throw new FilterInvalid("text(...) is not available on the links target (links carry no text index)", "10 §5");
     const match = sanitizeFtsQuery(terms);
     if (match === "")
         return { sql: "(1 = 0)", params: [] };
@@ -701,8 +674,8 @@ function compileText(terms, target, ctx) {
 // threshold comparison excludes it (absence = false). The query vector + model
 // come from ctx.semantic (the runner embedded the literal); absent ⇒ loud.
 function compileSemantic(phrase, target, ctx) {
-    if (target === "nodes" || target === "edges") {
-        throw new FilterInvalid('semantic(...) is available on the docs and blocks targets (nodes/edges have no embeddings)', "OQX semantic");
+    if (target === "nodes" || target === "links") {
+        throw new FilterInvalid('semantic(...) is available on the docs and blocks targets (nodes/links have no embeddings)', "OQX semantic");
     }
     const resolved = ctx.semantic?.(phrase);
     if (!resolved) {

package/dist/src/search/cel/parser.js

@@ -103,7 +103,7 @@ class Parser {
         while (this.peek().type === "dot") {
             this.next();
             // A `$`-segment after a dot is an intrinsic reach-through continuation
-            // (`doc.$path`, `doc.$updated_at`): the lexer emits it as a `field` token
+            // (`doc.path`, `doc.updated_at`): the lexer emits it as a `field` token
             // (value keeps the `$`). It is never a method receiver, so append it as a
             // field segment directly. The compiler routes `doc.$…` to docs intrinsics.
             if (this.peek().type === "field") {

package/dist/src/search/resolve.d.ts

@@ -1,4 +1,6 @@
 import type { Store } from "../core/store/store.js";
+/** A resolve hit (spec/search §4): the block's `id` (spec/surface §1.2, 3.0),
+ *  its `locator`, a `preview` and the fusion `evidence`. */
 export interface ResolveHit {
     id: string;
     locator: string;

package/dist/src/search/rrf.js

@@ -43,8 +43,8 @@ export function hybridSearch(store, input) {
     const ftsRanks = new Map();
     if (input.text) {
         textSearch(store, input.repoId, input.text, { limit: 200 }).hits.forEach((h, i) => {
-            if (!ftsRanks.has(h.blockId))
-                ftsRanks.set(h.blockId, i + 1);
+            if (!ftsRanks.has(h.id))
+                ftsRanks.set(h.id, i + 1);
         });
     }
     const vecRanks = new Map();

package/dist/src/search/text.d.ts

@@ -1,7 +1,7 @@
 import type { Store } from "../core/store/store.js";
 export interface TextHit {
-    blockId: string;
-    docId: string;
+    id: string;
+    doc_id: string;
     path: string;
     type: string;
     text: string;

package/dist/src/search/text.js

@@ -5,7 +5,7 @@ export function textSearch(store, repoId, queryStr, opts = {}) {
     if (match === "")
         return { hits: [], truncated: false };
     const rows = store.db
-        .prepare(`SELECT b.block_id AS blockId, b.doc_id AS docId, d.path AS path, b.type AS type,
+        .prepare(`SELECT b.block_id AS "id", b.doc_id AS doc_id, d.path AS "path", b.type AS type,
               b.text AS text, bm25(blocks_fts) AS score
        FROM blocks_fts
        JOIN blocks b ON b.rowid = blocks_fts.rowid

package/dist/src/spec-versions.d.ts

@@ -1,14 +1,14 @@
 export declare const SPEC_VERSIONS: {
-    readonly oqx: "0.18";
+    readonly oqx: "0.20";
     readonly format: "0.2";
     readonly reconcile: "2.3";
     readonly store: "13.5";
     readonly properties: "1.1";
     readonly graph: "1.1";
-    readonly search: "1.2";
-    readonly mutate: "1.3";
-    readonly sync: "1.3";
-    readonly surface: "2.0";
-    readonly cli: "2.0";
+    readonly search: "2.0";
+    readonly mutate: "2.0";
+    readonly sync: "2.0";
+    readonly surface: "3.0";
+    readonly cli: "3.0";
 };
 export type SpecName = keyof typeof SPEC_VERSIONS;

package/dist/src/spec-versions.js

@@ -16,10 +16,10 @@ export const SPEC_VERSIONS = {
     store: "13.5",
     properties: "1.1",
     graph: "1.1",
-    search: "1.2",
-    mutate: "1.3",
-    sync: "1.3",
-    surface: "2.0",
-    cli: "2.0",
+    search: "2.0",
+    mutate: "2.0",
+    sync: "2.0",
+    surface: "3.0",
+    cli: "3.0",
 };
 //# sourceMappingURL=spec-versions.js.map

package/dist/src/surface-paths.d.ts

@@ -3,22 +3,55 @@ import type { DocOpResult, DocMoveResult } from "./mutate/docs.js";
 import type { RetargetHit } from "./mutate/macros.js";
 import type { Opset } from "./mutate/opset.js";
 import type { DocsUpdateResult } from "./mutate/plan-update.js";
+import type { InboundLink } from "./graph/inbound-links.js";
 import type { ObserveResult, ObserveDeleteResult } from "./sync/observe.js";
 import type { SweepResult } from "./sync/freshness.js";
 import type { TextSearchResult } from "./search/text.js";
 import type { ResolveHit } from "./search/resolve.js";
 /** `spec/mutate` §4's result: `revisions[].path` and the dry-run `diffs` keys. */
 export declare function surfaceApplyResult<T extends ApplyResult>(res: T): T;
-/** `docs_create` / `docs_delete` / `docs_set_meta`: `path` and the `diffs` keys. */
-export declare function surfaceDocOpResult<T extends DocOpResult>(res: T): T;
-/** `docs_move`: the document-op fields plus each dangling link's source `path`
- *  (its `target` stays as authored — that is what the link says). */
-export declare function surfaceDocMoveResult(res: DocMoveResult): DocMoveResult;
+/** A document operation's result on the wire (spec/surface §4, 3.0): the
+ *  library's `{ docId, path, … }` (`spec/mutate` §6, unchanged there) renamed
+ *  to the document's row attributes `id`/`path`, the path rooted, the
+ *  dry-run `diffs` re-keyed; every other key (`committed`, `deleted`, …) as is. */
+export type SurfaceDocOpResult<T extends DocOpResult> = Omit<T, "docId" | "path"> & {
+    id: string;
+    path: string;
+};
+/** `docs_create` / `docs_delete` / `docs_set_meta`. */
+export declare function surfaceDocOpResult<T extends DocOpResult>(res: T): SurfaceDocOpResult<T>;
+/** An inbound link on the wire (`docs_move.dangling[]`): an edge row under the
+ *  `edges` target's names (spec/surface §1.2) — `doc_id`, `path` (rooted),
+ *  `block_id`, `target` (as authored), `anchor`, `field?`. */
+export interface SurfaceInboundLink {
+    doc_id: string;
+    path: string;
+    block_id: string | null;
+    target: string;
+    anchor: string | null;
+    field?: string;
+}
+export declare function surfaceInboundLink(l: InboundLink): SurfaceInboundLink;
+/** `docs_move`: the document-op fields plus each dangling link (its `target`
+ *  stays as authored — that is what the link says). */
+export declare function surfaceDocMoveResult(res: DocMoveResult): Omit<SurfaceDocOpResult<DocMoveResult>, "dangling"> & {
+    dangling: SurfaceInboundLink[];
+};
+/** An observe outcome on the wire (spec/surface §4, 3.0): `spec/store` §5's
+ *  `{ docId, path, … }` (unchanged there) renamed to the document's row
+ *  attributes `id`/`path`, the path rooted. */
+export type SurfaceObserveResult<T extends {
+    docId: string | null;
+    path: string;
+}> = Omit<T, "docId" | "path"> & {
+    id: T["docId"];
+    path: string;
+};
 /** `observe` / `observe_many` outcomes. */
-export declare function surfaceObserveResult<T extends ObserveResult>(res: T): T;
+export declare function surfaceObserveResult<T extends ObserveResult>(res: T): SurfaceObserveResult<T>;
 /** `observe_delete`. */
-export declare function surfaceObserveDeleteResult(res: ObserveDeleteResult): ObserveDeleteResult;
-/** `text_search` hits. */
+export declare function surfaceObserveDeleteResult(res: ObserveDeleteResult): SurfaceObserveResult<ObserveDeleteResult>;
+/** `blocks_search` hits (`path` rooted). */
 export declare function surfaceTextSearch(res: TextSearchResult): TextSearchResult;
 /** `resolve` hits: the locator is `<path>#<type>[<ordinal>]`; its path half is
  *  rooted (a locator without `#` names no path and is left alone). */

package/dist/src/surface-paths.js

@@ -1,13 +1,22 @@
-// The surface's path rule applied at its boundary (spec/surface §1 "Paths",
-// 2.0): every path a tool or verb returns is `/`-rooted. The surface-owned
-// readers (`core/read`, `graph/history`, `graph/link-health`, the query
-// binding) root their own output; the results that belong to another spec —
-// `spec/mutate`'s apply and document-operation results and opsets,
-// `spec/store`'s observe outcomes, `spec/search`'s hits, `spec/sync`'s sweep —
-// keep their storage-form paths in the library (their own fixtures pin them)
-// and are re-shaped HERE, by the MCP server and the `omg` verbs alike, so the
-// two clients cannot drift. Each function returns a new value; the input is
-// not mutated.
+// The surface's rules applied at its boundary. Two of them:
+//
+// Paths (spec/surface §1 "Paths", 2.0): every path a tool or verb returns is
+// `/`-rooted. The surface-owned readers (`core/read`, `graph/history`,
+// `graph/link-health`, the query binding) root their own output; the results
+// that belong to another spec — `spec/mutate`'s apply and document-operation
+// results and opsets, `spec/store`'s observe outcomes, `spec/search`'s hits,
+// `spec/sync`'s sweep — keep their storage-form paths in the library (their
+// own fixtures pin them) and are re-shaped HERE.
+//
+// Row names (spec/surface §1.2, 3.0): a result that renders a document, block
+// or edge row spells it the way the query binding does — `id`, `path`,
+// `hash`, `raw`, `updated_at`, plain `doc_id`/`block_id` foreign keys. The
+// shapes other specs own under their own names — `spec/mutate`'s document
+// operation result `{ docId, path, … }`, `spec/store`'s observe outcome — are
+// re-shaped HERE too (`SurfaceDocOpResult`, `SurfaceObserveResult`, …).
+//
+// Both the MCP server and the `omg` verbs call these, so the two clients
+// cannot drift. Each function returns a new value; the input is not mutated.
 import { referencePath, referenceKeyed } from "./core/paths.js";
 /** `spec/mutate` §4's result: `revisions[].path` and the dry-run `diffs` keys. */
 export function surfaceApplyResult(res) {
@@ -17,24 +26,31 @@ export function surfaceApplyResult(res) {
         ...(res.diffs ? { diffs: referenceKeyed(res.diffs) } : {}),
     };
 }
-/** `docs_create` / `docs_delete` / `docs_set_meta`: `path` and the `diffs` keys. */
+/** `docs_create` / `docs_delete` / `docs_set_meta`. */
 export function surfaceDocOpResult(res) {
-    return { ...res, path: referencePath(res.path), ...(res.diffs ? { diffs: referenceKeyed(res.diffs) } : {}) };
+    const { docId, path, ...rest } = res;
+    return { id: docId, path: referencePath(path), ...rest, ...(res.diffs ? { diffs: referenceKeyed(res.diffs) } : {}) };
 }
-/** `docs_move`: the document-op fields plus each dangling link's source `path`
- *  (its `target` stays as authored — that is what the link says). */
+export function surfaceInboundLink(l) {
+    const { path, ...rest } = l;
+    return { doc_id: rest.doc_id, path: referencePath(path), block_id: rest.block_id, target: rest.target, anchor: rest.anchor, ...(rest.field !== undefined ? { field: rest.field } : {}) };
+}
+/** `docs_move`: the document-op fields plus each dangling link (its `target`
+ *  stays as authored — that is what the link says). */
 export function surfaceDocMoveResult(res) {
-    return { ...surfaceDocOpResult(res), dangling: res.dangling.map((l) => ({ ...l, path: referencePath(l.path) })) };
+    return { ...surfaceDocOpResult(res), dangling: res.dangling.map(surfaceInboundLink) };
 }
 /** `observe` / `observe_many` outcomes. */
 export function surfaceObserveResult(res) {
-    return { ...res, path: referencePath(res.path) };
+    const { docId, path, ...rest } = res;
+    return { id: docId, path: referencePath(path), ...rest };
 }
 /** `observe_delete`. */
 export function surfaceObserveDeleteResult(res) {
-    return { ...res, path: referencePath(res.path) };
+    const { docId, path, ...rest } = res;
+    return { id: docId, path: referencePath(path), ...rest };
 }
-/** `text_search` hits. */
+/** `blocks_search` hits (`path` rooted). */
 export function surfaceTextSearch(res) {
     return { ...res, hits: res.hits.map((h) => ({ ...h, path: referencePath(h.path) })) };
 }

package/dist/src/sync/admin.d.ts

@@ -10,7 +10,8 @@ export interface DiskStatus extends DiskDrift {
     checked: boolean;
 }
 export interface RepoStatus {
-    repoId: string;
+    /** the repository's own id (spec/surface §1.2, 3.0: every row names its identity `id`) */
+    id: string;
     slug: string;
     rootPath: string;
     docs: number;

package/dist/src/sync/admin.js

@@ -18,7 +18,7 @@ export function reposStatus(store, repoId, rootPath) {
         ? { ...detectDiskDrift(store, repoId, rootPath), checked: true }
         : { changed: 0, deleted: 0, untracked: 0, checked: false };
     return {
-        repoId,
+        id: repoId,
         slug: repo?.slug ?? "",
         rootPath: rootPath ?? "",
         docs: count("SELECT count(*) c FROM docs WHERE repo_id = ? AND deleted_commit IS NULL"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omgbase/core",
-  "version": "0.10.1",
+  "version": "0.11.1",
   "description": "Open Markdown Graph Base — embedded engine",
   "license": "MIT",
   "repository": {
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@omgbase/oqx": "^0.18.0",
+    "@omgbase/oqx": "^0.20.0",
     "better-sqlite3": "^13.0.3",
     "mdast-util-from-markdown": "^2.0.2",
     "mdast-util-frontmatter": "^2.0.1",