@lucern/graph-primitives 1.0.29 → 1.0.30

package/dist/epistemicBeliefs.confidence.js

@@ -1,12 +1,13 @@
-import { v } from 'convex/values';
-import { normalizeTupleContradictionPolicy, mkOpinion, conditionalDeduction, project, dampedDependencyCascade, hasProjectedOpinionChanged, confidenceFromSL, detectTupleContradiction, evaluateTupleContradictionTransition, trustDiscount, applyNegativeSupport, cumulativeFusion, applyNegativeEvidence, readOpinionFromRecord } from '@lucern/confidence';
 import { requireScopeWriteAccess } from '@lucern/access-control/access';
+import { normalizeTupleContradictionPolicy, mkOpinion, conditionalDeduction, project, dampedDependencyCascade, trustDiscount, applyNegativeSupport, cumulativeFusion, applyNegativeEvidence, confidenceFromSL, detectTupleContradiction, evaluateTupleContradictionTransition, readOpinionFromRecord, hasProjectedOpinionChanged } from '@lucern/confidence';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { componentsGeneric, internalMutationGeneric, anyApi } from 'convex/server';
+import { v } from 'convex/values';
 import '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
-import { throwStructuredMutationError } from '@lucern/access-control/structuredMutationError';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, internalMutationGeneric } from 'convex/server';
 import '@lucern/access-control/audience';
 import '@lucern/access-control/auth';
+import { throwStructuredMutationError } from '@lucern/access-control/structuredMutationError';
 
 // src/epistemicBeliefs.confidence.ts
 
@@ -130,10 +131,6 @@ function promoteBeliefStatusAfterScoring(status, opts) {
   }
   return status;
 }
-var api = anyApi;
-componentsGeneric();
-var internal = anyApi;
-var internalMutation = internalMutationGeneric;
 
 // src/edges/contains.ts
 var containsPropagationSpec = {
@@ -270,7 +267,7 @@ var dependsOnPropagationSpec = {
   description: "Structural gating. Textbook conditional deduction when edge conditionals exist, otherwise damped dependency cascade through downstream chains."
 };
 
-// src/edges/derivedFrom.ts
+// src/edges/derived-from.ts
 var derivedFromPropagationSpec = {
   edgeType: "derived_from",
   direction: "incoming",
@@ -323,7 +320,7 @@ var informsPropagationSpec = {
   description: "Evidence-bearing influence. Informs can chain through the graph with light per-hop damping."
 };
 
-// src/edges/propagationTypes.ts
+// src/edges/propagation-types.ts
 function isPropagationTraversalDirection(direction) {
   return direction === "outgoing" || direction === "incoming";
 }
@@ -396,6 +393,9 @@ var testsPropagationSpec = {
 };
 
 // src/edges/index.ts
+var canContinueTransitively2 = canContinueTransitively;
+var canTraverseHop2 = canTraverseHop;
+var isPropagationTraversalDirection2 = isPropagationTraversalDirection;
 var EDGE_PROPAGATION_SPECS = [
   supportsPropagationSpec,
   informsPropagationSpec,
@@ -412,11 +412,18 @@ function getEdgePropagationSpecs() {
   return EDGE_PROPAGATION_SPECS;
 }
 function getTraversalDirections(direction) {
-  if (isPropagationTraversalDirection(direction)) {
+  if (isPropagationTraversalDirection2(direction)) {
     return [direction];
   }
   return ["outgoing", "incoming"];
 }
+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;
 
 // src/debug.ts
 function isGraphPrimitiveDebugEnabled() {
@@ -465,13 +472,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") {
@@ -496,8 +505,9 @@ function pickPrimaryTopic(candidates) {
   })[0];
 }
 async function findTopicsByScopeAlias(ctx, scopeId) {
+  const query = ctx.db.query("topics");
   try {
-    return await ctx.db.query("topics").withIndex(
+    return await query.withIndex(
       "by_graph_scope_project",
       (q) => q.eq(LEGACY_SCOPE_FIELD, scopeId)
     ).collect();
@@ -509,7 +519,7 @@ async function findTopicsByScopeAlias(ctx, scopeId) {
         scopeId
       }
     );
-    const topics = await ctx.db.query("topics").collect();
+    const topics = await query.collect();
     return topics.filter((topic) => {
       const normalizedGlobalId = normalizeScopeValue(topic.globalId);
       const mappedProjectId = asMappedProjectId(topic);
@@ -565,137 +575,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
+  };
+}
 ({
   projectId: v.optional(v.string()),
   topicId: v.optional(v.string())
@@ -765,9 +753,10 @@ async function resolveNodeScopeForWorkspaceIsolation(ctx, node) {
   if (resolved.tenantId || resolved.workspaceId) {
     return resolved;
   }
-  if (node.topicId) {
+  const topicId = normalizeScopeValue2(node.topicId);
+  if (topicId) {
     const topicScope = await resolveTopicProjectScope(ctx, {
-      topicId: node.topicId
+      topicId
     });
     return {
       ...resolved,
@@ -789,9 +778,8 @@ async function resolveNodeScopeForWorkspaceIsolation(ctx, node) {
 }
 
 // src/confidencePropagationDispatch.ts
-function resolveTraversalTargetNodeId(edge, direction) {
-  const targetNodeId = direction === "outgoing" ? edge.toNodeId : edge.fromNodeId;
-  return targetNodeId ?? void 0;
+function nodeIdToCacheKey(nodeId) {
+  return String(nodeId);
 }
 function readNodeOpinion(node) {
   const metadata = node.metadata ?? {};
@@ -807,112 +795,168 @@ function readNodeOpinion(node) {
     return mkOpinion(0, 0, 1, 0.5);
   }
 }
+function resolveTraversalTargetNodeId(edge, direction) {
+  const targetNodeId = direction === "outgoing" ? edge.toNodeId : edge.fromNodeId;
+  return targetNodeId ?? void 0;
+}
+function buildInitialState(sourceNodeId, sourceOpinion) {
+  return {
+    nodeId: sourceNodeId,
+    opinion: sourceOpinion,
+    hop: 0,
+    visitedNodeIds: /* @__PURE__ */ new Set([nodeIdToCacheKey(sourceNodeId)])
+  };
+}
+function extendVisited(currentVisited, targetNodeId) {
+  return /* @__PURE__ */ new Set([...currentVisited, nodeIdToCacheKey(targetNodeId)]);
+}
+function makeTransitiveState(current, targetNodeId, projectedOpinion, nextHop) {
+  return {
+    nodeId: targetNodeId,
+    opinion: projectedOpinion,
+    hop: nextHop,
+    visitedNodeIds: extendVisited(current.visitedNodeIds, targetNodeId)
+  };
+}
+function makeDispatchRecord(targetNodeId, spec, direction, edge, projectedOpinion, nextHop, result, existingDispatch) {
+  return {
+    targetNodeId,
+    edgeType: spec.edgeType,
+    traversedDirection: direction,
+    weight: edge.weight ?? 1,
+    opinion: projectedOpinion,
+    operator: result.operator,
+    rationale: existingDispatch ? `${existingDispatch.rationale}; ${result.rationale}` : result.rationale,
+    hop: nextHop
+  };
+}
+async function loadCachedNode(scope, nodeId) {
+  const cacheKey = nodeIdToCacheKey(nodeId);
+  if (!scope.nodeCache.has(cacheKey)) {
+    scope.nodeCache.set(cacheKey, await scope.args.getNode(nodeId));
+  }
+  return scope.nodeCache.get(cacheKey) ?? null;
+}
+async function collectTargetDispatch(state, nextHop, spec, direction, edge, queue, scope) {
+  const sourceScope = scope.args.sourceScope;
+  if (sourceScope && !edgeMatchesWorkspaceReasoningScope(edge, sourceScope)) {
+    return;
+  }
+  const targetNodeId = resolveTraversalTargetNodeId(edge, direction);
+  if (!targetNodeId) {
+    return;
+  }
+  const targetNodeIdKey = nodeIdToCacheKey(targetNodeId);
+  if (state.visitedNodeIds.has(targetNodeIdKey)) {
+    return;
+  }
+  const targetNode = await loadCachedNode(scope, targetNodeId);
+  if (targetNode?.nodeType !== "belief") {
+    return;
+  }
+  if (sourceScope && !nodeMatchesWorkspaceReasoningScope(targetNode, sourceScope)) {
+    return;
+  }
+  const targetOpinion = scope.opinionCache.get(targetNodeIdKey) ?? readNodeOpinion(targetNode);
+  const result = spec.operator(state.opinion, targetOpinion, edge, {
+    hop: nextHop,
+    sourceNodeId: state.nodeId,
+    targetNodeId,
+    traversedDirection: direction,
+    spec
+  });
+  if (!(result && hasProjectedOpinionChanged(targetOpinion, result.opinion))) {
+    return;
+  }
+  const projectedOpinion = mkOpinion(
+    result.opinion.b,
+    result.opinion.d,
+    result.opinion.u,
+    result.opinion.a
+  );
+  scope.opinionCache.set(targetNodeIdKey, projectedOpinion);
+  const existingDispatch = scope.dispatchesByTargetId.get(targetNodeIdKey);
+  scope.dispatchesByTargetId.set(
+    targetNodeIdKey,
+    makeDispatchRecord(
+      targetNodeId,
+      spec,
+      direction,
+      edge,
+      projectedOpinion,
+      nextHop,
+      result,
+      existingDispatch
+    )
+  );
+  if (canContinueTransitively2(spec, nextHop)) {
+    queue.push(
+      makeTransitiveState(state, targetNodeId, projectedOpinion, nextHop)
+    );
+  }
+}
+async function processTraversalSpec(state, nextHop, spec, queue, scope) {
+  const sourceNodeId = state.nodeId;
+  for (const direction of getTraversalDirections(spec.direction)) {
+    const edges = await scope.args.queryEdges({
+      nodeId: sourceNodeId,
+      spec,
+      direction,
+      hop: nextHop
+    });
+    for (const edge of edges) {
+      await collectTargetDispatch(
+        state,
+        nextHop,
+        spec,
+        direction,
+        edge,
+        queue,
+        scope
+      );
+    }
+  }
+}
+async function processQueuedState(state, queue, scope) {
+  const nextHop = state.hop + 1;
+  for (const spec of scope.traversalSpecs) {
+    if (!canTraverseHop2(spec, nextHop)) {
+      continue;
+    }
+    await processTraversalSpec(state, nextHop, spec, queue, scope);
+  }
+}
+function sortDispatches(dispatches) {
+  return Array.from(dispatches).sort((left, right) => {
+    if (left.hop !== right.hop) {
+      return left.hop - right.hop;
+    }
+    return String(left.targetNodeId).localeCompare(String(right.targetNodeId));
+  });
+}
 async function collectConfidencePropagationDispatches(args) {
   const dispatchesByTargetId = /* @__PURE__ */ new Map();
   const opinionCache = /* @__PURE__ */ new Map();
   const nodeCache = /* @__PURE__ */ new Map();
   const traversalSpecs = args.traversalSpecs ?? getEdgePropagationSpecs();
+  const scope = {
+    args,
+    dispatchesByTargetId,
+    opinionCache,
+    nodeCache,
+    traversalSpecs
+  };
   const queue = [
-    {
-      nodeId: args.sourceNodeId,
-      opinion: args.sourceOpinion,
-      hop: 0,
-      visitedNodeIds: /* @__PURE__ */ new Set([String(args.sourceNodeId)])
-    }
+    buildInitialState(args.sourceNodeId, args.sourceOpinion)
   ];
-  const loadNode = async (nodeId) => {
-    const cacheKey = String(nodeId);
-    if (!nodeCache.has(cacheKey)) {
-      nodeCache.set(cacheKey, await args.getNode(nodeId));
-    }
-    return nodeCache.get(cacheKey) ?? null;
-  };
   while (queue.length > 0) {
     const state = queue.shift();
     if (!state) {
       continue;
     }
-    for (const spec of traversalSpecs) {
-      const nextHop = state.hop + 1;
-      if (!canTraverseHop(spec, nextHop)) {
-        continue;
-      }
-      for (const direction of getTraversalDirections(spec.direction)) {
-        const edges = await args.queryEdges({
-          nodeId: state.nodeId,
-          spec,
-          direction,
-          hop: nextHop
-        });
-        for (const edge of edges) {
-          if (args.sourceScope && !edgeMatchesWorkspaceReasoningScope(edge, args.sourceScope)) {
-            continue;
-          }
-          const targetNodeId = resolveTraversalTargetNodeId(edge, direction);
-          if (!targetNodeId) {
-            continue;
-          }
-          if (state.visitedNodeIds.has(String(targetNodeId))) {
-            continue;
-          }
-          const targetNode = await loadNode(targetNodeId);
-          if (!targetNode || targetNode.nodeType !== "belief") {
-            continue;
-          }
-          if (args.sourceScope && !nodeMatchesWorkspaceReasoningScope(targetNode, args.sourceScope)) {
-            continue;
-          }
-          const cacheKey = String(targetNodeId);
-          const targetOpinion = opinionCache.get(cacheKey) ?? readNodeOpinion(targetNode);
-          const result = spec.operator(state.opinion, targetOpinion, edge, {
-            hop: nextHop,
-            sourceNodeId: state.nodeId,
-            targetNodeId,
-            traversedDirection: direction,
-            spec
-          });
-          if (!result || !hasProjectedOpinionChanged(targetOpinion, result.opinion)) {
-            continue;
-          }
-          const projectedOpinion = mkOpinion(
-            result.opinion.b,
-            result.opinion.d,
-            result.opinion.u,
-            result.opinion.a
-          );
-          opinionCache.set(cacheKey, projectedOpinion);
-          const existingDispatch = dispatchesByTargetId.get(cacheKey);
-          dispatchesByTargetId.set(cacheKey, {
-            targetNodeId,
-            edgeType: spec.edgeType,
-            traversedDirection: direction,
-            weight: edge.weight ?? 1,
-            opinion: projectedOpinion,
-            operator: result.operator,
-            rationale: existingDispatch ? `${existingDispatch.rationale}; ${result.rationale}` : result.rationale,
-            hop: nextHop
-          });
-          if (canContinueTransitively(spec, nextHop)) {
-            queue.push({
-              nodeId: targetNodeId,
-              opinion: projectedOpinion,
-              hop: nextHop,
-              visitedNodeIds: /* @__PURE__ */ new Set([
-                ...state.visitedNodeIds,
-                String(targetNodeId)
-              ])
-            });
-          }
-        }
-      }
-    }
+    await processQueuedState(state, queue, scope);
   }
-  return Array.from(dispatchesByTargetId.values()).sort((left, right) => {
-    if (left.hop !== right.hop) {
-      return left.hop - right.hop;
-    }
-    return String(left.targetNodeId).localeCompare(String(right.targetNodeId));
-  });
+  return sortDispatches(dispatchesByTargetId.values());
 }
 v.id("epistemicNodes");
 var DEFAULT_CONFIDENCE_POLICY = {
@@ -993,7 +1037,10 @@ function resolveBeliefStatus(node, metadata) {
   });
 }
 async function hasCompletedWorktreeForBelief(ctx, beliefNodeId) {
-  const clusterMembership = await ctx.db.query("worktreeBeliefCluster").withIndex("by_belief", (q) => q.eq("beliefId", beliefNodeId)).collect();
+  const clusterMembership = await ctx.db.query("worktreeBeliefCluster").withIndex(
+    "by_belief",
+    (q) => q.eq("beliefId", beliefNodeId)
+  ).collect();
   for (const membership of clusterMembership) {
     const worktree = await ctx.db.get(membership.worktreeId);
     if (worktree?.status === "completed" || worktree?.status === "merged") {
@@ -1004,7 +1051,10 @@ async function hasCompletedWorktreeForBelief(ctx, beliefNodeId) {
 }
 async function getActiveConfidencePolicy(ctx) {
   try {
-    const activeConfig = await ctx.db.query("logicSprintScoring").withIndex("by_active", (q) => q.eq("isActive", true)).first();
+    const activeConfig = await ctx.db.query("logicSprintScoring").withIndex(
+      "by_active",
+      (q) => q.eq("isActive", true)
+    ).first();
     return {
       scoringMode: activeConfig?.confidencePolicy === "always" ? "always" : DEFAULT_CONFIDENCE_POLICY.scoringMode,
       tupleContradiction: normalizeTupleContradictionPolicy(
@@ -1023,9 +1073,189 @@ async function getActiveConfidencePolicy(ctx) {
 }
 
 // src/epistemicBeliefs.confidence.ts
+function isRecord(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 readOptionalBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function readOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readRecord(value) {
+  return isRecord(value) ? value : void 0;
+}
+function readConfidenceBeliefNode(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const id = readConvexId(value._id);
+  const nodeType = readOptionalString(value.nodeType);
+  const projectId = readOptionalString(value.projectId);
+  if (!(id && nodeType === "belief" && projectId)) {
+    return null;
+  }
+  const node = {
+    _id: id,
+    nodeType,
+    projectId
+  };
+  const confidence = readOptionalNumber(value.confidence);
+  const epistemicLayer = readOptionalString(value.epistemicLayer);
+  const globalId = readOptionalString(value.globalId);
+  const metadata = readRecord(value.metadata);
+  const opinionA = readOptionalNumber(value.opinion_a);
+  const opinionB = readOptionalNumber(value.opinion_b);
+  const opinionD = readOptionalNumber(value.opinion_d);
+  const opinionU = readOptionalNumber(value.opinion_u);
+  const predictionMeta = readRecord(value.predictionMeta);
+  const publicationStatus = readOptionalString(value.publicationStatus);
+  const status = readOptionalString(value.status);
+  const tenantId = readOptionalString(value.tenantId);
+  const topicId = readOptionalString(value.topicId);
+  const tupleContradicted = readOptionalBoolean(value.tupleContradicted);
+  const workspaceId = readOptionalString(value.workspaceId);
+  if (confidence !== void 0) {
+    node.confidence = confidence;
+  }
+  if (epistemicLayer !== void 0) {
+    node.epistemicLayer = epistemicLayer;
+  }
+  if (globalId !== void 0) {
+    node.globalId = globalId;
+  }
+  if (metadata !== void 0) {
+    node.metadata = metadata;
+  }
+  if (opinionA !== void 0) {
+    node.opinion_a = opinionA;
+  }
+  if (opinionB !== void 0) {
+    node.opinion_b = opinionB;
+  }
+  if (opinionD !== void 0) {
+    node.opinion_d = opinionD;
+  }
+  if (opinionU !== void 0) {
+    node.opinion_u = opinionU;
+  }
+  if (predictionMeta !== void 0) {
+    node.predictionMeta = predictionMeta;
+  }
+  if (publicationStatus !== void 0) {
+    node.publicationStatus = publicationStatus;
+  }
+  if (status !== void 0) {
+    node.status = status;
+  }
+  if (tenantId !== void 0) {
+    node.tenantId = tenantId;
+  }
+  if (topicId !== void 0) {
+    node.topicId = topicId;
+  }
+  if (tupleContradicted !== void 0) {
+    node.tupleContradicted = tupleContradicted;
+  }
+  if (workspaceId !== void 0) {
+    node.workspaceId = workspaceId;
+  }
+  return node;
+}
+function readPropagationEdge(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const edgeType = readOptionalString(value.edgeType);
+  if (!edgeType) {
+    return null;
+  }
+  const edge = { edgeType };
+  const fromNodeId = readConvexId(value.fromNodeId);
+  const tenantId = readOptionalString(value.tenantId);
+  const toNodeId = readConvexId(value.toNodeId);
+  const weight = readOptionalNumber(value.weight);
+  const workspaceId = readOptionalString(value.workspaceId);
+  if (fromNodeId !== void 0) {
+    edge.fromNodeId = fromNodeId;
+  }
+  if (tenantId !== void 0) {
+    edge.tenantId = tenantId;
+  }
+  if (toNodeId !== void 0) {
+    edge.toNodeId = toNodeId;
+  }
+  if (weight !== void 0) {
+    edge.weight = weight;
+  }
+  if (workspaceId !== void 0) {
+    edge.workspaceId = workspaceId;
+  }
+  return edge;
+}
+function readRowList(values, reader) {
+  return values.flatMap((value) => {
+    const row = reader(value);
+    return row ? [row] : [];
+  });
+}
 async function applyBeliefConfidenceChange(ctx, args) {
   const now = Date.now();
-  const node = await ctx.db.get(args.nodeId);
+  const node = await requireConfidenceBeliefNode(ctx, args);
+  const state = await buildConfidenceChangeState(ctx, node, args);
+  await assertConfidenceScoringPolicySatisfied(ctx, args, state);
+  const tupleContradictionId = await createTupleContradictionIfNeeded(
+    ctx,
+    args,
+    node,
+    state
+  );
+  await patchBeliefConfidenceState(ctx, args, state);
+  await scheduleFirstScoringThemeEdges(ctx, args, node, state);
+  const beliefConfidenceId = await insertBeliefConfidenceRecord(
+    ctx,
+    args,
+    state,
+    tupleContradictionId,
+    now
+  );
+  await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+    nodeId: args.nodeId,
+    operation: "upsert"
+  });
+  await insertConfidenceAudit(
+    ctx,
+    args,
+    node,
+    state,
+    tupleContradictionId,
+    now
+  );
+  await insertTupleTransitionAuditIfNeeded(
+    ctx,
+    args,
+    node,
+    state,
+    tupleContradictionId,
+    now
+  );
+  await scheduleConfidenceFollowups(ctx, args, node, state);
+  return {
+    nodeId: args.nodeId,
+    previousConfidence: state.previousConfidence,
+    newConfidence: state.derivedConfidence,
+    opinion: state.nextOpinion,
+    beliefConfidenceId
+  };
+}
+async function requireConfidenceBeliefNode(ctx, args) {
+  const node = readConfidenceBeliefNode(await ctx.db.get(args.nodeId));
   if (!node) {
     throwStructuredMutationError({
       message: "Node not found.",
@@ -1036,59 +1266,28 @@ async function applyBeliefConfidenceChange(ctx, args) {
       details: { nodeId: args.nodeId }
     });
   }
-  if (node.nodeType !== "belief") {
-    throwStructuredMutationError({
-      message: `appendSlScoring only applies to belief nodes. Received nodeType "${node.nodeType}". Entity nodes (company, person, investor, etc.) do not have confidence \u2014 use entityLifecycle.updateEntityAttributes for mutable entity data.`,
-      status: 400,
-      code: "INVALID_ARGUMENT",
-      invariantCode: "entity.no_confidence",
-      suggestion: "Use entityLifecycle.updateEntityAttributes for entity mutations. appendSlScoring is for belief nodes only.",
-      details: { nodeId: args.nodeId, nodeType: node.nodeType }
-    });
-  }
-  if (!node.projectId) {
-    throwStructuredMutationError({
-      message: "Belief has no project scope.",
-      status: 400,
-      code: "MISSING_SCOPE",
-      invariantCode: "belief.project_required",
-      suggestion: "Belief must have a projectId before SL scoring can be appended.",
-      details: { nodeId: args.nodeId }
-    });
-  }
-  await requireScopeWriteAccess(
-    ctx,
-    node.projectId,
-    args.authenticatedUserId
-  );
-  const existingMetadata = node.metadata || {};
+  await requireScopeWriteAccess(ctx, node.projectId, args.authenticatedUserId);
+  return node;
+}
+async function buildConfidenceChangeState(ctx, node, args) {
+  const existingMetadata = readNodeMetadata(node);
   const currentBeliefStatus = resolveBeliefStatus(node, existingMetadata);
   const confidencePolicy = await getActiveConfidencePolicy(ctx);
-  if (confidencePolicy.scoringMode === "after_worktree" && isPreValidationBeliefStatus(currentBeliefStatus)) {
-    const hasCompletedWorktree = await hasCompletedWorktreeForBelief(
-      ctx,
-      args.nodeId
-    );
-    if (!hasCompletedWorktree) {
-      throwStructuredMutationError({
-        message: "Cannot score belief before worktree completion. Complete a worktree that tests this belief first.",
-        status: 409,
-        code: "CONFLICT",
-        invariantCode: "belief.confidence_append_only",
-        suggestion: "Complete a worktree linked to this belief before recording SL scoring.",
-        details: { nodeId: args.nodeId }
-      });
-    }
-  }
   const previousConfidence = node.confidence || 0.5;
   const predictionMeta = node.predictionMeta || existingMetadata.predictionMeta;
   const previousOpinion = readBeliefOpinionSnapshot(node, existingMetadata);
-  const slB = args.belief;
-  const slD = args.disbelief;
-  const slU = args.uncertainty;
-  const slA = args.baseRate ?? 0.5;
-  const nextOpinion = { b: slB, d: slD, u: slU, a: slA };
-  const derivedConfidence = confidenceFromSL(slB, slD, slU, slA);
+  const nextOpinion = {
+    b: args.belief,
+    d: args.disbelief,
+    u: args.uncertainty,
+    a: args.baseRate ?? 0.5
+  };
+  const derivedConfidence = confidenceFromSL(
+    nextOpinion.b,
+    nextOpinion.d,
+    nextOpinion.u,
+    nextOpinion.a
+  );
   const isFirstScoring = typeof node.confidence !== "number" || !Number.isFinite(node.confidence);
   const previousTupleContradicted = readTupleContradictedFlag(node.tupleContradicted) ?? readTupleContradictedFlag(existingMetadata.tupleContradicted) ?? detectTupleContradiction(
     previousOpinion,
@@ -1109,79 +1308,121 @@ async function applyBeliefConfidenceChange(ctx, args) {
     predictionMeta,
     metadata: existingMetadata
   });
-  let tupleContradictionId;
-  if (tupleTransition.crossedIntoTupleContradiction) {
-    tupleContradictionId = await ctx.runMutation(
-      "contradictions:create",
-      {
-        projectId: node.projectId,
-        topicId: node.topicId,
-        beliefId: args.nodeId,
-        beliefBId: args.nodeId,
-        supportingInsightIds: [],
-        contradictingInsightIds: [],
-        severity: deriveTupleContradictionSeverity(node),
-        source: "tuple_space",
-        detectionMethod: "agent",
-        description: tupleContradictionDescription,
-        createdBy: args.authenticatedUserId
-      }
-    );
+  const storedRationale = args.rationale ?? `Confidence changed from ${previousConfidence.toFixed(2)} (nodeId: ${args.nodeId})`;
+  return {
+    confidencePolicy,
+    currentBeliefStatus,
+    derivedConfidence,
+    existingMetadata,
+    isFirstScoring,
+    newBeliefStatus,
+    nextOpinion,
+    previousConfidence,
+    previousTupleContradicted,
+    storedRationale,
+    tupleContradictionDescription,
+    tupleTransition
+  };
+}
+function readNodeMetadata(node) {
+  return node.metadata ?? {};
+}
+async function assertConfidenceScoringPolicySatisfied(ctx, args, state) {
+  if (state.confidencePolicy.scoringMode !== "after_worktree" || !isPreValidationBeliefStatus(state.currentBeliefStatus)) {
+    return;
   }
+  const hasCompletedWorktree = await hasCompletedWorktreeForBelief(
+    ctx,
+    args.nodeId
+  );
+  if (hasCompletedWorktree) {
+    return;
+  }
+  throwStructuredMutationError({
+    message: "Cannot score belief before worktree completion. Complete a worktree that tests this belief first.",
+    status: 409,
+    code: "CONFLICT",
+    invariantCode: "belief.confidence_append_only",
+    suggestion: "Complete a worktree linked to this belief before recording SL scoring.",
+    details: { nodeId: args.nodeId }
+  });
+}
+async function createTupleContradictionIfNeeded(ctx, args, node, state) {
+  if (!state.tupleTransition.crossedIntoTupleContradiction) {
+    return;
+  }
+  return await ctx.runMutation("contradictions:create", {
+    projectId: node.projectId,
+    topicId: node.topicId,
+    beliefId: args.nodeId,
+    beliefBId: args.nodeId,
+    supportingInsightIds: [],
+    contradictingInsightIds: [],
+    severity: deriveTupleContradictionSeverity(node),
+    source: "tuple_space",
+    detectionMethod: "agent",
+    description: state.tupleContradictionDescription,
+    createdBy: args.authenticatedUserId
+  });
+}
+async function patchBeliefConfidenceState(ctx, args, state) {
   await ctx.db.patch(args.nodeId, {
-    confidence: derivedConfidence,
-    beliefStatus: newBeliefStatus,
-    tupleContradicted: tupleTransition.tupleContradicted,
-    updatedAt: now,
-    // Store SL opinion fields at node level for fast access
-    opinion_b: slB,
-    opinion_d: slD,
-    opinion_u: slU,
-    opinion_a: slA,
+    confidence: state.derivedConfidence,
+    beliefStatus: state.newBeliefStatus,
+    tupleContradicted: state.tupleTransition.tupleContradicted,
+    updatedAt: Date.now(),
+    opinion_b: state.nextOpinion.b,
+    opinion_d: state.nextOpinion.d,
+    opinion_u: state.nextOpinion.u,
+    opinion_a: state.nextOpinion.a,
     metadata: {
-      ...existingMetadata,
-      beliefStatus: newBeliefStatus,
-      slBelief: slB,
-      slDisbelief: slD,
-      slUncertainty: slU,
-      slBaseRate: slA,
-      tupleContradicted: tupleTransition.tupleContradicted
+      ...state.existingMetadata,
+      beliefStatus: state.newBeliefStatus,
+      slBelief: state.nextOpinion.b,
+      slDisbelief: state.nextOpinion.d,
+      slUncertainty: state.nextOpinion.u,
+      slBaseRate: state.nextOpinion.a,
+      tupleContradicted: state.tupleTransition.tupleContradicted
     }
   });
-  if (isFirstScoring) {
-    const nodeTopicId = node.topicId;
-    const themeNodes = await ctx.db.query("epistemicNodes").withIndex(
-      "by_topic",
-      (q) => q.eq("topicId", nodeTopicId || node.projectId)
-    ).filter((q) => q.eq(q.field("nodeType"), "theme")).collect();
-    for (const theme of themeNodes) {
-      if (theme.globalId && node.globalId) {
-        await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
-          globalId: `edge-${node.globalId}-relates_to_thesis-${theme.globalId}`,
-          fromGlobalId: node.globalId,
-          toGlobalId: theme.globalId,
-          edgeType: "relates_to_thesis",
-          weight: derivedConfidence,
-          createdBy: args.authenticatedUserId,
-          topicId: String(node.projectId),
-          fromNodeType: "belief",
-          toNodeType: "theme",
-          fromLayer: "L3",
-          toLayer: "L3"
-        });
-      }
+}
+async function scheduleFirstScoringThemeEdges(ctx, args, node, state) {
+  if (!state.isFirstScoring) {
+    return;
+  }
+  const themeNodes = await ctx.db.query("epistemicNodes").withIndex(
+    "by_topic",
+    (q) => q.eq("topicId", node.topicId || node.projectId)
+  ).filter((q) => q.eq(q.field("nodeType"), "theme")).collect();
+  for (const theme of themeNodes) {
+    if (!(theme.globalId && node.globalId)) {
+      continue;
     }
+    await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
+      globalId: `edge-${node.globalId}-relates_to_thesis-${theme.globalId}`,
+      fromGlobalId: node.globalId,
+      toGlobalId: theme.globalId,
+      edgeType: "relates_to_thesis",
+      weight: state.derivedConfidence,
+      createdBy: args.authenticatedUserId,
+      topicId: String(node.projectId),
+      fromNodeType: "belief",
+      toNodeType: "theme",
+      fromLayer: "L3",
+      toLayer: "L3"
+    });
   }
-  const storedRationale = args.rationale ?? `Confidence changed from ${previousConfidence.toFixed(2)} (nodeId: ${args.nodeId})`;
-  const beliefConfidenceId = await ctx.db.insert("beliefConfidence", {
+}
+async function insertBeliefConfidenceRecord(ctx, args, state, tupleContradictionId, now) {
+  return await ctx.db.insert("beliefConfidence", {
     ...buildBeliefConfidenceRow({
       beliefId: args.nodeId,
-      belief: slB,
-      disbelief: slD,
-      uncertainty: slU,
-      baseRate: slA,
+      belief: state.nextOpinion.b,
+      disbelief: state.nextOpinion.d,
+      uncertainty: state.nextOpinion.u,
+      baseRate: state.nextOpinion.a,
       trigger: args.trigger,
-      rationale: storedRationale,
+      rationale: state.storedRationale,
       assessedBy: args.authenticatedUserId,
       assessedAt: now,
       slOperator: args.slOperator,
@@ -1190,25 +1431,23 @@ async function applyBeliefConfidenceChange(ctx, args) {
       triggeringWorktreeId: args.triggeringWorktreeId
     })
   });
-  await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
-    nodeId: args.nodeId,
-    operation: "upsert"
-  });
+}
+async function insertConfidenceAudit(ctx, args, node, state, tupleContradictionId, now) {
   await ctx.db.insert("epistemicAudit", {
     entityType: "belief",
     entityId: args.nodeId,
     changeType: "confidence_changed",
     previousState: {
-      confidence: previousConfidence,
-      tupleContradicted: previousTupleContradicted
+      confidence: state.previousConfidence,
+      tupleContradicted: state.previousTupleContradicted
     },
     newState: {
-      opinion: nextOpinion,
-      confidence: derivedConfidence,
+      opinion: state.nextOpinion,
+      confidence: state.derivedConfidence,
       trigger: args.trigger,
-      rationale: storedRationale,
-      tupleContradicted: tupleTransition.tupleContradicted,
-      tupleContradictionPolicy: tupleTransition.policy,
+      rationale: state.storedRationale,
+      tupleContradicted: state.tupleTransition.tupleContradicted,
+      tupleContradictionPolicy: state.tupleTransition.policy,
       ...tupleContradictionId ? { tupleContradictionId: String(tupleContradictionId) } : {}
     },
     changedBy: args.authenticatedUserId,
@@ -1217,28 +1456,39 @@ async function applyBeliefConfidenceChange(ctx, args) {
     projectId: node.projectId,
     topicId: node.topicId
   });
-  if (tupleTransition.crossedIntoTupleContradiction || tupleTransition.crossedOutOfTupleContradiction) {
-    await ctx.db.insert("epistemicAudit", {
-      entityType: "belief",
-      entityId: args.nodeId,
-      changeType: "updated",
-      previousState: { tupleContradicted: previousTupleContradicted },
-      newState: {
-        tupleContradicted: tupleTransition.tupleContradicted,
-        action: tupleTransition.crossedIntoTupleContradiction ? "tuple_contradiction_detected" : "tuple_contradiction_cleared",
-        opinion: nextOpinion,
-        tupleContradictionPolicy: tupleTransition.policy,
-        ...tupleContradictionId ? { tupleContradictionId: String(tupleContradictionId) } : {}
-      },
-      rationale: tupleTransition.crossedIntoTupleContradiction ? tupleContradictionDescription : `Tuple-space contradiction cleared: b=${nextOpinion.b.toFixed(2)}, d=${nextOpinion.d.toFixed(2)} no longer exceed the configured policy thresholds.`,
-      changedBy: args.authenticatedUserId,
-      isAgent: false,
-      changedAt: now,
-      projectId: node.projectId,
-      topicId: node.topicId
-    });
+}
+async function insertTupleTransitionAuditIfNeeded(ctx, args, node, state, tupleContradictionId, now) {
+  if (!(state.tupleTransition.crossedIntoTupleContradiction || state.tupleTransition.crossedOutOfTupleContradiction)) {
+    return;
   }
-  if (Math.abs(derivedConfidence - previousConfidence) >= 0.15) {
+  await ctx.db.insert("epistemicAudit", {
+    entityType: "belief",
+    entityId: args.nodeId,
+    changeType: "updated",
+    previousState: { tupleContradicted: state.previousTupleContradicted },
+    newState: {
+      tupleContradicted: state.tupleTransition.tupleContradicted,
+      action: state.tupleTransition.crossedIntoTupleContradiction ? "tuple_contradiction_detected" : "tuple_contradiction_cleared",
+      opinion: state.nextOpinion,
+      tupleContradictionPolicy: state.tupleTransition.policy,
+      ...tupleContradictionId ? { tupleContradictionId: String(tupleContradictionId) } : {}
+    },
+    rationale: tupleAuditRationale(state),
+    changedBy: args.authenticatedUserId,
+    isAgent: false,
+    changedAt: now,
+    projectId: node.projectId,
+    topicId: node.topicId
+  });
+}
+function tupleAuditRationale(state) {
+  if (state.tupleTransition.crossedIntoTupleContradiction) {
+    return state.tupleContradictionDescription;
+  }
+  return `Tuple-space contradiction cleared: b=${state.nextOpinion.b.toFixed(2)}, d=${state.nextOpinion.d.toFixed(2)} no longer exceed the configured policy thresholds.`;
+}
+async function scheduleConfidenceFollowups(ctx, args, node, state) {
+  if (Math.abs(state.derivedConfidence - state.previousConfidence) >= 0.15) {
     await ctx.scheduler.runAfter(
       5e3,
       internal.bi.contradictionSemanticDetector.scanAffectedBeliefs,
@@ -1255,13 +1505,6 @@ async function applyBeliefConfidenceChange(ctx, args) {
       { nodeId: args.nodeId }
     );
   }
-  return {
-    nodeId: args.nodeId,
-    previousConfidence,
-    newConfidence: derivedConfidence,
-    opinion: { b: slB, d: slD, u: slU, a: slA },
-    beliefConfidenceId
-  };
 }
 function propagationPressureLabel(edgeType, weight) {
   if (edgeType === "contradicts" || edgeType === "refutes") {
@@ -1289,7 +1532,7 @@ var propagateConfidenceChange = internalMutation({
       args.opinion_u,
       args.opinion_a
     );
-    const sourceNode = await ctx.db.get(args.nodeId);
+    const sourceNode = readConfidenceBeliefNode(await ctx.db.get(args.nodeId));
     const sourceScope = await resolveNodeScopeForWorkspaceIsolation(
       ctx,
       sourceNode
@@ -1298,16 +1541,20 @@ var propagateConfidenceChange = internalMutation({
       sourceNodeId: args.nodeId,
       sourceOpinion,
       sourceScope,
-      queryEdges: async ({ nodeId, spec, direction }) => {
-        return await ctx.db.query("epistemicEdges").withIndex(
+      queryEdges: async ({ nodeId, spec, direction }) => readRowList(
+        await ctx.db.query("epistemicEdges").withIndex(
           direction === "outgoing" ? "by_from_type" : "by_to_type",
           (q) => direction === "outgoing" ? q.eq("fromNodeId", nodeId).eq("edgeType", spec.edgeType) : q.eq("toNodeId", nodeId).eq("edgeType", spec.edgeType)
-        ).collect();
-      },
-      getNode: async (nodeId) => await ctx.db.get(nodeId)
+        ).collect(),
+        readPropagationEdge
+      ),
+      getNode: async (nodeId) => readConfidenceBeliefNode(await ctx.db.get(nodeId))
     });
     for (const dispatch of dispatches) {
-      const pressureLabel = propagationPressureLabel(dispatch.edgeType, dispatch.weight);
+      const pressureLabel = propagationPressureLabel(
+        dispatch.edgeType,
+        dispatch.weight
+      );
       await applyBeliefConfidenceChange(ctx, {
         nodeId: dispatch.targetNodeId,
         belief: dispatch.opinion.b,