@lucern/graph-primitives 1.0.28 → 1.0.30

package/dist/epistemicNodes.queries.js

@@ -1,10 +1,14 @@
-import { v } from 'convex/values';
 import { checkScopeAccess } from '@lucern/access-control/access';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { componentsGeneric, queryGeneric, anyApi } from 'convex/server';
+import { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, queryGeneric } from 'convex/server';
 
 // src/epistemicNodes.queries.ts
-var api = anyApi;
+var unsafeApi = unsafeConvexAnyApi(
+  "graph-primitives top-level module bundle lacks a committed Convex _generated/api surface"
+);
+var api = unsafeApi;
 componentsGeneric();
 var query = queryGeneric;
 
@@ -19,6 +23,153 @@ function debugGraphPrimitiveFallback(message, context) {
   }
   console.debug(message, context ?? {});
 }
+
+// src/epistemicNodes.helpers.ts
+var DEFAULT_NODE_PAGE_SIZE = 250;
+var MAX_NODE_PAGE_SIZE = 8e3;
+function clampNodeLimit(limit, fallback = DEFAULT_NODE_PAGE_SIZE) {
+  if (!Number.isFinite(limit)) {
+    return fallback;
+  }
+  return Math.max(1, Math.min(Math.floor(limit), MAX_NODE_PAGE_SIZE));
+}
+function dedupeWorkspaceNodes(nodes) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const node of nodes) {
+    const key = String(node._id);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    deduped.push(node);
+  }
+  return deduped;
+}
+function nodeMatchesWorkspaceReasoningScope(node, scope) {
+  return scope.topicId !== void 0 && node.topicId === scope.topicId || scope.projectId !== void 0 && node.projectId === scope.projectId;
+}
+async function collectScopedNodes(ctx, scope, args) {
+  const queries = [];
+  if (scope.topicId) {
+    queries.push(
+      args.nodeType ? ctx.db.query("epistemicNodes").withIndex(
+        "by_topic_type",
+        (q) => q.eq("topicId", scope.topicId).eq("nodeType", args.nodeType)
+      ).order("desc").take(args.scanLimit) : ctx.db.query("epistemicNodes").withIndex("by_topic", (q) => q.eq("topicId", scope.topicId)).order("desc").take(args.scanLimit)
+    );
+  }
+  if (scope.projectId && !scope.topicId) {
+    queries.push(
+      args.nodeType ? ctx.db.query("epistemicNodes").withIndex(
+        "by_topic_type",
+        (q) => q.eq("topicId", scope.projectId).eq("nodeType", args.nodeType)
+      ).order("desc").take(args.scanLimit) : ctx.db.query("epistemicNodes").withIndex("by_topic", (q) => q.eq("topicId", scope.projectId)).order("desc").take(args.scanLimit)
+    );
+  }
+  const combined = dedupeWorkspaceNodes((await Promise.all(queries)).flat());
+  return combined.filter(
+    (node) => nodeMatchesWorkspaceReasoningScope(node, scope)
+  );
+}
+v.union(
+  v.literal("L4"),
+  v.literal("L3"),
+  v.literal("L2"),
+  v.literal("L1"),
+  v.literal("ontological"),
+  v.literal("organizational")
+);
+v.union(v.literal("decision"));
+v.union(
+  v.literal("belief"),
+  v.literal("question"),
+  v.literal("theme"),
+  v.literal("deal")
+);
+v.union(
+  v.literal("claim"),
+  v.literal("evidence"),
+  v.literal("synthesis")
+);
+v.union(
+  v.literal("atomic_fact"),
+  v.literal("excerpt"),
+  v.literal("source")
+);
+v.union(
+  // L4: Audit targets
+  v.literal("decision"),
+  // L3: Traversal anchors
+  v.literal("belief"),
+  v.literal("question"),
+  v.literal("theme"),
+  v.literal("deal"),
+  // L2: Compression boundary
+  v.literal("claim"),
+  v.literal("evidence"),
+  v.literal("synthesis"),
+  v.literal("answer"),
+  // L1: Terminal leaves
+  v.literal("atomic_fact"),
+  v.literal("excerpt"),
+  v.literal("source")
+);
+v.union(
+  v.literal("company"),
+  v.literal("person"),
+  v.literal("investor"),
+  v.literal("function"),
+  v.literal("value_chain")
+);
+v.union(v.literal("topic"));
+var nodeTypeValidator = v.union(
+  // L4: Audit targets
+  v.literal("decision"),
+  // L3: Traversal anchors
+  v.literal("belief"),
+  v.literal("question"),
+  v.literal("theme"),
+  v.literal("deal"),
+  // L2: Compression boundary
+  v.literal("claim"),
+  v.literal("evidence"),
+  v.literal("synthesis"),
+  v.literal("answer"),
+  // L1: Terminal leaves
+  v.literal("atomic_fact"),
+  v.literal("excerpt"),
+  v.literal("source"),
+  // Ontological
+  v.literal("company"),
+  v.literal("person"),
+  v.literal("investor"),
+  v.literal("function"),
+  v.literal("value_chain"),
+  // Organizational
+  v.literal("topic")
+);
+v.union(
+  v.literal("human"),
+  v.literal("ai_extracted"),
+  v.literal("ai_generated"),
+  v.literal("imported"),
+  v.literal("system")
+  // System-generated (migrations, classifiers)
+);
+var statusValidator = v.union(
+  v.literal("active"),
+  v.literal("superseded"),
+  v.literal("archived"),
+  v.literal("deleted")
+);
+v.union(
+  v.literal("unverified"),
+  v.literal("human_verified"),
+  v.literal("ai_verified"),
+  v.literal("contradicted"),
+  v.literal("outdated")
+);
 var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
 async function resolveTopicNodeScopeOrNull(ctx, ref) {
   if (!ctx?.db || typeof ctx.db.query !== "function") {
@@ -53,13 +204,15 @@ function asMappedProjectId(topic) {
   if (!topic) {
     return;
   }
-  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD]);
+  const directLegacyProjectId = normalizeScopeValue(
+    topic[LEGACY_SCOPE_FIELD]
+  );
   if (directLegacyProjectId) {
     return directLegacyProjectId;
   }
   const metadata = topic.metadata || {};
   const candidate = metadata[LEGACY_SCOPE_FIELD] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
-  return candidate ? candidate : void 0;
+  return typeof candidate === "string" ? normalizeScopeValue(candidate) : void 0;
 }
 function normalizeScopeValue(value) {
   if (typeof value !== "string") {
@@ -84,8 +237,9 @@ function pickPrimaryTopic(candidates) {
   })[0];
 }
 async function findTopicsByScopeAlias(ctx, scopeId) {
+  const query2 = ctx.db.query("topics");
   try {
-    return await ctx.db.query("topics").withIndex(
+    return await query2.withIndex(
       "by_graph_scope_project",
       (q) => q.eq(LEGACY_SCOPE_FIELD, scopeId)
     ).collect();
@@ -97,7 +251,7 @@ async function findTopicsByScopeAlias(ctx, scopeId) {
         scopeId
       }
     );
-    const topics = await ctx.db.query("topics").collect();
+    const topics = await query2.collect();
     return topics.filter((topic) => {
       const normalizedGlobalId = normalizeScopeValue(topic.globalId);
       const mappedProjectId = asMappedProjectId(topic);
@@ -153,311 +307,163 @@ async function resolveInheritedWorkspaceScope(ctx, topic) {
   let current = topic;
   for (let i = 0; i < MAX_DEPTH && current?.parentTopicId; i++) {
     current = await ctx.db.get(current.parentTopicId);
-    if (!current) break;
+    if (!current) {
+      break;
+    }
     if (!tenantId) {
       tenantId = normalizeScopeValue(current.tenantId);
     }
     if (!workspaceId) {
       workspaceId = normalizeScopeValue(current.workspaceId);
     }
-    if (tenantId && workspaceId) break;
+    if (tenantId && workspaceId) {
+      break;
+    }
   }
   return { tenantId, workspaceId };
 }
 async function resolveTopicProjectScope(ctx, args) {
   if (args.topicId) {
-    let topic = null;
-    try {
-      topic = await ctx.db.get(
-        args.topicId
-      );
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[topicScope] Failed to load topic by direct id",
-        {
-          error,
-          topicId: args.topicId
-        }
-      );
-    }
-    if (!topic) {
-      topic = await tryResolveHostTopicById(ctx, String(args.topicId));
-    }
-    if (!topic) {
-      topic = pickPrimaryTopic(
-        await findTopicsByScopeAlias(ctx, String(args.topicId))
-      ) ?? null;
-    }
-    if (!topic) {
-      const nodeScope = await resolveTopicNodeScopeOrNull(
-        ctx,
-        String(args.topicId)
-      );
-      if (nodeScope) {
-        return nodeScope;
-      }
-      throw new Error(`Topic not found: ${String(args.topicId)}`);
-    }
-    const inherited = await resolveInheritedWorkspaceScope(ctx, topic);
-    const mapped = asMappedProjectId(topic);
-    if (mapped) {
-      return {
-        topicId: topic._id,
-        projectId: mapped,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "topic"
-      };
-    }
-    return {
-      topicId: topic._id,
-      tenantId: inherited.tenantId,
-      workspaceId: inherited.workspaceId,
-      source: "topic"
-    };
+    return await resolveScopeFromTopicId(ctx, args.topicId);
   }
   if (args.projectId) {
-    let directTopic = null;
-    try {
-      directTopic = await ctx.db.get(
-        args.projectId
-      );
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[topicScope] Failed to load direct project topic",
-        {
-          error,
-          projectId: args.projectId
-        }
-      );
-    }
-    if (directTopic) {
-      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
-      const mapped = asMappedProjectId(directTopic);
-      return {
-        topicId: directTopic._id,
-        projectId: mapped ?? args.projectId,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "topic_inferred"
-      };
-    }
-    directTopic = await tryResolveHostTopicByLegacyScope(ctx, args.projectId);
-    if (directTopic) {
-      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
-      const mapped = asMappedProjectId(directTopic);
-      return {
-        topicId: directTopic._id,
-        projectId: mapped ?? args.projectId,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "topic_inferred"
-      };
-    }
-    const topics = await findTopicsByScopeAlias(ctx, args.projectId);
-    const primary = pickPrimaryTopic(topics);
-    if (primary) {
-      const inherited = await resolveInheritedWorkspaceScope(ctx, primary);
-      return {
-        topicId: primary._id,
-        projectId: args.projectId,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "project_mapped_topic"
-      };
-    }
-    const nodeScope = await resolveTopicNodeScopeOrNull(
-      ctx,
-      String(args.projectId)
-    );
-    if (nodeScope) {
-      return {
-        ...nodeScope,
-        projectId: nodeScope.projectId ?? String(args.projectId)
-      };
-    }
-    throw new Error(
-      `Legacy project scope ${String(args.projectId)} has no mapped topic.`
-    );
+    return await resolveScopeFromLegacyProjectId(ctx, args.projectId);
   }
   throw new Error(
     "Missing scope: provide topicId (preferred) or legacy projectId alias."
   );
 }
-var optionalScopeArgs = {
-  projectId: v.optional(v.string()),
-  topicId: v.optional(v.string())
-};
-
-// src/epistemicNodes.helpers.ts
-var DEFAULT_NODE_PAGE_SIZE = 250;
-var MAX_NODE_PAGE_SIZE = 8e3;
-function clampNodeLimit(limit, fallback = DEFAULT_NODE_PAGE_SIZE) {
-  if (!Number.isFinite(limit)) {
-    return fallback;
+async function resolveScopeFromTopicId(ctx, topicId) {
+  const topic = await resolveTopicDocFromTopicId(ctx, topicId);
+  if (topic) {
+    return await buildTopicScope(ctx, topic, "topic");
   }
-  return Math.max(1, Math.min(Math.floor(limit), MAX_NODE_PAGE_SIZE));
-}
-function dedupeWorkspaceNodes(nodes) {
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const node of nodes) {
-    const key = String(node._id);
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    deduped.push(node);
+  const nodeScope = await resolveTopicNodeScopeOrNull(ctx, String(topicId));
+  if (nodeScope) {
+    return nodeScope;
   }
-  return deduped;
+  throw new Error(`Topic not found: ${String(topicId)}`);
 }
-function nodeMatchesWorkspaceReasoningScope(node, scope) {
-  return scope.topicId !== void 0 && node.topicId === scope.topicId || scope.projectId !== void 0 && node.projectId === scope.projectId;
+async function resolveTopicDocFromTopicId(ctx, topicId) {
+  const direct = await tryReadTopicDoc(ctx, topicId, {
+    failureLog: "[topicScope] Failed to load topic by direct id",
+    idLogKey: "topicId"
+  });
+  if (direct) {
+    return direct;
+  }
+  const hostTopic = await tryResolveHostTopicById(ctx, String(topicId));
+  if (hostTopic) {
+    return hostTopic;
+  }
+  return pickPrimaryTopic(await findTopicsByScopeAlias(ctx, String(topicId))) ?? null;
 }
-async function collectScopedNodes(ctx, scope, args) {
-  const queries = [];
-  if (scope.topicId) {
-    queries.push(
-      args.nodeType ? ctx.db.query("epistemicNodes").withIndex(
-        "by_topic_type",
-        (q) => q.eq("topicId", scope.topicId).eq("nodeType", args.nodeType)
-      ).order("desc").take(args.scanLimit) : ctx.db.query("epistemicNodes").withIndex("by_topic", (q) => q.eq("topicId", scope.topicId)).order("desc").take(args.scanLimit)
-    );
+async function resolveScopeFromLegacyProjectId(ctx, legacyProjectId) {
+  const directTopic = await resolveDirectLegacyProjectTopic(
+    ctx,
+    legacyProjectId
+  );
+  if (directTopic) {
+    return await buildTopicScope(ctx, directTopic, "topic_inferred", {
+      fallbackProjectId: legacyProjectId
+    });
   }
-  if (scope.projectId && !scope.topicId) {
-    queries.push(
-      args.nodeType ? ctx.db.query("epistemicNodes").withIndex(
-        "by_topic_type",
-        (q) => q.eq("topicId", scope.projectId).eq("nodeType", args.nodeType)
-      ).order("desc").take(args.scanLimit) : ctx.db.query("epistemicNodes").withIndex("by_topic", (q) => q.eq("topicId", scope.projectId)).order("desc").take(args.scanLimit)
-    );
+  const primary = pickPrimaryTopic(
+    await findTopicsByScopeAlias(ctx, legacyProjectId)
+  );
+  if (primary) {
+    return await buildTopicScope(ctx, primary, "project_mapped_topic", {
+      fallbackProjectId: legacyProjectId
+    });
   }
-  const combined = dedupeWorkspaceNodes((await Promise.all(queries)).flat());
-  return combined.filter(
-    (node) => nodeMatchesWorkspaceReasoningScope(node, scope)
+  const nodeScope = await resolveTopicNodeScopeOrNull(ctx, legacyProjectId);
+  if (nodeScope) {
+    return {
+      ...nodeScope,
+      projectId: nodeScope.projectId ?? legacyProjectId
+    };
+  }
+  throw new Error(
+    `Legacy project scope ${legacyProjectId} has no mapped topic.`
   );
 }
-v.union(
-  v.literal("L4"),
-  v.literal("L3"),
-  v.literal("L2"),
-  v.literal("L1"),
-  v.literal("ontological"),
-  v.literal("organizational")
-);
-v.union(v.literal("decision"));
-v.union(
-  v.literal("belief"),
-  v.literal("question"),
-  v.literal("theme"),
-  v.literal("deal")
-);
-v.union(
-  v.literal("claim"),
-  v.literal("evidence"),
-  v.literal("synthesis")
-);
-v.union(
-  v.literal("atomic_fact"),
-  v.literal("excerpt"),
-  v.literal("source")
-);
-v.union(
-  // L4: Audit targets
-  v.literal("decision"),
-  // L3: Traversal anchors
-  v.literal("belief"),
-  v.literal("question"),
-  v.literal("theme"),
-  v.literal("deal"),
-  // L2: Compression boundary
-  v.literal("claim"),
-  v.literal("evidence"),
-  v.literal("synthesis"),
-  v.literal("answer"),
-  // L1: Terminal leaves
-  v.literal("atomic_fact"),
-  v.literal("excerpt"),
-  v.literal("source")
-);
-v.union(
-  v.literal("company"),
-  v.literal("person"),
-  v.literal("investor"),
-  v.literal("function"),
-  v.literal("value_chain")
-);
-v.union(v.literal("topic"));
-var nodeTypeValidator = v.union(
-  // L4: Audit targets
-  v.literal("decision"),
-  // L3: Traversal anchors
-  v.literal("belief"),
-  v.literal("question"),
-  v.literal("theme"),
-  v.literal("deal"),
-  // L2: Compression boundary
-  v.literal("claim"),
-  v.literal("evidence"),
-  v.literal("synthesis"),
-  v.literal("answer"),
-  // L1: Terminal leaves
-  v.literal("atomic_fact"),
-  v.literal("excerpt"),
-  v.literal("source"),
-  // Ontological
-  v.literal("company"),
-  v.literal("person"),
-  v.literal("investor"),
-  v.literal("function"),
-  v.literal("value_chain"),
-  // Organizational
-  v.literal("topic")
-);
-v.union(
-  v.literal("human"),
-  v.literal("ai_extracted"),
-  v.literal("ai_generated"),
-  v.literal("imported"),
-  v.literal("system")
-  // System-generated (migrations, classifiers)
-);
-var statusValidator = v.union(
-  v.literal("active"),
-  v.literal("superseded"),
-  v.literal("archived"),
-  v.literal("deleted")
-);
-v.union(
-  v.literal("unverified"),
-  v.literal("human_verified"),
-  v.literal("ai_verified"),
-  v.literal("contradicted"),
-  v.literal("outdated")
-);
+async function resolveDirectLegacyProjectTopic(ctx, legacyProjectId) {
+  const directTopic = await tryReadTopicDoc(ctx, legacyProjectId, {
+    failureLog: "[topicScope] Failed to load direct project topic",
+    idLogKey: "projectId"
+  });
+  return directTopic ?? tryResolveHostTopicByLegacyScope(ctx, legacyProjectId);
+}
+async function tryReadTopicDoc(ctx, id, log) {
+  try {
+    return await ctx.db.get(id);
+  } catch (error) {
+    debugGraphPrimitiveFallback(log.failureLog, {
+      error,
+      [log.idLogKey]: id
+    });
+    return null;
+  }
+}
+async function buildTopicScope(ctx, topic, source, options = {}) {
+  const inherited = await resolveInheritedWorkspaceScope(ctx, topic);
+  const mapped = asMappedProjectId(topic);
+  return {
+    topicId: topic._id,
+    ...mapped || options.fallbackProjectId ? { projectId: mapped ?? options.fallbackProjectId } : {},
+    tenantId: inherited.tenantId,
+    workspaceId: inherited.workspaceId,
+    source
+  };
+}
+var optionalScopeArgs = {
+  projectId: v.optional(v.string()),
+  topicId: v.optional(v.string())
+};
 
 // src/epistemicNodes.queries.ts
 var optionalNodeScopeArgs = optionalScopeArgs;
+function asEpistemicNodesQueryCtx(ctx) {
+  return ctx;
+}
+function isInScope(node, scope) {
+  return nodeMatchesWorkspaceReasoningScope(node, scope);
+}
+function isStatus(status) {
+  return (node) => node.status === status;
+}
+function isStatusInScope(status, scope) {
+  return (node) => isStatus(status)(node) && isInScope(node, scope);
+}
+function isNotDeletedInScope(scope) {
+  return (node) => node.status !== "deleted" && isInScope(node, scope);
+}
+function toLiteNode(node) {
+  return {
+    _id: node._id,
+    globalId: node.globalId,
+    nodeType: node.nodeType,
+    createdBy: node.createdBy,
+    topicId: node.topicId,
+    projectId: node.projectId,
+    status: node.status,
+    epistemicLayer: node.epistemicLayer
+  };
+}
 var get = query({
   args: { nodeId: v.id("epistemicNodes") },
   returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    return await ctx.db.get(args.nodeId);
-  }
+  handler: async (ctx, args) => await asEpistemicNodesQueryCtx(ctx).db.get(args.nodeId)
 });
 var getByGlobalId = query({
   args: { globalId: v.string() },
   returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    return await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first();
-  }
+  handler: async (ctx, args) => await asEpistemicNodesQueryCtx(ctx).db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first()
 });
 var getByContentHash = query({
   args: { contentHash: v.string() },
   returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    return await ctx.db.query("epistemicNodes").withIndex("by_contentHash", (q) => q.eq("contentHash", args.contentHash)).collect();
-  }
+  handler: async (ctx, args) => await asEpistemicNodesQueryCtx(ctx).db.query("epistemicNodes").withIndex("by_contentHash", (q) => q.eq("contentHash", args.contentHash)).collect()
 });
 var getByProjectAndType = query({
   args: {
@@ -468,12 +474,13 @@ var getByProjectAndType = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    if (!args.projectId && !args.topicId) {
+    if (!(args.projectId || args.topicId)) {
       return [];
     }
+    const queryCtx = asEpistemicNodesQueryCtx(ctx);
     let scope;
     try {
-      scope = await resolveTopicProjectScope(ctx, {
+      scope = await resolveTopicProjectScope(queryCtx, {
         projectId: args.projectId,
         topicId: args.topicId
       });
@@ -490,18 +497,14 @@ var getByProjectAndType = query({
     }
     const pageSize = clampNodeLimit(args.limit);
     const scanLimit = Math.min(pageSize * 3, MAX_NODE_PAGE_SIZE);
-    const nodes = await collectScopedNodes(ctx, scope, {
+    const nodes = await collectScopedNodes(queryCtx, scope, {
       nodeType: args.nodeType,
       scanLimit
     });
     if (args.status) {
-      return nodes.filter(
-        (n) => n.status === args.status && nodeMatchesWorkspaceReasoningScope(n, scope)
-      ).slice(0, pageSize);
+      return nodes.filter(isStatusInScope(args.status, scope)).slice(0, pageSize);
     }
-    return nodes.filter(
-      (n) => n.status === "active" && nodeMatchesWorkspaceReasoningScope(n, scope)
-    ).slice(0, pageSize);
+    return nodes.filter(isStatusInScope("active", scope)).slice(0, pageSize);
   }
 });
 var getByProjectAndTypeLite = query({
@@ -513,12 +516,13 @@ var getByProjectAndTypeLite = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    if (!args.projectId && !args.topicId) {
+    if (!(args.projectId || args.topicId)) {
       return [];
     }
+    const queryCtx = asEpistemicNodesQueryCtx(ctx);
     let scope;
     try {
-      scope = await resolveTopicProjectScope(ctx, {
+      scope = await resolveTopicProjectScope(queryCtx, {
         projectId: args.projectId,
         topicId: args.topicId
       });
@@ -535,23 +539,14 @@ var getByProjectAndTypeLite = query({
     }
     const pageSize = clampNodeLimit(args.limit);
     const scanLimit = Math.min(pageSize * 3, MAX_NODE_PAGE_SIZE);
-    const query2 = ctx.db.query("epistemicNodes").withIndex(
+    const nodeQuery = queryCtx.db.query("epistemicNodes").withIndex(
       "by_topic_type",
       (q) => q.eq("topicId", scope.topicId).eq("nodeType", args.nodeType)
     );
-    const nodes = await query2.order("desc").take(scanLimit);
-    const statusFiltered = args.status ? nodes.filter((n) => n.status === args.status) : nodes.filter((n) => n.status === "active");
+    const nodes = await nodeQuery.order("desc").take(scanLimit);
+    const statusFiltered = args.status ? nodes.filter(isStatus(args.status)) : nodes.filter(isStatus("active"));
     const capped = statusFiltered.slice(0, pageSize);
-    return capped.map((n) => ({
-      _id: n._id,
-      globalId: n.globalId,
-      nodeType: n.nodeType,
-      createdBy: n.createdBy,
-      topicId: n.topicId,
-      projectId: n.projectId,
-      status: n.status,
-      epistemicLayer: n.epistemicLayer
-    }));
+    return capped.map(toLiteNode);
   }
 });
 var getByProject = query({
@@ -563,23 +558,27 @@ var getByProject = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    if (!args.projectId && !args.topicId) {
+    if (!(args.projectId || args.topicId)) {
       return [];
     }
+    const queryCtx = asEpistemicNodesQueryCtx(ctx);
     const pageSize = clampNodeLimit(args.limit);
     const scanLimit = Math.min(pageSize * 3, MAX_NODE_PAGE_SIZE);
     let scope;
     try {
-      scope = await resolveTopicProjectScope(ctx, {
+      scope = await resolveTopicProjectScope(queryCtx, {
         projectId: args.projectId,
         topicId: args.topicId
       });
     } catch (error) {
-      debugGraphPrimitiveFallback("[epistemicNodes] Failed to resolve list scope", {
-        error,
-        projectId: args.projectId,
-        topicId: args.topicId
-      });
+      debugGraphPrimitiveFallback(
+        "[epistemicNodes] Failed to resolve list scope",
+        {
+          error,
+          projectId: args.projectId,
+          topicId: args.topicId
+        }
+      );
       return [];
     }
     if (args.userId) {
@@ -592,15 +591,11 @@ var getByProject = query({
         return [];
       }
     }
-    const nodes = await collectScopedNodes(ctx, scope, { scanLimit });
+    const nodes = await collectScopedNodes(queryCtx, scope, { scanLimit });
     if (args.includeArchived) {
-      return nodes.filter(
-        (n) => n.status !== "deleted" && nodeMatchesWorkspaceReasoningScope(n, scope)
-      ).slice(0, pageSize);
+      return nodes.filter(isNotDeletedInScope(scope)).slice(0, pageSize);
     }
-    return nodes.filter(
-      (n) => n.status === "active" && nodeMatchesWorkspaceReasoningScope(n, scope)
-    ).slice(0, pageSize);
+    return nodes.filter(isStatusInScope("active", scope)).slice(0, pageSize);
   }
 });
 var listAll = query({
@@ -609,10 +604,11 @@ var listAll = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
+    const queryCtx = asEpistemicNodesQueryCtx(ctx);
     const pageSize = clampNodeLimit(args.limit ?? 2e3);
     const scanLimit = Math.min(pageSize * 2, MAX_NODE_PAGE_SIZE * 2);
-    const nodes = await ctx.db.query("epistemicNodes").order("desc").take(scanLimit);
-    return nodes.filter((n) => n.status === "active").slice(0, pageSize);
+    const nodes = await queryCtx.db.query("epistemicNodes").order("desc").take(scanLimit);
+    return nodes.filter(isStatus("active")).slice(0, pageSize);
   }
 });
 var search = query({
@@ -624,11 +620,12 @@ var search = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
+    const queryCtx = asEpistemicNodesQueryCtx(ctx);
     const pageSize = clampNodeLimit(args.limit, 100);
     let scope;
     if (args.projectId || args.topicId) {
       try {
-        scope = await resolveTopicProjectScope(ctx, {
+        scope = await resolveTopicProjectScope(queryCtx, {
           projectId: args.projectId,
           topicId: args.topicId
         });
@@ -644,7 +641,7 @@ var search = query({
         return [];
       }
     }
-    const searchResults = ctx.db.query("epistemicNodes").withSearchIndex("search_canonicalText", (q) => {
+    const searchResults = queryCtx.db.query("epistemicNodes").withSearchIndex("search_canonicalText", (q) => {
       let search2 = q.search("canonicalText", args.searchQuery);
       if (scope?.topicId) {
         search2 = search2.eq("topicId", scope.topicId);