@lucern/graph-primitives 1.0.28 → 1.0.30

package/dist/epistemicBeliefs.backfills.js

@@ -1,16 +1,21 @@
-import { v, ConvexError } from 'convex/values';
-import { normalizeTupleContradictionPolicy, confidenceFromSL, readOpinionFromRecord, mkOpinion } from '@lucern/confidence';
 import { checkScopeAccess } from '@lucern/access-control/access';
+import { normalizeTupleContradictionPolicy, readOpinionFromRecord, mkOpinion, confidenceFromSL } from '@lucern/confidence';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { componentsGeneric, anyApi, queryGeneric, internalMutationGeneric, mutationGeneric } from 'convex/server';
+import { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, queryGeneric, internalMutationGeneric, mutationGeneric } from 'convex/server';
 import '@lucern/access-control/audience';
 import '@lucern/access-control/auth';
+import { throwStructuredMutationError } from '@lucern/access-control/structuredMutationError';
 import '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
 
 // src/epistemicBeliefs.backfills.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 internalMutation = internalMutationGeneric;
 var mutation = mutationGeneric;
 var query = queryGeneric;
@@ -171,13 +176,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") {
@@ -202,8 +209,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();
@@ -215,7 +223,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);
@@ -223,20 +231,20 @@ async function findTopicsByScopeAlias(ctx, scopeId) {
     });
   }
 }
-async function tryResolveHostTopicById(ctx, topicId) {
+async function tryResolveHostTopicById(ctx, topicId2) {
   if (typeof ctx.runQuery !== "function") {
     return null;
   }
   try {
     return await ctx.runQuery(api.topics.get, {
-      id: topicId
+      id: topicId2
     }) ?? null;
   } catch (error) {
     debugGraphPrimitiveFallback(
       "[topicScope] Failed to resolve topic by host query",
       {
         error,
-        topicId
+        topicId: topicId2
       }
     );
     return null;
@@ -271,137 +279,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, topicId2) {
+  const topic = await resolveTopicDocFromTopicId(ctx, topicId2);
+  if (topic) {
+    return await buildTopicScope(ctx, topic, "topic");
+  }
+  const nodeScope = await resolveTopicNodeScopeOrNull(ctx, String(topicId2));
+  if (nodeScope) {
+    return nodeScope;
+  }
+  throw new Error(`Topic not found: ${String(topicId2)}`);
+}
+async function resolveTopicDocFromTopicId(ctx, topicId2) {
+  const direct = await tryReadTopicDoc(ctx, topicId2, {
+    failureLog: "[topicScope] Failed to load topic by direct id",
+    idLogKey: "topicId"
+  });
+  if (direct) {
+    return direct;
+  }
+  const hostTopic = await tryResolveHostTopicById(ctx, String(topicId2));
+  if (hostTopic) {
+    return hostTopic;
+  }
+  return pickPrimaryTopic(await findTopicsByScopeAlias(ctx, String(topicId2))) ?? 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())
@@ -436,36 +422,125 @@ function nodeMatchesWorkspaceReasoningScope(node, scope) {
   }
   return scopeWorkspaceId === nodeWorkspaceId;
 }
-
-// src/epistemicBeliefs.helpers.ts
 v.id("epistemicNodes");
 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
-  );
-  error.status = args.status;
-  error.code = args.code;
-  error.invariantCode = args.invariantCode;
-  error.suggestion = args.suggestion;
-  error.details = args.details;
-  throw error;
-}
 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
+  );
+  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 clamp01(value) {
   return Math.max(0, Math.min(1, value));
 }
@@ -532,7 +607,7 @@ function deriveSyntheticBackfillOpinion(source) {
   return mkOpinion(confidence, 1 - confidence, 0, 0.5);
 }
 async function resolveBeliefScopeOrNull(ctx, args) {
-  if (!args.projectId && !args.topicId) {
+  if (!(args.projectId || args.topicId)) {
     return null;
   }
   try {
@@ -557,7 +632,8 @@ async function getBeliefNodesForScope(ctx, scope, args) {
     "by_topic_type",
     (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
   );
-  const nodes = await baseQuery.collect();
+  const rows = await baseQuery.collect();
+  const nodes = readBeliefNodeViews(rows);
   const scopedNodes = nodes.filter(
     (node) => nodeMatchesWorkspaceReasoningScope(node, scope)
   );
@@ -575,6 +651,340 @@ function resolveBeliefStatus(node, metadata) {
 }
 
 // src/epistemicBeliefs.backfills.ts
+function epistemicNodeId(value) {
+  return value;
+}
+function topicId(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 readFiniteNumber(value);
+}
+function readOptionalString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readRecord2(value) {
+  if (value === null) {
+    return null;
+  }
+  return isRecord2(value) ? value : void 0;
+}
+function readEpistemicNodeBackfillRow(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const id = readConvexId(value._id);
+  if (!id) {
+    return null;
+  }
+  const row = { ...value, _id: id };
+  const canonicalText = readOptionalString2(value.canonicalText);
+  const createdAt = readOptionalNumber(value.createdAt);
+  const confidence = readOptionalNumber(value.confidence);
+  const globalId = readOptionalString2(value.globalId);
+  const metadata = readRecord2(value.metadata);
+  const nodeType = readOptionalString2(value.nodeType);
+  const projectId = readOptionalString2(value.projectId);
+  const status = readOptionalString2(value.status);
+  const title = readOptionalString2(value.title);
+  const topicIdValue = readOptionalString2(value.topicId);
+  const updatedAt = readOptionalNumber(value.updatedAt);
+  if (canonicalText !== void 0) {
+    row.canonicalText = canonicalText;
+  }
+  if (createdAt !== void 0) {
+    row.createdAt = createdAt;
+  }
+  if (confidence !== void 0) {
+    row.confidence = confidence;
+  }
+  if (globalId !== void 0) {
+    row.globalId = globalId;
+  }
+  if (metadata !== void 0) {
+    row.metadata = metadata;
+  }
+  if (nodeType !== void 0) {
+    row.nodeType = nodeType;
+  }
+  if (projectId !== void 0) {
+    row.projectId = projectId;
+  }
+  if (status !== void 0) {
+    row.status = status;
+  }
+  if (title !== void 0) {
+    row.title = title;
+  }
+  if (topicIdValue !== void 0) {
+    row.topicId = topicIdValue;
+  }
+  if (updatedAt !== void 0) {
+    row.updatedAt = updatedAt;
+  }
+  return row;
+}
+function readBeliefConfidenceBackfillRow(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const id = readConvexId(value._id);
+  const assessedAt = readOptionalNumber(value.assessedAt);
+  const assessedBy = readOptionalString2(value.assessedBy);
+  const beliefId = readOptionalString2(value.beliefId);
+  const confidence = readOptionalNumber(value.confidence);
+  const trigger = readOptionalString2(value.trigger);
+  if (!(id && assessedAt !== void 0 && assessedBy && beliefId && trigger)) {
+    return null;
+  }
+  const row = {
+    ...value,
+    _id: id,
+    assessedAt,
+    assessedBy,
+    beliefId,
+    confidence: confidence ?? 0.5,
+    trigger
+  };
+  const baseRate = readOptionalNumber(value.baseRate);
+  const belief = readOptionalNumber(value.belief);
+  const certainty = readOptionalNumber(value.certainty);
+  const disbelief = readOptionalNumber(value.disbelief);
+  const uncertainty = readOptionalNumber(value.uncertainty);
+  const valence = readOptionalNumber(value.valence);
+  if (baseRate !== void 0) {
+    row.baseRate = baseRate;
+  }
+  if (belief !== void 0) {
+    row.belief = belief;
+  }
+  if (certainty !== void 0) {
+    row.certainty = certainty;
+  }
+  if (disbelief !== void 0) {
+    row.disbelief = disbelief;
+  }
+  if (uncertainty !== void 0) {
+    row.uncertainty = uncertainty;
+  }
+  if (valence !== void 0) {
+    row.valence = valence;
+  }
+  return row;
+}
+function readEpistemicEdgeBackfillRow(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const id = readConvexId(value._id);
+  if (!id) {
+    return null;
+  }
+  const row = { ...value, _id: id };
+  const fromNodeId = readOptionalString2(value.fromNodeId);
+  const globalId = readOptionalString2(value.globalId);
+  const toNodeId = readOptionalString2(value.toNodeId);
+  if (fromNodeId !== void 0) {
+    row.fromNodeId = fromNodeId;
+  }
+  if (globalId !== void 0) {
+    row.globalId = globalId;
+  }
+  if (toNodeId !== void 0) {
+    row.toNodeId = toNodeId;
+  }
+  return row;
+}
+function readRowList(values, reader) {
+  return values.flatMap((value) => {
+    const row = reader(value);
+    return row ? [row] : [];
+  });
+}
+function hasLegacyOpinionSnapshot(node) {
+  return readFiniteNumber(node.opinion_b) !== void 0 || readFiniteNumber(node.opinion_d) !== void 0 || readFiniteNumber(node.opinion_u) !== void 0 || readFiniteNumber(node.opinion_a) !== void 0 || readFiniteNumber(node.confidence) !== void 0;
+}
+function buildSubjectiveOpinionPatch(node, defaultBaseRate) {
+  return {
+    belief: readFiniteNumber(node.opinion_b) ?? 0,
+    disbelief: readFiniteNumber(node.opinion_d) ?? 0,
+    uncertainty: readFiniteNumber(node.opinion_u) ?? 1,
+    baseRate: readFiniteNumber(node.opinion_a) ?? defaultBaseRate
+  };
+}
+function needsSubjectiveOpinionPatch(node) {
+  return readFiniteNumber(node.opinion_b) === void 0 || readFiniteNumber(node.opinion_d) === void 0 || readFiniteNumber(node.opinion_u) === void 0 || readFiniteNumber(node.opinion_a) === void 0;
+}
+function buildSubjectiveOpinionNodePatch(opinion) {
+  return {
+    opinion_b: opinion.belief,
+    opinion_d: opinion.disbelief,
+    opinion_u: opinion.uncertainty,
+    opinion_a: opinion.baseRate,
+    updatedAt: Date.now()
+  };
+}
+function buildBaseRateHistoryPatch(row, defaultBaseRate) {
+  const belief = readFiniteNumber(row.belief) ?? 0;
+  const disbelief = readFiniteNumber(row.disbelief) ?? 0;
+  const uncertainty = readFiniteNumber(row.uncertainty) ?? 1;
+  return {
+    baseRate: defaultBaseRate,
+    confidence: confidenceFromSL(
+      belief,
+      disbelief,
+      uncertainty,
+      defaultBaseRate
+    )
+  };
+}
+function buildMandatoryPriorAuditRow(args) {
+  return {
+    entityType: "belief",
+    entityId: args.beliefId,
+    changeType: "updated",
+    changedAt: Date.now(),
+    changedBy: "system:lkc-2-prior-backfill",
+    isAgent: false,
+    previousState: null,
+    newState: {
+      baseRateBackfilled: true,
+      baseRate: args.defaultBaseRate,
+      patchedNodeOpinion: args.needsNodePatch,
+      patchedHistoryRows: args.rowsMissingBaseRate,
+      insertedInitialOpinion: args.insertedInitialRow
+    },
+    projectId: args.node.projectId,
+    topicId: args.node.topicId
+  };
+}
+async function backfillMandatoryPriorNode(ctx, args) {
+  const beliefId = String(args.node._id);
+  const patchedOpinion = buildSubjectiveOpinionPatch(
+    args.node,
+    args.defaultBaseRate
+  );
+  const needsNodePatch = needsSubjectiveOpinionPatch(args.node);
+  const rowsMissingBaseRate = args.history.filter(
+    (row) => readFiniteNumber(row.baseRate) === void 0
+  );
+  const needsInitialRow = args.history.length === 0;
+  if (!needsNodePatch && rowsMissingBaseRate.length === 0 && !needsInitialRow) {
+    return {
+      auditEntries: 0,
+      insertedInitialRows: 0,
+      patchedHistoryRows: 0,
+      patchedNodes: 0,
+      touched: false
+    };
+  }
+  if (needsNodePatch) {
+    await ctx.db.patch(
+      args.node._id,
+      buildSubjectiveOpinionNodePatch(patchedOpinion)
+    );
+  }
+  for (const row of rowsMissingBaseRate) {
+    await ctx.db.patch(
+      row._id,
+      buildBaseRateHistoryPatch(row, args.defaultBaseRate)
+    );
+  }
+  if (needsInitialRow) {
+    await ctx.db.insert(
+      "beliefConfidence",
+      buildBeliefConfidenceRow({
+        beliefId: args.node._id,
+        belief: patchedOpinion.belief,
+        disbelief: patchedOpinion.disbelief,
+        uncertainty: patchedOpinion.uncertainty,
+        baseRate: patchedOpinion.baseRate,
+        trigger: "initial",
+        rationale: "LKC-2 backfill: inserted missing initial vacuous opinion with neutral prior.",
+        assessedAt: readFiniteNumber(args.node.createdAt) ?? readFiniteNumber(args.node.updatedAt) ?? Date.now(),
+        assessedBy: "system:lkc-2-prior-backfill",
+        slOperator: "prior_seed"
+      })
+    );
+  }
+  await ctx.db.insert(
+    "epistemicAudit",
+    buildMandatoryPriorAuditRow({
+      beliefId,
+      defaultBaseRate: args.defaultBaseRate,
+      insertedInitialRow: needsInitialRow,
+      needsNodePatch,
+      node: args.node,
+      rowsMissingBaseRate: rowsMissingBaseRate.length
+    })
+  );
+  return {
+    auditEntries: 1,
+    insertedInitialRows: needsInitialRow ? 1 : 0,
+    patchedHistoryRows: rowsMissingBaseRate.length,
+    patchedNodes: needsNodePatch ? 1 : 0,
+    touched: true
+  };
+}
+async function collectConnectedNodeIds(ctx, beliefId) {
+  const [rawOutbound, rawInbound] = await Promise.all([
+    ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", beliefId)).collect(),
+    ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", beliefId)).collect()
+  ]);
+  const outbound = readRowList(rawOutbound, readEpistemicEdgeBackfillRow);
+  const inbound = readRowList(rawInbound, readEpistemicEdgeBackfillRow);
+  const connectedNodeIds = /* @__PURE__ */ new Set();
+  for (const edge of outbound) {
+    if (edge.toNodeId) {
+      connectedNodeIds.add(String(edge.toNodeId));
+    }
+  }
+  for (const edge of inbound) {
+    if (edge.fromNodeId) {
+      connectedNodeIds.add(String(edge.fromNodeId));
+    }
+  }
+  return connectedNodeIds;
+}
+async function reassignConnectedBeliefNeighbors(ctx, args) {
+  let connectedReassigned = 0;
+  for (const connectedId of args.connectedNodeIds) {
+    if (args.movedBeliefIds.has(connectedId) || args.alreadyReassigned.has(connectedId)) {
+      continue;
+    }
+    try {
+      const connectedNode = readEpistemicNodeBackfillRow(
+        await ctx.db.get(epistemicNodeId(connectedId))
+      );
+      if (connectedNode?.status !== "active") {
+        continue;
+      }
+      if (connectedNode.topicId && String(connectedNode.topicId) !== String(args.targetTopicId)) {
+        await ctx.db.patch(epistemicNodeId(connectedId), {
+          topicId: args.targetTopicId,
+          updatedAt: args.now
+        });
+        args.alreadyReassigned.add(connectedId);
+        connectedReassigned++;
+      }
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[epistemicBeliefs] Failed to reassign connected node",
+        {
+          error,
+          connectedId
+        }
+      );
+    }
+  }
+  return connectedReassigned;
+}
 var getRecentConfidenceChanges = query({
   args: {
     ...optionalBeliefScopeArgs,
@@ -590,27 +1000,33 @@ var getRecentConfidenceChanges = query({
       return [];
     }
     const scopeId = scope.topicId ? String(scope.topicId) : scope.projectId;
-    if (!scopeId || !await checkScopeAccess(ctx, scopeId, args.userId)) {
+    if (!(scopeId && await checkScopeAccess(ctx, scopeId, args.userId))) {
       return [];
     }
-    const projectBeliefs = await getBeliefNodesForScope(ctx, scope);
+    const projectBeliefs = readRowList(
+      await getBeliefNodesForScope(ctx, scope),
+      readEpistemicNodeBackfillRow
+    );
     if (projectBeliefs.length === 0) {
       return [];
     }
     const beliefMap = /* @__PURE__ */ new Map();
     for (const belief of projectBeliefs) {
       const info = {
-        id: belief._id,
+        id: String(belief._id),
         title: belief.canonicalText || belief.title || "Untitled belief",
         currentConfidence: belief.confidence ?? 0.5
       };
-      beliefMap.set(belief._id, info);
+      beliefMap.set(String(belief._id), info);
     }
-    const recentConfidence = await ctx.db.query("beliefConfidence").order("desc").filter((q) => q.gt(q.field("assessedAt"), sevenDaysAgo)).take(200);
+    const recentConfidence = readRowList(
+      await ctx.db.query("beliefConfidence").order("desc").filter((q) => q.gt(q.field("assessedAt"), sevenDaysAgo)).take(200),
+      readBeliefConfidenceBackfillRow
+    );
     const changes = [];
     const seenBeliefs = /* @__PURE__ */ new Set();
     for (const entry of recentConfidence) {
-      const beliefInfo = beliefMap.get(entry.beliefId);
+      const beliefInfo = beliefMap.get(String(entry.beliefId));
       if (!beliefInfo) {
         continue;
       }
@@ -618,7 +1034,10 @@ var getRecentConfidenceChanges = query({
         continue;
       }
       seenBeliefs.add(beliefInfo.id);
-      const previousEntries = await ctx.db.query("beliefConfidence").withIndex("by_beliefId", (q) => q.eq("beliefId", entry.beliefId)).order("desc").filter((q) => q.lt(q.field("assessedAt"), entry.assessedAt)).take(1);
+      const previousEntries = readRowList(
+        await ctx.db.query("beliefConfidence").withIndex("by_beliefId", (q) => q.eq("beliefId", entry.beliefId)).order("desc").filter((q) => q.lt(q.field("assessedAt"), entry.assessedAt)).take(1),
+        readBeliefConfidenceBackfillRow
+      );
       const previousConfidence = previousEntries[0]?.confidence ?? 0.5;
       const delta = entry.confidence - previousConfidence;
       if (Math.abs(delta) < 0.05) {
@@ -646,10 +1065,14 @@ var backfillSyntheticOpinionHistory = internalMutation({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const limit = Math.max(1, Math.min(args.limit ?? 100, 100));
-    const [beliefNodes, existingHistory] = await Promise.all([
-      ctx.db.query("epistemicNodes").withIndex("by_nodeType", (q) => q.eq("nodeType", "belief")).collect(),
-      ctx.db.query("beliefConfidence").collect()
-    ]);
+    const beliefNodes = readRowList(
+      await ctx.db.query("epistemicNodes").withIndex("by_nodeType", (q) => q.eq("nodeType", "belief")).collect(),
+      readEpistemicNodeBackfillRow
+    );
+    const existingHistory = readRowList(
+      await ctx.db.query("beliefConfidence").collect(),
+      readBeliefConfidenceBackfillRow
+    );
     const beliefsWithHistory = new Set(
       existingHistory.map((entry) => String(entry.beliefId))
     );
@@ -660,8 +1083,7 @@ var backfillSyntheticOpinionHistory = internalMutation({
       if (inserted >= limit) {
         break;
       }
-      const hasOpinionSnapshot = readFiniteNumber(node.opinion_b) !== void 0 || readFiniteNumber(node.opinion_d) !== void 0 || readFiniteNumber(node.opinion_u) !== void 0 || readFiniteNumber(node.opinion_a) !== void 0 || readFiniteNumber(node.confidence) !== void 0;
-      if (!hasOpinionSnapshot) {
+      if (!hasLegacyOpinionSnapshot(node)) {
         skippedNoOpinion++;
         continue;
       }
@@ -669,9 +1091,7 @@ var backfillSyntheticOpinionHistory = internalMutation({
         skippedHasHistory++;
         continue;
       }
-      const opinion = deriveSyntheticBackfillOpinion(
-        node
-      );
+      const opinion = deriveSyntheticBackfillOpinion(node);
       await ctx.db.insert(
         "beliefConfidence",
         buildBeliefConfidenceRow({
@@ -690,10 +1110,9 @@ var backfillSyntheticOpinionHistory = internalMutation({
       beliefsWithHistory.add(String(node._id));
       inserted++;
     }
-    const remainingCandidates = beliefNodes.filter((node) => {
-      const hasOpinionSnapshot = readFiniteNumber(node.opinion_b) !== void 0 || readFiniteNumber(node.opinion_d) !== void 0 || readFiniteNumber(node.opinion_u) !== void 0 || readFiniteNumber(node.opinion_a) !== void 0 || readFiniteNumber(node.confidence) !== void 0;
-      return hasOpinionSnapshot && !beliefsWithHistory.has(String(node._id));
-    }).length;
+    const remainingCandidates = beliefNodes.filter(
+      (node) => hasLegacyOpinionSnapshot(node) && !beliefsWithHistory.has(String(node._id))
+    ).length;
     return {
       scanned: beliefNodes.length,
       inserted,
@@ -716,10 +1135,14 @@ var backfillMandatoryPriors = internalMutation({
       args.defaultBaseRate ?? 0.5,
       "defaultBaseRate"
     );
-    const [beliefNodes, historyRows] = await Promise.all([
-      ctx.db.query("epistemicNodes").withIndex("by_nodeType", (q) => q.eq("nodeType", "belief")).collect(),
-      ctx.db.query("beliefConfidence").collect()
-    ]);
+    const beliefNodes = readRowList(
+      await ctx.db.query("epistemicNodes").withIndex("by_nodeType", (q) => q.eq("nodeType", "belief")).collect(),
+      readEpistemicNodeBackfillRow
+    );
+    const historyRows = readRowList(
+      await ctx.db.query("beliefConfidence").collect(),
+      readBeliefConfidenceBackfillRow
+    );
     const historyByBeliefId = /* @__PURE__ */ new Map();
     for (const row of historyRows) {
       const beliefId = String(row.beliefId);
@@ -738,82 +1161,18 @@ var backfillMandatoryPriors = internalMutation({
       }
       const beliefId = String(node._id);
       const history = historyByBeliefId.get(beliefId) ?? [];
-      const patchedOpinion = {
-        belief: readFiniteNumber(node.opinion_b) ?? 0,
-        disbelief: readFiniteNumber(node.opinion_d) ?? 0,
-        uncertainty: readFiniteNumber(node.opinion_u) ?? 1,
-        baseRate: readFiniteNumber(node.opinion_a) ?? defaultBaseRate
-      };
-      const needsNodePatch = readFiniteNumber(node.opinion_b) === void 0 || readFiniteNumber(node.opinion_d) === void 0 || readFiniteNumber(node.opinion_u) === void 0 || readFiniteNumber(node.opinion_a) === void 0;
-      const rowsMissingBaseRate = history.filter(
-        (row) => readFiniteNumber(row.baseRate) === void 0
-      );
-      const needsInitialRow = history.length === 0;
-      if (!needsNodePatch && rowsMissingBaseRate.length === 0 && !needsInitialRow) {
+      const result = await backfillMandatoryPriorNode(ctx, {
+        defaultBaseRate,
+        history,
+        node
+      });
+      if (!result.touched) {
         continue;
       }
-      if (needsNodePatch) {
-        await ctx.db.patch(node._id, {
-          opinion_b: patchedOpinion.belief,
-          opinion_d: patchedOpinion.disbelief,
-          opinion_u: patchedOpinion.uncertainty,
-          opinion_a: patchedOpinion.baseRate,
-          updatedAt: Date.now()
-        });
-        patchedNodes++;
-      }
-      for (const row of rowsMissingBaseRate) {
-        const belief = readFiniteNumber(row.belief) ?? 0;
-        const disbelief = readFiniteNumber(row.disbelief) ?? 0;
-        const uncertainty = readFiniteNumber(row.uncertainty) ?? 1;
-        await ctx.db.patch(row._id, {
-          baseRate: defaultBaseRate,
-          confidence: confidenceFromSL(
-            belief,
-            disbelief,
-            uncertainty,
-            defaultBaseRate
-          )
-        });
-        patchedHistoryRows++;
-      }
-      if (needsInitialRow) {
-        await ctx.db.insert(
-          "beliefConfidence",
-          buildBeliefConfidenceRow({
-            beliefId: node._id,
-            belief: patchedOpinion.belief,
-            disbelief: patchedOpinion.disbelief,
-            uncertainty: patchedOpinion.uncertainty,
-            baseRate: patchedOpinion.baseRate,
-            trigger: "initial",
-            rationale: "LKC-2 backfill: inserted missing initial vacuous opinion with neutral prior.",
-            assessedAt: readFiniteNumber(node.createdAt) ?? readFiniteNumber(node.updatedAt) ?? Date.now(),
-            assessedBy: "system:lkc-2-prior-backfill",
-            slOperator: "prior_seed"
-          })
-        );
-        insertedInitialRows++;
-      }
-      await ctx.db.insert("epistemicAudit", {
-        entityType: "belief",
-        entityId: beliefId,
-        changeType: "updated",
-        changedAt: Date.now(),
-        changedBy: "system:lkc-2-prior-backfill",
-        isAgent: false,
-        previousState: null,
-        newState: {
-          baseRateBackfilled: true,
-          baseRate: defaultBaseRate,
-          patchedNodeOpinion: needsNodePatch,
-          patchedHistoryRows: rowsMissingBaseRate.length,
-          insertedInitialOpinion: needsInitialRow
-        },
-        projectId: node.projectId,
-        topicId: typeof node.topicId === "string" ? node.topicId : void 0
-      });
-      auditEntries++;
+      patchedNodes += result.patchedNodes;
+      patchedHistoryRows += result.patchedHistoryRows;
+      insertedInitialRows += result.insertedInitialRows;
+      auditEntries += result.auditEntries;
       touched++;
     }
     return {
@@ -833,7 +1192,10 @@ var backfillTwoAxisConfidence = internalMutation({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const dryRun = args.dryRun ?? false;
-    const allConfRecords = await ctx.db.query("beliefConfidence").collect();
+    const allConfRecords = readRowList(
+      await ctx.db.query("beliefConfidence").collect(),
+      readBeliefConfidenceBackfillRow
+    );
     let confUpdated = 0;
     let confSkipped = 0;
     for (const record of allConfRecords) {
@@ -849,11 +1211,14 @@ var backfillTwoAxisConfidence = internalMutation({
       }
       confUpdated++;
     }
-    const allBeliefNodes = await ctx.db.query("epistemicNodes").filter((q) => q.eq(q.field("nodeType"), "belief")).collect();
+    const allBeliefNodes = readRowList(
+      await ctx.db.query("epistemicNodes").filter((q) => q.eq(q.field("nodeType"), "belief")).collect(),
+      readEpistemicNodeBackfillRow
+    );
     let nodesUpdated = 0;
     let nodesSkipped = 0;
     for (const node of allBeliefNodes) {
-      const meta = node.metadata || {};
+      const meta = node.metadata ?? {};
       if (meta.valence !== void 0 && meta.certainty !== void 0) {
         nodesSkipped++;
         continue;
@@ -891,19 +1256,29 @@ var backfillScoredBeliefEdges = internalMutation({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const dryRun = args.dryRun ?? false;
-    const allBeliefs = await ctx.db.query("epistemicNodes").withIndex(
-      "by_topic",
-      (q) => q.eq("topicId", args.topicId || args.projectId)
-    ).filter((q) => q.eq(q.field("nodeType"), "belief")).collect();
+    const scopeTopicId = args.topicId ?? args.projectId;
+    if (!scopeTopicId) {
+      return {
+        dryRun,
+        scoredBeliefs: 0,
+        themeNodes: 0,
+        edgesCreated: 0,
+        edgesSkipped: 0
+      };
+    }
+    const allBeliefs = readRowList(
+      await ctx.db.query("epistemicNodes").withIndex("by_topic", (q) => q.eq("topicId", scopeTopicId)).filter((q) => q.eq(q.field("nodeType"), "belief")).collect(),
+      readEpistemicNodeBackfillRow
+    );
     const scoredBeliefs = allBeliefs.filter((belief) => {
-      const metadata = belief.metadata || {};
+      const metadata = belief.metadata ?? {};
       const lifecycle = resolveBeliefStatus(belief, metadata);
       return lifecycle === "active" || lifecycle === "resolved_true";
     });
-    const themeNodes = await ctx.db.query("epistemicNodes").withIndex(
-      "by_topic",
-      (q) => q.eq("topicId", args.topicId || args.projectId)
-    ).filter((q) => q.eq(q.field("nodeType"), "theme")).collect();
+    const themeNodes = readRowList(
+      await ctx.db.query("epistemicNodes").withIndex("by_topic", (q) => q.eq("topicId", scopeTopicId)).filter((q) => q.eq(q.field("nodeType"), "theme")).collect(),
+      readEpistemicNodeBackfillRow
+    );
     let created = 0;
     let skipped = 0;
     for (const belief of scoredBeliefs) {
@@ -929,7 +1304,7 @@ var backfillScoredBeliefEdges = internalMutation({
             edgeType: "relates_to_thesis",
             weight: belief.confidence ?? 0.5,
             createdBy: "backfill:scored_belief_theme",
-            topicId: String(args.projectId),
+            topicId: String(scopeTopicId),
             fromNodeType: "belief",
             toNodeType: "theme",
             fromLayer: "L3",
@@ -954,16 +1329,14 @@ var backfillBeliefSprintIds = internalMutation({
     dryRun: v.optional(v.boolean())
   },
   returns: permissiveReturn,
-  handler: async (_ctx, _args) => {
-    return {
-      dryRun: true,
-      message: "backfillBeliefSprintIds removed \u2014 sprints are D-tier legacy. Use worktrees.",
-      sprintsScanned: 0,
-      beliefsWithSprints: 0,
-      updated: 0,
-      skipped: 0
-    };
-  }
+  handler: async (_ctx, _args) => ({
+    dryRun: true,
+    message: "backfillBeliefSprintIds removed \u2014 sprints are D-tier legacy. Use worktrees.",
+    sprintsScanned: 0,
+    beliefsWithSprints: 0,
+    updated: 0,
+    skipped: 0
+  })
 });
 var getBeliefClusterPositions = query({
   args: {
@@ -973,7 +1346,7 @@ var getBeliefClusterPositions = query({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const scope = await resolveBeliefScopeOrNull(ctx, args);
-    if (!scope || !scope.projectId) {
+    if (!scope?.projectId) {
       return {
         positions: {},
         hasClusters: false,
@@ -1021,7 +1394,7 @@ var reassignBeliefsTopic = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const targetTopic = await ctx.db.get(args.targetTopicId);
+    const targetTopic = await ctx.db.get(topicId(args.targetTopicId));
     if (!targetTopic) {
       throw new Error(`Target topic not found: ${args.targetTopicId}`);
     }
@@ -1030,8 +1403,8 @@ var reassignBeliefsTopic = mutation({
     const now = Date.now();
     const movedBeliefIds = /* @__PURE__ */ new Set();
     for (const beliefNodeId of args.beliefNodeIds) {
-      const node = await ctx.db.get(beliefNodeId);
-      if (!node || node.nodeType !== "belief") {
+      const node = readEpistemicNodeBackfillRow(await ctx.db.get(beliefNodeId));
+      if (node?.nodeType !== "belief") {
         skipped++;
         continue;
       }
@@ -1045,40 +1418,14 @@ var reassignBeliefsTopic = mutation({
     let connectedReassigned = 0;
     const alreadyReassigned = /* @__PURE__ */ new Set();
     for (const beliefId of movedBeliefIds) {
-      const outbound = await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", beliefId)).collect();
-      const inbound = await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", beliefId)).collect();
-      const connectedNodeIds = /* @__PURE__ */ new Set();
-      for (const edge of outbound) {
-        if (edge.toNodeId) connectedNodeIds.add(String(edge.toNodeId));
-      }
-      for (const edge of inbound) {
-        if (edge.fromNodeId) connectedNodeIds.add(String(edge.fromNodeId));
-      }
-      for (const connectedId of connectedNodeIds) {
-        if (movedBeliefIds.has(connectedId) || alreadyReassigned.has(connectedId)) {
-          continue;
-        }
-        try {
-          const connectedNode = await ctx.db.get(connectedId);
-          if (!connectedNode || connectedNode.status !== "active") continue;
-          if (connectedNode.topicId && String(connectedNode.topicId) !== String(args.targetTopicId)) {
-            await ctx.db.patch(connectedId, {
-              topicId: args.targetTopicId,
-              updatedAt: now
-            });
-            alreadyReassigned.add(connectedId);
-            connectedReassigned++;
-          }
-        } catch (error) {
-          debugGraphPrimitiveFallback(
-            "[epistemicBeliefs] Failed to reassign connected node",
-            {
-              error,
-              connectedId
-            }
-          );
-        }
-      }
+      const connectedNodeIds = await collectConnectedNodeIds(ctx, beliefId);
+      connectedReassigned += await reassignConnectedBeliefNeighbors(ctx, {
+        alreadyReassigned,
+        connectedNodeIds,
+        movedBeliefIds,
+        now,
+        targetTopicId: args.targetTopicId
+      });
     }
     return { reassigned, skipped, connectedReassigned };
   }