@lucern/graph-primitives 1.0.28 → 1.0.30

package/dist/epistemicBeliefs.admin.js

@@ -1,16 +1,21 @@
-import { v, ConvexError } from 'convex/values';
+import { requireScopeWriteAccess } from '@lucern/access-control/access';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { componentsGeneric, anyApi, mutationGeneric, queryGeneric } from 'convex/server';
-import { normalizeTupleContradictionPolicy } from '@lucern/confidence';
-import { checkProjectAccess } from '@lucern/access-control/access';
+import { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, mutationGeneric, queryGeneric } from 'convex/server';
 import '@lucern/access-control/audience';
 import { getCurrentUserId } from '@lucern/access-control/auth';
+import { throwStructuredMutationError } from '@lucern/access-control/structuredMutationError';
+import { normalizeTupleContradictionPolicy } from '@lucern/confidence';
 import '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
 
 // src/epistemicBeliefs.admin.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 internal = anyApi;
+var internal = unsafeApi;
 var mutation = mutationGeneric;
 var query = queryGeneric;
 
@@ -59,13 +64,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") {
@@ -90,8 +97,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();
@@ -103,7 +111,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);
@@ -159,137 +167,115 @@ 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())
@@ -324,8 +310,6 @@ function nodeMatchesWorkspaceReasoningScope(node, scope) {
   }
   return scopeWorkspaceId === nodeWorkspaceId;
 }
-
-// src/epistemicBeliefs.helpers.ts
 v.id("epistemicNodes");
 var DEFAULT_PROJECT_BELIEF_LIMIT = 250;
 var MAX_PROJECT_BELIEF_LIMIT = 1e3;
@@ -333,25 +317,119 @@ var optionalBeliefScopeArgs = optionalScopeArgs;
 ({
   tupleContradiction: normalizeTupleContradictionPolicy()
 });
-function throwStructuredMutationError(args) {
-  const data = {
-    structuredMutationError: true,
-    message: args.message,
-    status: args.status,
-    code: args.code,
-    invariantCode: args.invariantCode,
-    suggestion: args.suggestion,
-    details: args.details
-  };
-  const error = new ConvexError(
-    data
+function readFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return;
+  }
+  const strings = value.filter(
+    (item) => typeof item === "string" && item.length > 0
   );
-  error.status = args.status;
-  error.code = args.code;
-  error.invariantCode = args.invariantCode;
-  error.suggestion = args.suggestion;
-  error.details = args.details;
-  throw error;
+  return strings.length === value.length ? strings : void 0;
+}
+function readRecord(value) {
+  return isRecord(value) ? value : void 0;
+}
+function readBeliefNodeView(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const id = readOptionalString(value._id);
+  const nodeType = readOptionalString(value.nodeType);
+  if (!(id && nodeType === "belief")) {
+    return null;
+  }
+  const node = {
+    _id: id,
+    nodeType
+  };
+  const creationTime = readFiniteNumber(value._creationTime);
+  if (creationTime !== void 0) {
+    node._creationTime = creationTime;
+  }
+  const metadata = readRecord(value.metadata);
+  if (metadata !== void 0) {
+    node.metadata = metadata;
+  }
+  const opinionA = readFiniteNumber(value.opinion_a);
+  if (opinionA !== void 0) {
+    node.opinion_a = opinionA;
+  }
+  const opinionB = readFiniteNumber(value.opinion_b);
+  if (opinionB !== void 0) {
+    node.opinion_b = opinionB;
+  }
+  const opinionD = readFiniteNumber(value.opinion_d);
+  if (opinionD !== void 0) {
+    node.opinion_d = opinionD;
+  }
+  const opinionU = readFiniteNumber(value.opinion_u);
+  if (opinionU !== void 0) {
+    node.opinion_u = opinionU;
+  }
+  const tupleContradicted = typeof value.tupleContradicted === "boolean" ? value.tupleContradicted : void 0;
+  if (tupleContradicted !== void 0) {
+    node.tupleContradicted = tupleContradicted;
+  }
+  const stringFields = {
+    anonymizationClass: value.anonymizationClass,
+    audienceLabel: value.audienceLabel,
+    canonicalText: value.canonicalText,
+    createdBy: value.createdBy,
+    epistemicLayer: value.epistemicLayer,
+    exportClass: value.exportClass,
+    globalId: value.globalId,
+    projectId: value.projectId,
+    publicationStatus: value.publicationStatus,
+    sensitivityTier: value.sensitivityTier,
+    status: value.status,
+    tenantId: value.tenantId,
+    topicId: value.topicId,
+    userId: value.userId,
+    workspaceId: value.workspaceId
+  };
+  for (const [field, fieldValue] of Object.entries(stringFields)) {
+    const normalized = readOptionalString(fieldValue);
+    if (normalized !== void 0) {
+      node[field] = normalized;
+    }
+  }
+  const createdAt = readFiniteNumber(value.createdAt);
+  if (createdAt !== void 0) {
+    node.createdAt = createdAt;
+  }
+  const updatedAt = readFiniteNumber(value.updatedAt);
+  if (updatedAt !== void 0) {
+    node.updatedAt = updatedAt;
+  }
+  if (value.beliefStatus !== void 0) {
+    node.beliefStatus = value.beliefStatus;
+  }
+  if (value.confidence !== void 0) {
+    node.confidence = value.confidence;
+  }
+  if (value.predictionMeta !== void 0) {
+    node.predictionMeta = value.predictionMeta;
+  }
+  const policyTags = readStringArray(value.policyTags);
+  if (policyTags !== void 0) {
+    node.policyTags = policyTags;
+  }
+  return node;
+}
+function readBeliefNodeViews(values) {
+  return values.flatMap((value) => {
+    const node = readBeliefNodeView(value);
+    return node ? [node] : [];
+  });
 }
 function buildBeliefStatusSuccessResult() {
   return { success: true };
@@ -366,7 +444,7 @@ function clampBeliefLimit(limit, fallback = DEFAULT_PROJECT_BELIEF_LIMIT) {
   );
 }
 async function resolveBeliefScopeOrNull(ctx, args) {
-  if (!args.projectId && !args.topicId) {
+  if (!(args.projectId || args.topicId)) {
     return null;
   }
   try {
@@ -391,14 +469,17 @@ async function getBeliefNodesForScope(ctx, scope, args) {
     "by_topic_type",
     (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
   );
-  const nodes = typeof args?.scanLimit === "number" ? await baseQuery.order("desc").take(args.scanLimit) : await baseQuery.collect();
+  const rows = typeof args?.scanLimit === "number" ? await baseQuery.order("desc").take(args.scanLimit) : await baseQuery.collect();
+  const nodes = readBeliefNodeViews(rows);
   const scopedNodes = nodes.filter(
     (node) => nodeMatchesWorkspaceReasoningScope(node, scope)
   );
   if (!args?.status) {
     return scopedNodes;
   }
-  return scopedNodes.filter((node) => node.status === args.status);
+  return scopedNodes.filter(
+    (node) => node.status === args.status
+  );
 }
 async function requireAuthenticatedUserId(ctx) {
   const userId = await getCurrentUserId(
@@ -415,25 +496,105 @@ async function requireAuthenticatedUserId(ctx) {
   }
   return userId;
 }
-async function requireProjectWriteAccess(ctx, projectId, userId) {
-  const hasAccess = await checkProjectAccess(
-    ctx,
-    projectId,
-    userId
-  );
-  if (!hasAccess) {
-    throwStructuredMutationError({
-      message: `Project write access denied for topic ${projectId}.`,
-      status: 403,
-      code: "PROJECT_ACCESS_DENIED",
-      invariantCode: "policy.scope_required",
-      suggestion: "The acting principal lacks project-write access to this topic. Request a topic grant (or, if the principal created this topic, run the creator-grant backfill) and retry.",
-      details: { topicId: projectId, principalId: userId }
-    });
-  }
-}
 
 // src/epistemicBeliefs.admin.ts
+function worktreeId(value) {
+  return value;
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readConvexId(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 readOptionalString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readRecord2(value) {
+  return isRecord2(value) ? value : void 0;
+}
+function readBeliefAdminNode(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const id = readConvexId(value._id);
+  if (!id) {
+    return null;
+  }
+  const node = { _id: id };
+  const metadata = readRecord2(value.metadata);
+  const nodeType = readOptionalString2(value.nodeType);
+  const projectId = readOptionalString2(value.projectId);
+  const status = readOptionalString2(value.status);
+  if (metadata !== void 0) {
+    node.metadata = metadata;
+  }
+  if (nodeType !== void 0) {
+    node.nodeType = nodeType;
+  }
+  if (projectId !== void 0) {
+    node.projectId = projectId;
+  }
+  if (status !== void 0) {
+    node.status = status;
+  }
+  return node;
+}
+function readBeliefAdminEdge(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const id = readConvexId(value._id);
+  if (!id) {
+    return null;
+  }
+  const edge = { _id: id };
+  const context = readOptionalString2(value.context);
+  const edgeType = readOptionalString2(value.edgeType);
+  const fromNodeId = readConvexId(value.fromNodeId);
+  const globalId = readOptionalString2(value.globalId);
+  const projectId = readOptionalString2(value.projectId);
+  const toNodeId = readConvexId(value.toNodeId);
+  const weight = readOptionalNumber(value.weight);
+  if (context !== void 0) {
+    edge.context = context;
+  }
+  if (edgeType !== void 0) {
+    edge.edgeType = edgeType;
+  }
+  if (fromNodeId !== void 0) {
+    edge.fromNodeId = fromNodeId;
+  }
+  if (globalId !== void 0) {
+    edge.globalId = globalId;
+  }
+  if (projectId !== void 0) {
+    edge.projectId = projectId;
+  }
+  if (toNodeId !== void 0) {
+    edge.toNodeId = toNodeId;
+  }
+  if (weight !== void 0) {
+    edge.weight = weight;
+  }
+  return edge;
+}
+function readWorktreeBeliefClusterLink(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const beliefId = readConvexId(value.beliefId);
+  return beliefId ? { beliefId } : null;
+}
+function readRowList(values, reader) {
+  return values.flatMap((value) => {
+    const row = reader(value);
+    return row ? [row] : [];
+  });
+}
 var deleteRelationship = mutation({
   args: {
     edgeId: v.id("epistemicEdges"),
@@ -443,26 +604,26 @@ var deleteRelationship = mutation({
   handler: async (ctx, args) => {
     const authenticatedUserId = await requireAuthenticatedUserId(ctx);
     const now = Date.now();
-    const edge = await ctx.db.get(args.edgeId);
+    const edge = readBeliefAdminEdge(await ctx.db.get(args.edgeId));
     if (!edge) {
       throw new Error("Edge not found");
     }
     if (!edge.projectId) {
       throw new Error("Edge has no project scope");
     }
-    await requireProjectWriteAccess(ctx, edge.projectId, authenticatedUserId);
+    await requireScopeWriteAccess(ctx, edge.projectId, authenticatedUserId);
     const previousState = {
       fromNodeId: edge.fromNodeId,
       toNodeId: edge.toNodeId,
       edgeType: edge.edgeType
     };
     await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
-      globalId: edge.globalId
+      globalId: edge.globalId ?? String(args.edgeId)
     });
     await ctx.db.delete(args.edgeId);
     await ctx.db.insert("epistemicAudit", {
       entityType: "edge",
-      entityId: edge.globalId,
+      entityId: edge.globalId ?? String(args.edgeId),
       changeType: "edge_removed",
       previousState,
       newState: null,
@@ -490,15 +651,15 @@ var updateCriticality = mutation({
   handler: async (ctx, args) => {
     const authenticatedUserId = await requireAuthenticatedUserId(ctx);
     const now = Date.now();
-    const node = await ctx.db.get(args.nodeId);
-    if (!node || node.nodeType !== "belief") {
+    const node = readBeliefAdminNode(await ctx.db.get(args.nodeId));
+    if (node?.nodeType !== "belief") {
       throw new Error("Belief not found");
     }
     if (!node.projectId) {
       throw new Error("Belief has no project scope");
     }
-    await requireProjectWriteAccess(ctx, node.projectId, authenticatedUserId);
-    const metadata = node.metadata || {};
+    await requireScopeWriteAccess(ctx, node.projectId, authenticatedUserId);
+    const metadata = node.metadata ?? {};
     const previousCriticality = metadata.criticality;
     await ctx.db.patch(args.nodeId, {
       metadata: {
@@ -557,8 +718,8 @@ var batchUpdateCriticality = mutation({
     const results = [];
     for (const update of args.updates) {
       try {
-        const node = await ctx.db.get(update.beliefId);
-        if (!node || node.nodeType !== "belief") {
+        const node = readBeliefAdminNode(await ctx.db.get(update.beliefId));
+        if (node?.nodeType !== "belief") {
           results.push({ beliefId: update.beliefId, success: false });
           continue;
         }
@@ -566,12 +727,8 @@ var batchUpdateCriticality = mutation({
           results.push({ beliefId: update.beliefId, success: false });
           continue;
         }
-        await requireProjectWriteAccess(
-          ctx,
-          node.projectId,
-          authenticatedUserId
-        );
-        const metadata = node.metadata || {};
+        await requireScopeWriteAccess(ctx, node.projectId, authenticatedUserId);
+        const metadata = node.metadata ?? {};
         const previousCriticality = metadata.criticality;
         await ctx.db.patch(node._id, {
           metadata: {
@@ -600,11 +757,11 @@ var batchUpdateCriticality = mutation({
           changedAt: now,
           projectId: node.projectId
         });
-        const result = {};
-        result.beliefId = update.beliefId;
-        result.nodeId = node._id;
-        result.success = true;
-        results.push(result);
+        results.push({
+          beliefId: update.beliefId,
+          nodeId: node._id,
+          success: true
+        });
       } catch (error) {
         debugGraphPrimitiveFallback(
           "[epistemicBeliefs] Failed to update belief criticality",
@@ -613,10 +770,7 @@ var batchUpdateCriticality = mutation({
             beliefId: update.beliefId
           }
         );
-        const result = {};
-        result.beliefId = update.beliefId;
-        result.success = false;
-        results.push(result);
+        results.push({ beliefId: update.beliefId, success: false });
       }
     }
     return { results, updatedCount: results.filter((r) => r.success).length };
@@ -641,7 +795,7 @@ var getByCriticality = query({
     }
     const nodes = await getBeliefNodesForScope(ctx, scope);
     return nodes.filter((n) => {
-      const metadata = n.metadata;
+      const metadata = readRecord2(n.metadata);
       return metadata?.criticality === args.criticality && n.status === "active";
     });
   }
@@ -660,7 +814,7 @@ var getUnanalyzed = query({
     }
     const nodes = await getBeliefNodesForScope(ctx, scope);
     const unanalyzed = nodes.filter((n) => {
-      const metadata = n.metadata;
+      const metadata = readRecord2(n.metadata);
       return !metadata?.criticality && n.status === "active";
     });
     return unanalyzed.slice(0, limit);
@@ -722,7 +876,7 @@ var getByPillar = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    if (!args.projectId && !args.topicId) {
+    if (!(args.projectId || args.topicId)) {
       return [];
     }
     let scope;
@@ -742,10 +896,13 @@ var getByPillar = query({
       );
       return [];
     }
-    const nodes = await ctx.db.query("epistemicNodes").withIndex(
-      "by_topic_type",
-      (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
-    ).collect();
+    const nodes = readRowList(
+      await ctx.db.query("epistemicNodes").withIndex(
+        "by_topic_type",
+        (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
+      ).collect(),
+      readBeliefAdminNode
+    );
     return nodes.filter((n) => {
       const metadata = n.metadata;
       const matchesPillar = metadata?.pillar === args.pillar;
@@ -761,24 +918,30 @@ var getWorktreeCluster = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const worktree = await ctx.db.get(args.worktreeId);
+    const worktree = await ctx.db.get(worktreeId(args.worktreeId));
     if (!worktree) {
       return { beliefs: [], edges: [], beliefCount: 0 };
     }
-    const clusterLinks = await ctx.db.query("worktreeBeliefCluster").withIndex("by_worktree", (q) => q.eq("worktreeId", args.worktreeId)).collect();
+    const clusterLinks = readRowList(
+      await ctx.db.query("worktreeBeliefCluster").withIndex("by_worktree", (q) => q.eq("worktreeId", args.worktreeId)).collect(),
+      readWorktreeBeliefClusterLink
+    );
     const beliefIds = new Set(clusterLinks.map((l) => String(l.beliefId)));
     const beliefs = [];
     for (const link of clusterLinks) {
-      const node = await ctx.db.get(link.beliefId);
-      if (node) beliefs.push(node);
+      const node = readBeliefAdminNode(await ctx.db.get(link.beliefId));
+      if (node) {
+        beliefs.push(node);
+      }
     }
     const clusterEdges = [];
     for (const beliefId of beliefIds) {
-      const outEdges = await ctx.db.query("epistemicEdges").filter(
-        (q) => q.eq(q.field("fromNodeId"), beliefId)
-      ).collect();
+      const outEdges = readRowList(
+        await ctx.db.query("epistemicEdges").filter((q) => q.eq(q.field("fromNodeId"), beliefId)).collect(),
+        readBeliefAdminEdge
+      );
       for (const edge of outEdges) {
-        if (beliefIds.has(String(edge.toNodeId))) {
+        if (edge.fromNodeId && edge.toNodeId && edge.edgeType && beliefIds.has(String(edge.toNodeId))) {
           clusterEdges.push({
             fromNodeId: String(edge.fromNodeId),
             toNodeId: String(edge.toNodeId),