@lucern/graph-primitives 1.0.29 → 1.0.30

package/dist/epistemicNodes.js

@@ -1,12 +1,105 @@
-import { v } from 'convex/values';
 import { checkScopeAccess, requireScopeWriteAccess } from '@lucern/access-control/access';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { componentsGeneric, anyApi, queryGeneric, mutationGeneric, internalMutationGeneric, internalQueryGeneric } from 'convex/server';
-import { isNodeType, getLayerForNodeType } from '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
-import { assertUuidV7Identity } from '@lucern/contracts/ids';
+import { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, queryGeneric, internalMutationGeneric, internalQueryGeneric, mutationGeneric } from 'convex/server';
 import '@lucern/contracts';
+import { assertUuidV7Identity } from '@lucern/contracts/ids';
+import { isNodeType, getLayerForNodeType } from '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
+
+// src/epistemicNodes.queries.ts
+var unsafeApi = unsafeConvexAnyApi(
+  "graph-primitives top-level module bundle lacks a committed Convex _generated/api surface"
+);
+var api = unsafeApi;
+componentsGeneric();
+var internal = unsafeApi;
+var internalMutation = internalMutationGeneric;
+var internalQuery = internalQueryGeneric;
+var mutation = mutationGeneric;
+var query = queryGeneric;
+
+// src/debug.ts
+function isGraphPrimitiveDebugEnabled() {
+  const env = globalThis.process?.env;
+  return env?.LUCERN_COMPAT_FALLBACK_DEBUG === "1" || env?.LUCERN_GRAPH_DEBUG === "1";
+}
+function debugGraphPrimitiveFallback(message, context) {
+  if (!isGraphPrimitiveDebugEnabled()) {
+    return;
+  }
+  console.debug(message, context ?? {});
+}
 
-// src/epistemicNodes.validators.ts
+// 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 buildNodeStatusSuccessResult() {
+  return { success: true };
+}
+function buildNodeArchivedResult() {
+  return {
+    success: true,
+    effectiveStatus: "archived"
+  };
+}
+function buildNodeNotFoundResult() {
+  const result = {};
+  result.success = false;
+  result.error = "Node not found";
+  return result;
+}
+function buildNodeDeletedResult(deletedEdgeCount) {
+  return {
+    success: true,
+    deletedEdgeCount
+  };
+}
+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)
+  );
+}
 var epistemicLayerValidator = v.union(
   v.literal("L4"),
   v.literal("L3"),
@@ -105,25 +198,6 @@ var verificationStatusValidator = v.union(
   v.literal("contradicted"),
   v.literal("outdated")
 );
-var api = anyApi;
-componentsGeneric();
-var internal = anyApi;
-var internalMutation = internalMutationGeneric;
-var internalQuery = internalQueryGeneric;
-var mutation = mutationGeneric;
-var query = queryGeneric;
-
-// src/debug.ts
-function isGraphPrimitiveDebugEnabled() {
-  const env = globalThis.process?.env;
-  return env?.LUCERN_COMPAT_FALLBACK_DEBUG === "1" || env?.LUCERN_GRAPH_DEBUG === "1";
-}
-function debugGraphPrimitiveFallback(message, context) {
-  if (!isGraphPrimitiveDebugEnabled()) {
-    return;
-  }
-  console.debug(message, context ?? {});
-}
 var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
 async function resolveTopicNodeScopeOrNull(ctx, ref) {
   if (!ctx?.db || typeof ctx.db.query !== "function") {
@@ -158,13 +232,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") {
@@ -189,8 +265,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();
@@ -202,7 +279,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);
@@ -258,234 +335,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."
   );
 }
+async function resolveScopeFromTopicId(ctx, topicId) {
+  const topic = await resolveTopicDocFromTopicId(ctx, topicId);
+  if (topic) {
+    return await buildTopicScope(ctx, topic, "topic");
+  }
+  const nodeScope = await resolveTopicNodeScopeOrNull(ctx, String(topicId));
+  if (nodeScope) {
+    return nodeScope;
+  }
+  throw new Error(`Topic not found: ${String(topicId)}`);
+}
+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 resolveScopeFromLegacyProjectId(ctx, legacyProjectId) {
+  const directTopic = await resolveDirectLegacyProjectTopic(
+    ctx,
+    legacyProjectId
+  );
+  if (directTopic) {
+    return await buildTopicScope(ctx, directTopic, "topic_inferred", {
+      fallbackProjectId: legacyProjectId
+    });
+  }
+  const primary = pickPrimaryTopic(
+    await findTopicsByScopeAlias(ctx, legacyProjectId)
+  );
+  if (primary) {
+    return await buildTopicScope(ctx, primary, "project_mapped_topic", {
+      fallbackProjectId: legacyProjectId
+    });
+  }
+  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.`
+  );
+}
+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.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));
+// src/epistemicNodes.queries.ts
+var optionalNodeScopeArgs = optionalScopeArgs;
+function asEpistemicNodesQueryCtx(ctx) {
+  return ctx;
 }
-function buildNodeStatusSuccessResult() {
-  return { success: true };
+function isInScope(node, scope) {
+  return nodeMatchesWorkspaceReasoningScope(node, scope);
 }
-function buildNodeArchivedResult() {
-  return {
-    success: true,
-    effectiveStatus: "archived"
-  };
+function isStatus(status) {
+  return (node) => node.status === status;
 }
-function buildNodeNotFoundResult() {
-  const result = {};
-  result.success = false;
-  result.error = "Node not found";
-  return result;
+function isStatusInScope(status, scope) {
+  return (node) => isStatus(status)(node) && isInScope(node, scope);
 }
-function buildNodeDeletedResult(deletedEdgeCount) {
+function isNotDeletedInScope(scope) {
+  return (node) => node.status !== "deleted" && isInScope(node, scope);
+}
+function toLiteNode(node) {
   return {
-    success: true,
-    deletedEdgeCount
+    _id: node._id,
+    globalId: node.globalId,
+    nodeType: node.nodeType,
+    createdBy: node.createdBy,
+    topicId: node.topicId,
+    projectId: node.projectId,
+    status: node.status,
+    epistemicLayer: node.epistemicLayer
   };
 }
-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)
-  );
-}
-
-// src/epistemicNodes.queries.ts
-var optionalNodeScopeArgs = optionalScopeArgs;
 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: {
@@ -496,12 +502,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
       });
@@ -518,18 +525,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({
@@ -541,12 +544,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
       });
@@ -563,23 +567,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({
@@ -591,23 +586,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) {
@@ -620,15 +619,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({
@@ -637,10 +632,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({
@@ -652,11 +648,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
         });
@@ -672,7 +669,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);
@@ -687,6 +684,10 @@ var search = query({
     return await searchResults.take(pageSize);
   }
 });
+function insertEpistemicNode(ctx, doc) {
+  assertUuidV7Identity("epistemicNodes", doc.globalId);
+  return ctx.db.insert("epistemicNodes", doc);
+}
 
 // src/graphTypes.ts
 function getNodeLayer(nodeType) {
@@ -951,6 +952,310 @@ function assertOntologicalNodeSupersedeAllowed(args) {
     }
   });
 }
+
+// src/epistemicNodes.internal.ts
+var optionalNodeScopeArgs2 = optionalScopeArgs;
+var EPISTEMIC_LAYERS = /* @__PURE__ */ new Set([
+  "L4",
+  "L3",
+  "L2",
+  "L1",
+  "ontological",
+  "organizational"
+]);
+function readOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readConvexId(value) {
+  const normalized = readOptionalString(value);
+  return normalized ? normalized : null;
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readEpistemicLayer(value) {
+  const layer = readOptionalString(value);
+  return layer && EPISTEMIC_LAYERS.has(layer) ? layer : void 0;
+}
+function resolveEpistemicLayer(args) {
+  return readEpistemicLayer(args.providedLayer) ?? getNodeLayer(args.nodeType);
+}
+function readInternalNodeRow(value) {
+  const record = readRecord(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId(record._id);
+  const nodeType = readOptionalString(record.nodeType);
+  if (!(id && nodeType)) {
+    return null;
+  }
+  const node = { _id: id, nodeType };
+  const canonicalText = readOptionalString(record.canonicalText);
+  if (canonicalText !== void 0) {
+    node.canonicalText = canonicalText;
+  }
+  const globalId = readOptionalString(record.globalId);
+  if (globalId !== void 0) {
+    node.globalId = globalId;
+  }
+  const projectId = readOptionalString(record.projectId);
+  if (projectId !== void 0) {
+    node.projectId = projectId;
+  }
+  const status = readOptionalString(record.status);
+  if (status !== void 0) {
+    node.status = status;
+  }
+  const title = readOptionalString(record.title);
+  if (title !== void 0) {
+    node.title = title;
+  }
+  return node;
+}
+function readInternalEdgeRow(value) {
+  const record = readRecord(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId(record._id);
+  if (!id) {
+    return null;
+  }
+  const edge = { _id: id };
+  const globalId = readOptionalString(record.globalId);
+  if (globalId !== void 0) {
+    edge.globalId = globalId;
+  }
+  return edge;
+}
+var createInternal = internalMutation({
+  args: {
+    ...optionalNodeScopeArgs2,
+    globalId: v.string(),
+    nodeType: nodeTypeValidator,
+    subtype: v.optional(v.string()),
+    canonicalText: v.string(),
+    contentHash: v.optional(v.string()),
+    // Optional - will be generated if not provided
+    content: v.optional(v.string()),
+    contentType: v.optional(v.string()),
+    title: v.optional(v.string()),
+    tags: v.optional(v.array(v.string())),
+    domain: v.optional(v.string()),
+    metadata: v.optional(v.any()),
+    externalIds: v.optional(
+      v.object({
+        crunchbase: v.optional(v.string()),
+        linkedin: v.optional(v.string()),
+        pitchbook: v.optional(v.string()),
+        twitter: v.optional(v.string()),
+        website: v.optional(v.string())
+      })
+    ),
+    sourceType: v.optional(sourceTypeValidator),
+    aiProvider: v.optional(v.string()),
+    extractedFromNodeId: v.optional(v.id("epistemicNodes")),
+    confidence: v.optional(v.number()),
+    verificationStatus: v.optional(verificationStatusValidator),
+    createdBy: v.string(),
+    // Neo4j sync status tracking
+    syncStatus: v.optional(
+      v.union(
+        v.literal("synced"),
+        v.literal("pending_edges"),
+        v.literal("edge_creation_failed")
+      )
+    ),
+    epistemicLayer: v.optional(v.string()),
+    status: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const resolvedScope = args.topicId || args.projectId ? await (async () => {
+      try {
+        return await resolveTopicProjectScope(ctx, {
+          topicId: args.topicId,
+          projectId: args.projectId
+        });
+      } catch (error) {
+        debugGraphPrimitiveFallback(
+          "[epistemicNodes] Failed to resolve create scope",
+          {
+            error,
+            topicId: args.topicId,
+            projectId: args.projectId
+          }
+        );
+        return;
+      }
+    })() : void 0;
+    const contentHash = args.contentHash || `${args.nodeType}:${args.canonicalText}`.slice(0, 64);
+    const epistemicLayer = resolveEpistemicLayer({
+      nodeType: args.nodeType,
+      providedLayer: args.epistemicLayer
+    });
+    const nodeId = await insertEpistemicNode(ctx, {
+      globalId: args.globalId,
+      nodeType: args.nodeType,
+      epistemicLayer,
+      subtype: args.subtype,
+      canonicalText: args.canonicalText,
+      contentHash,
+      content: args.content,
+      contentType: args.contentType,
+      title: args.title,
+      tags: args.tags,
+      domain: args.domain,
+      metadata: args.metadata,
+      externalIds: args.externalIds,
+      sourceType: args.sourceType ?? "human",
+      aiProvider: args.aiProvider,
+      extractedFromNodeId: args.extractedFromNodeId,
+      confidence: args.confidence,
+      verificationStatus: args.verificationStatus ?? "unverified",
+      status: args.status ?? "active",
+      topicId: resolvedScope?.topicId ?? args.topicId,
+      projectId: resolvedScope?.projectId ?? args.projectId,
+      createdBy: args.createdBy,
+      createdAt: now,
+      updatedAt: now,
+      // Neo4j sync status
+      syncStatus: args.syncStatus
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId,
+      operation: "upsert"
+    });
+    return nodeId;
+  }
+});
+var getInternal = internalQuery({
+  args: {
+    nodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => await ctx.db.get(args.nodeId)
+});
+var updateSyncStatus = internalMutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    syncStatus: v.union(
+      v.literal("synced"),
+      v.literal("pending_edges"),
+      v.literal("edge_creation_failed")
+    ),
+    syncError: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const updates = {
+      syncStatus: args.syncStatus,
+      updatedAt: Date.now()
+    };
+    if (args.syncError !== void 0) {
+      updates.syncError = args.syncError;
+    }
+    await ctx.db.patch(args.nodeId, updates);
+    return buildNodeStatusSuccessResult();
+  }
+});
+var backfillTopicId = internalMutation({
+  args: {
+    nodeIds: v.array(v.id("epistemicNodes")),
+    newTopicId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    let patched = 0;
+    for (const nodeId of args.nodeIds) {
+      const node = await ctx.db.get(nodeId);
+      if (!node) {
+        continue;
+      }
+      await ctx.db.patch(nodeId, {
+        topicId: args.newTopicId,
+        updatedAt: Date.now()
+      });
+      patched++;
+    }
+    return { patched, total: args.nodeIds.length };
+  }
+});
+var getNodesPendingEdgeSync = internalQuery({
+  args: {
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 100;
+    return await ctx.db.query("epistemicNodes").withIndex(
+      "by_syncStatus",
+      (q) => q.eq("syncStatus", "edge_creation_failed")
+    ).take(limit);
+  }
+});
+var hardDelete = internalMutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    reason: v.string(),
+    // Required: document why this is being hard-deleted
+    allowBeliefHardDelete: v.optional(v.boolean())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const node = readInternalNodeRow(await ctx.db.get(args.nodeId));
+    if (!node) {
+      return buildNodeNotFoundResult();
+    }
+    assertBeliefNodeHardDeleteAllowed({
+      node,
+      allowBeliefHardDelete: args.allowBeliefHardDelete ?? false,
+      reason: args.reason,
+      mutationName: "epistemicNodes.hardDelete"
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "node",
+      entityId: String(args.nodeId),
+      changeType: "deleted",
+      projectId: node.projectId,
+      changedBy: "system:hard_delete",
+      changedAt: Date.now(),
+      isAgent: false,
+      previousState: {
+        nodeType: node.nodeType,
+        title: node.title ?? node.canonicalText?.slice(0, 100),
+        status: node.status
+      },
+      rationale: args.reason
+    });
+    const endpointRefs = [String(args.nodeId), node.globalId].filter(
+      (ref) => typeof ref === "string" && ref.length > 0
+    );
+    const uniqueEdges = /* @__PURE__ */ new Map();
+    for (const endpointRef of endpointRefs) {
+      const fromEdges = await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", endpointRef)).collect();
+      const toEdges = await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", endpointRef)).collect();
+      for (const rawEdge of [...fromEdges, ...toEdges]) {
+        const edge = readInternalEdgeRow(rawEdge);
+        if (edge) {
+          uniqueEdges.set(edge.globalId ?? String(edge._id), edge);
+        }
+      }
+    }
+    for (const edge of uniqueEdges.values()) {
+      if (edge.globalId) {
+        await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
+          globalId: edge.globalId
+        });
+      }
+      await ctx.db.delete(edge._id);
+    }
+    await ctx.db.delete(args.nodeId);
+    return buildNodeDeletedResult(uniqueEdges.size);
+  }
+});
 function normalizeScopeValue2(value) {
   if (typeof value !== "string") {
     return;
@@ -989,7 +1294,7 @@ function assertWorkspaceScopedEpistemicNodeScope(args) {
   });
 }
 function resolveRuntimePackMutationContext(args) {
-  if (!args.runtimeToolName && !args.runtimePackKey && !args.runtimePackInstallScope) {
+  if (!(args.runtimeToolName || args.runtimePackKey || args.runtimePackInstallScope)) {
     return;
   }
   return {
@@ -1021,13 +1326,117 @@ function assertTenantPackWorkspaceMutationAllowed(args) {
     }
   });
 }
-async function insertEpistemicNode(ctx, doc) {
-  assertUuidV7Identity("epistemicNodes", doc.globalId);
-  return ctx.db.insert("epistemicNodes", doc);
-}
 
 // src/epistemicNodes.mutations.ts
-var optionalNodeScopeArgs2 = optionalScopeArgs;
+var optionalNodeScopeArgs3 = optionalScopeArgs;
+var EPISTEMIC_LAYERS2 = /* @__PURE__ */ new Set([
+  "L4",
+  "L3",
+  "L2",
+  "L1",
+  "ontological",
+  "organizational"
+]);
+function readOptionalString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readConvexId2(value) {
+  const normalized = readOptionalString2(value);
+  return normalized ? normalized : null;
+}
+function readRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+}
+function readEpistemicLayer2(value) {
+  const layer = readOptionalString2(value);
+  return layer && EPISTEMIC_LAYERS2.has(layer) ? layer : void 0;
+}
+function readEpistemicNodeRow(value) {
+  const record = readRecord2(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId2(record._id);
+  const nodeType = readOptionalString2(record.nodeType);
+  if (!(id && nodeType)) {
+    return null;
+  }
+  const node = { _id: id, nodeType };
+  const canonicalText = readOptionalString2(record.canonicalText);
+  if (canonicalText !== void 0) {
+    node.canonicalText = canonicalText;
+  }
+  const confidence = readOptionalNumber(record.confidence);
+  if (confidence !== void 0) {
+    node.confidence = confidence;
+  }
+  const content = readOptionalString2(record.content);
+  if (content !== void 0) {
+    node.content = content;
+  }
+  const contentType = readOptionalString2(record.contentType);
+  if (contentType !== void 0) {
+    node.contentType = contentType;
+  }
+  const createdBy = readOptionalString2(record.createdBy);
+  if (createdBy !== void 0) {
+    node.createdBy = createdBy;
+  }
+  const epistemicLayer = readEpistemicLayer2(record.epistemicLayer);
+  if (epistemicLayer !== void 0) {
+    node.epistemicLayer = epistemicLayer;
+  }
+  const metadata = readRecord2(record.metadata);
+  if (metadata) {
+    node.metadata = metadata;
+  }
+  const projectId = readOptionalString2(record.projectId);
+  if (projectId !== void 0) {
+    node.projectId = projectId;
+  }
+  const status = readOptionalString2(record.status);
+  if (status !== void 0) {
+    node.status = status;
+  }
+  const tags = readStringArray(record.tags);
+  if (tags !== void 0) {
+    node.tags = tags;
+  }
+  const tenantId = readOptionalString2(record.tenantId);
+  if (tenantId !== void 0) {
+    node.tenantId = tenantId;
+  }
+  const title = readOptionalString2(record.title);
+  if (title !== void 0) {
+    node.title = title;
+  }
+  const topicId = readOptionalString2(record.topicId);
+  if (topicId !== void 0) {
+    node.topicId = topicId;
+  }
+  const verificationStatus = readOptionalString2(record.verificationStatus);
+  if (verificationStatus !== void 0) {
+    node.verificationStatus = verificationStatus;
+  }
+  const workspaceId = readOptionalString2(record.workspaceId);
+  if (workspaceId !== void 0) {
+    node.workspaceId = workspaceId;
+  }
+  return node;
+}
+function requireEpistemicNodeRow(value, context) {
+  const node = readEpistemicNodeRow(value);
+  if (!node) {
+    throw new Error(`${context} requires a stored epistemic node.`);
+  }
+  return node;
+}
 var create = mutation({
   args: {
     globalId: v.string(),
@@ -1057,7 +1466,7 @@ var create = mutation({
     extractedFromNodeId: v.optional(v.id("epistemicNodes")),
     confidence: v.optional(v.number()),
     verificationStatus: v.optional(verificationStatusValidator),
-    ...optionalNodeScopeArgs2,
+    ...optionalNodeScopeArgs3,
     createdBy: v.string(),
     runtimeToolName: v.optional(v.string()),
     runtimePackKey: v.optional(v.string()),
@@ -1073,8 +1482,9 @@ var create = mutation({
       mutationName: "epistemicNodes.create"
     });
     const existing = await ctx.db.query("epistemicNodes").withIndex("by_contentHash", (q) => q.eq("contentHash", args.contentHash)).first();
-    if (existing && existing.status === "active") {
-      return { nodeId: existing._id, isDuplicate: true };
+    const existingNode = readEpistemicNodeRow(existing);
+    if (existingNode?.status === "active") {
+      return { nodeId: existingNode._id, isDuplicate: true };
     }
     const epistemicLayer = getNodeLayer(args.nodeType);
     const resolvedScope = args.topicId || args.projectId ? await resolveTopicProjectScope(ctx, {
@@ -1189,10 +1599,10 @@ var update = mutation({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const { nodeId, userId, ...updates } = args;
-    const node = await ctx.db.get(nodeId);
-    if (!node) {
-      throw new Error("Node not found");
-    }
+    const node = requireEpistemicNodeRow(
+      await ctx.db.get(nodeId),
+      "Update node"
+    );
     if (node.projectId && userId) {
       await requireScopeWriteAccess(ctx, node.projectId, userId);
     }
@@ -1221,7 +1631,7 @@ var update = mutation({
         entityId: String(nodeId),
         changeType: "updated",
         changedAt: Date.now(),
-        changedBy: userId || node.createdBy,
+        changedBy: userId ?? node.createdBy ?? "system:update",
         isAgent: false,
         previousState: {
           status: node.status,
@@ -1250,10 +1660,10 @@ var supersede = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const oldNode = await ctx.db.get(args.oldNodeId);
-    if (!oldNode) {
-      throw new Error("Node not found");
-    }
+    const oldNode = requireEpistemicNodeRow(
+      await ctx.db.get(args.oldNodeId),
+      "Supersede node"
+    );
     if (oldNode.projectId) {
       await requireScopeWriteAccess(ctx, oldNode.projectId, args.createdBy);
     }
@@ -1285,7 +1695,10 @@ var supersede = mutation({
       verificationStatus: "unverified",
       // New version needs re-verification
       status: "active",
+      topicId: oldNode.topicId,
       projectId: oldNode.projectId,
+      tenantId: oldNode.tenantId,
+      workspaceId: oldNode.workspaceId,
       createdBy: args.createdBy,
       createdAt: now,
       updatedAt: now
@@ -1326,10 +1739,10 @@ var archive = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const node = await ctx.db.get(args.nodeId);
-    if (!node) {
-      throw new Error("Node not found");
-    }
+    const node = requireEpistemicNodeRow(
+      await ctx.db.get(args.nodeId),
+      "Archive node"
+    );
     if (node.projectId && args.userId) {
       await requireScopeWriteAccess(ctx, node.projectId, args.userId);
     }
@@ -1351,7 +1764,7 @@ var archive = mutation({
         entityId: String(args.nodeId),
         changeType: "archived",
         changedAt: Date.now(),
-        changedBy: args.userId || node.createdBy,
+        changedBy: args.userId ?? node.createdBy ?? "system:archive",
         isAgent: false,
         previousState: { status: node.status },
         newState: { status: "archived" },
@@ -1370,10 +1783,10 @@ var verify = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const node = await ctx.db.get(args.nodeId);
-    if (!node) {
-      throw new Error("Node not found");
-    }
+    const node = requireEpistemicNodeRow(
+      await ctx.db.get(args.nodeId),
+      "Verify node"
+    );
     assertBeliefNodeVerifyAllowed({
       node,
       confidence: args.confidence,
@@ -1412,7 +1825,7 @@ var batchCreate = mutation({
   args: {
     nodes: v.array(
       v.object({
-        ...optionalNodeScopeArgs2,
+        ...optionalNodeScopeArgs3,
         globalId: v.string(),
         nodeType: nodeTypeValidator,
         subtype: v.optional(v.string()),
@@ -1445,7 +1858,7 @@ var batchCreate = mutation({
   handler: async (ctx, args) => {
     const resolveNodeScope = async (node) => {
       if (!(node.topicId || node.projectId)) {
-        return void 0;
+        return;
       }
       try {
         return await resolveTopicProjectScope(ctx, {
@@ -1461,7 +1874,7 @@ var batchCreate = mutation({
             projectId: node.projectId
           }
         );
-        return void 0;
+        return;
       }
     };
     const now = Date.now();
@@ -1510,223 +1923,6 @@ var batchCreate = mutation({
     return { created: results.length, results };
   }
 });
-var optionalNodeScopeArgs3 = optionalScopeArgs;
-var createInternal = internalMutation({
-  args: {
-    ...optionalNodeScopeArgs3,
-    globalId: v.string(),
-    nodeType: nodeTypeValidator,
-    subtype: v.optional(v.string()),
-    canonicalText: v.string(),
-    contentHash: v.optional(v.string()),
-    // Optional - will be generated if not provided
-    content: v.optional(v.string()),
-    contentType: v.optional(v.string()),
-    title: v.optional(v.string()),
-    tags: v.optional(v.array(v.string())),
-    domain: v.optional(v.string()),
-    metadata: v.optional(v.any()),
-    externalIds: v.optional(
-      v.object({
-        crunchbase: v.optional(v.string()),
-        linkedin: v.optional(v.string()),
-        pitchbook: v.optional(v.string()),
-        twitter: v.optional(v.string()),
-        website: v.optional(v.string())
-      })
-    ),
-    sourceType: v.optional(sourceTypeValidator),
-    aiProvider: v.optional(v.string()),
-    extractedFromNodeId: v.optional(v.id("epistemicNodes")),
-    confidence: v.optional(v.number()),
-    verificationStatus: v.optional(verificationStatusValidator),
-    createdBy: v.string(),
-    // Neo4j sync status tracking
-    syncStatus: v.optional(
-      v.union(
-        v.literal("synced"),
-        v.literal("pending_edges"),
-        v.literal("edge_creation_failed")
-      )
-    ),
-    epistemicLayer: v.optional(v.string()),
-    status: v.optional(v.string())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const now = Date.now();
-    const resolvedScope = args.topicId || args.projectId ? await (async () => {
-      try {
-        return await resolveTopicProjectScope(ctx, {
-          topicId: args.topicId,
-          projectId: args.projectId
-        });
-      } catch (error) {
-        debugGraphPrimitiveFallback(
-          "[epistemicNodes] Failed to resolve create scope",
-          {
-            error,
-            topicId: args.topicId,
-            projectId: args.projectId
-          }
-        );
-        return void 0;
-      }
-    })() : void 0;
-    const contentHash = args.contentHash || `${args.nodeType}:${args.canonicalText}`.slice(0, 64);
-    const epistemicLayer = args.epistemicLayer || getNodeLayer(args.nodeType);
-    const nodeId = await insertEpistemicNode(ctx, {
-      globalId: args.globalId,
-      nodeType: args.nodeType,
-      epistemicLayer,
-      subtype: args.subtype,
-      canonicalText: args.canonicalText,
-      contentHash,
-      content: args.content,
-      contentType: args.contentType,
-      title: args.title,
-      tags: args.tags,
-      domain: args.domain,
-      metadata: args.metadata,
-      externalIds: args.externalIds,
-      sourceType: args.sourceType ?? "human",
-      aiProvider: args.aiProvider,
-      extractedFromNodeId: args.extractedFromNodeId,
-      confidence: args.confidence,
-      verificationStatus: args.verificationStatus ?? "unverified",
-      status: args.status ?? "active",
-      topicId: resolvedScope?.topicId ?? args.topicId,
-      projectId: resolvedScope?.projectId ?? args.projectId,
-      createdBy: args.createdBy,
-      createdAt: now,
-      updatedAt: now,
-      // Neo4j sync status
-      syncStatus: args.syncStatus
-    });
-    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
-      nodeId,
-      operation: "upsert"
-    });
-    return nodeId;
-  }
-});
-var getInternal = internalQuery({
-  args: {
-    nodeId: v.id("epistemicNodes")
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    return await ctx.db.get(args.nodeId);
-  }
-});
-var updateSyncStatus = internalMutation({
-  args: {
-    nodeId: v.id("epistemicNodes"),
-    syncStatus: v.union(
-      v.literal("synced"),
-      v.literal("pending_edges"),
-      v.literal("edge_creation_failed")
-    ),
-    syncError: v.optional(v.string())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const updates = {
-      syncStatus: args.syncStatus,
-      updatedAt: Date.now()
-    };
-    if (args.syncError !== void 0) {
-      updates.syncError = args.syncError;
-    }
-    await ctx.db.patch(args.nodeId, updates);
-    return buildNodeStatusSuccessResult();
-  }
-});
-var backfillTopicId = internalMutation({
-  args: {
-    nodeIds: v.array(v.id("epistemicNodes")),
-    newTopicId: v.string()
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    let patched = 0;
-    for (const nodeId of args.nodeIds) {
-      const node = await ctx.db.get(nodeId);
-      if (!node) {
-        continue;
-      }
-      await ctx.db.patch(nodeId, {
-        topicId: args.newTopicId,
-        updatedAt: Date.now()
-      });
-      patched++;
-    }
-    return { patched, total: args.nodeIds.length };
-  }
-});
-var getNodesPendingEdgeSync = internalQuery({
-  args: {
-    limit: v.optional(v.number())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const limit = args.limit ?? 100;
-    return await ctx.db.query("epistemicNodes").withIndex(
-      "by_syncStatus",
-      (q) => q.eq("syncStatus", "edge_creation_failed")
-    ).take(limit);
-  }
-});
-var hardDelete = internalMutation({
-  args: {
-    nodeId: v.id("epistemicNodes"),
-    reason: v.string(),
-    // Required: document why this is being hard-deleted
-    allowBeliefHardDelete: v.optional(v.boolean())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const node = await ctx.db.get(args.nodeId);
-    if (!node) {
-      return buildNodeNotFoundResult();
-    }
-    assertBeliefNodeHardDeleteAllowed({
-      node,
-      allowBeliefHardDelete: args.allowBeliefHardDelete ?? false,
-      reason: args.reason,
-      mutationName: "epistemicNodes.hardDelete"
-    });
-    await ctx.db.insert("epistemicAudit", {
-      entityType: "node",
-      entityId: args.nodeId,
-      changeType: "deleted",
-      projectId: node.projectId,
-      changedBy: "system:hard_delete",
-      changedAt: Date.now(),
-      isAgent: false,
-      previousState: {
-        nodeType: node.nodeType,
-        title: node.title || node.canonicalText?.slice(0, 100),
-        status: node.status
-      },
-      rationale: args.reason
-    });
-    const fromEdges = await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", args.nodeId)).collect();
-    const toEdges = await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", args.nodeId)).collect();
-    const uniqueEdges = /* @__PURE__ */ new Map();
-    for (const edge of [...fromEdges, ...toEdges]) {
-      uniqueEdges.set(edge.globalId, edge);
-    }
-    for (const edge of uniqueEdges.values()) {
-      await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
-        globalId: edge.globalId
-      });
-      await ctx.db.delete(edge._id);
-    }
-    await ctx.db.delete(args.nodeId);
-    return buildNodeDeletedResult(uniqueEdges.size);
-  }
-});
 
 // src/epistemicNodes.ts
 var getByTopic = getByProject;