@lucern/graph-primitives 1.0.28 → 1.0.30

package/dist/epistemicContracts.js

@@ -1,14 +1,37 @@
-import { v, ConvexError } from 'convex/values';
-import { normalizeTupleContradictionPolicy, mkOpinion, conditionalDeduction, project, dampedDependencyCascade, hasProjectedOpinionChanged, confidenceFromSL, detectTupleContradiction, evaluateTupleContradictionTransition, deriveContractModulationPlan, deriveContractStatus, trustDiscount, applyNegativeSupport, cumulativeFusion, applyNegativeEvidence, readOpinionFromRecord, parseEvidentialEvaluatorConfig, compareMetricValue, buildEvidentialRationale, parseMetricCheckerConfig, getEvaluatorInputRecord, pickFiniteNumber, resolveComparisonResult, buildComparisonRationale, parseReferenceCheckCounterConfig, parseTemporalDeadlineConfig, parseMarketIndexComparatorConfig, createInheritedContractRecord } from '@lucern/confidence';
-import { checkProjectAccess } from '@lucern/access-control/access';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, internalMutationGeneric, queryGeneric, mutationGeneric } from 'convex/server';
 import '@lucern/access-control/audience';
 import { getCurrentUserId } from '@lucern/access-control/auth';
-import { componentsGeneric, internalMutationGeneric, anyApi, queryGeneric, mutationGeneric } from 'convex/server';
+import { throwStructuredMutationError } from '@lucern/access-control/structuredMutationError';
+import { normalizeTupleContradictionPolicy, mkOpinion, conditionalDeduction, project, dampedDependencyCascade, deriveContractModulationPlan, deriveContractStatus, trustDiscount, applyNegativeSupport, cumulativeFusion, applyNegativeEvidence, confidenceFromSL, detectTupleContradiction, evaluateTupleContradictionTransition, readOpinionFromRecord, parseEvidentialEvaluatorConfig, compareMetricValue, resolveComparisonResult, buildEvidentialRationale, parseMetricCheckerConfig, getEvaluatorInputRecord, pickFiniteNumber, buildComparisonRationale, parseReferenceCheckCounterConfig, parseTemporalDeadlineConfig, parseMarketIndexComparatorConfig, hasProjectedOpinionChanged, createInheritedContractRecord } from '@lucern/confidence';
+import { v } from 'convex/values';
 import '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
+import { checkProjectAccess, requireScopeWriteAccess } from '@lucern/access-control/access';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
 import { generateGlobalId } from '@lucern/contracts/ids';
 
-// src/epistemicBeliefs.helpers.ts
+// src/convex.ts
+var unsafeApi = unsafeConvexAnyApi(
+  "graph-primitives top-level module bundle lacks a committed Convex _generated/api surface"
+);
+var api = unsafeApi;
+componentsGeneric();
+var internal = unsafeApi;
+var internalMutation = internalMutationGeneric;
+var mutation = mutationGeneric;
+var query = queryGeneric;
+
+// src/debug.ts
+function isGraphPrimitiveDebugEnabled() {
+  const env = globalThis.process?.env;
+  return env?.LUCERN_COMPAT_FALLBACK_DEBUG === "1" || env?.LUCERN_GRAPH_DEBUG === "1";
+}
+function debugGraphPrimitiveFallback(message, context) {
+  if (!isGraphPrimitiveDebugEnabled()) {
+    return;
+  }
+  console.debug(message, context ?? {});
+}
 
 // src/beliefLifecycle.ts
 var BELIEF_STATUS_VALUES = [
@@ -130,24 +153,6 @@ function promoteBeliefStatusAfterScoring(status, opts) {
   }
   return status;
 }
-var api = anyApi;
-componentsGeneric();
-var internal = anyApi;
-var internalMutation = internalMutationGeneric;
-var mutation = mutationGeneric;
-var query = queryGeneric;
-
-// src/debug.ts
-function isGraphPrimitiveDebugEnabled() {
-  const env = globalThis.process?.env;
-  return env?.LUCERN_COMPAT_FALLBACK_DEBUG === "1" || env?.LUCERN_GRAPH_DEBUG === "1";
-}
-function debugGraphPrimitiveFallback(message, context) {
-  if (!isGraphPrimitiveDebugEnabled()) {
-    return;
-  }
-  console.debug(message, context ?? {});
-}
 var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
 async function resolveTopicNodeScopeOrNull(ctx, ref) {
   if (!ctx?.db || typeof ctx.db.query !== "function") {
@@ -182,13 +187,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") {
@@ -213,8 +220,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();
@@ -226,7 +234,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);
@@ -282,137 +290,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())
@@ -480,9 +466,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,
@@ -502,33 +489,11 @@ async function resolveNodeScopeForWorkspaceIsolation(ctx, node) {
   }
   return resolved;
 }
-
-// src/epistemicBeliefs.helpers.ts
 v.id("epistemicNodes");
 var DEFAULT_CONFIDENCE_POLICY = {
   scoringMode: "after_worktree",
   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 buildBeliefConfidenceRow(args) {
   return {
     beliefId: args.beliefId,
@@ -603,7 +568,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") {
@@ -614,7 +582,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(
@@ -631,23 +602,6 @@ async function getActiveConfidencePolicy(ctx) {
     return DEFAULT_CONFIDENCE_POLICY;
   }
 }
-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/edges/contains.ts
 var containsPropagationSpec = {
@@ -784,7 +738,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",
@@ -837,7 +791,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";
 }
@@ -910,6 +864,9 @@ var testsPropagationSpec = {
 };
 
 // src/edges/index.ts
+var canContinueTransitively2 = canContinueTransitively;
+var canTraverseHop2 = canTraverseHop;
+var isPropagationTraversalDirection2 = isPropagationTraversalDirection;
 var EDGE_PROPAGATION_SPECS = [
   supportsPropagationSpec,
   informsPropagationSpec,
@@ -926,16 +883,15 @@ function getEdgePropagationSpecs() {
   return EDGE_PROPAGATION_SPECS;
 }
 function getTraversalDirections(direction) {
-  if (isPropagationTraversalDirection(direction)) {
+  if (isPropagationTraversalDirection2(direction)) {
     return [direction];
   }
   return ["outgoing", "incoming"];
 }
 
 // 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 ?? {};
@@ -951,118 +907,354 @@ 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());
 }
 
 // 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.",
@@ -1073,59 +1265,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 requireProjectWriteAccess(
-    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,
@@ -1146,79 +1307,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,
@@ -1227,25 +1430,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,
@@ -1254,28 +1455,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;
+  }
+  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;
   }
-  if (Math.abs(derivedConfidence - previousConfidence) >= 0.15) {
+  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,
@@ -1292,13 +1504,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") {
@@ -1326,7 +1531,7 @@ 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
@@ -1335,16 +1540,20 @@ 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,
@@ -1374,9 +1583,7 @@ var ACTIVE_CONTRADICTION_STATUSES = /* @__PURE__ */ new Set([
   "investigating",
   "accepted_as_permanent"
 ]);
-var DEPENDENT_EDGE_TYPES = /* @__PURE__ */ new Set([
-  "depends_on"
-]);
+var DEPENDENT_EDGE_TYPES = /* @__PURE__ */ new Set(["depends_on"]);
 function classifyContradictionStatus(status) {
   if (typeof status !== "string") {
     return "active";
@@ -1389,6 +1596,99 @@ function classifyContradictionStatus(status) {
   }
   return "resolved";
 }
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readOptionalNumber2(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 readConvexId2(value) {
+  const normalized = readOptionalString2(value);
+  return normalized;
+}
+function readMetricNodeDoc(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const id = readConvexId2(value._id);
+  const nodeType = readOptionalString2(value.nodeType);
+  if (!(id && nodeType)) {
+    return null;
+  }
+  const node = { _id: id, nodeType };
+  const globalId = readOptionalString2(value.globalId);
+  if (globalId !== void 0) {
+    node.globalId = globalId;
+  }
+  if ("metadata" in value) {
+    node.metadata = value.metadata;
+  }
+  const status = readOptionalString2(value.status);
+  if (status !== void 0) {
+    node.status = status;
+  }
+  return node;
+}
+function readIncomingEdgeRow(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const fromNodeId = readOptionalString2(value.fromNodeId);
+  if (!fromNodeId) {
+    return null;
+  }
+  const edge = { fromNodeId };
+  const id = readConvexId2(value._id);
+  if (id !== void 0) {
+    edge._id = id;
+  }
+  const edgeType = readOptionalString2(value.edgeType);
+  if (edgeType !== void 0) {
+    edge.edgeType = edgeType;
+  }
+  const fromGlobalId = readOptionalString2(value.fromGlobalId);
+  if (fromGlobalId !== void 0) {
+    edge.fromGlobalId = fromGlobalId;
+  }
+  const fromUuid = readOptionalString2(value.fromUuid);
+  if (fromUuid !== void 0) {
+    edge.fromUuid = fromUuid;
+  }
+  const sourceGlobalId = readOptionalString2(value.sourceGlobalId);
+  if (sourceGlobalId !== void 0) {
+    edge.sourceGlobalId = sourceGlobalId;
+  }
+  const targetGlobalId = readOptionalString2(value.targetGlobalId);
+  if (targetGlobalId !== void 0) {
+    edge.targetGlobalId = targetGlobalId;
+  }
+  const toGlobalId = readOptionalString2(value.toGlobalId);
+  if (toGlobalId !== void 0) {
+    edge.toGlobalId = toGlobalId;
+  }
+  const toNodeId = readOptionalString2(value.toNodeId);
+  if (toNodeId !== void 0) {
+    edge.toNodeId = toNodeId;
+  }
+  const toUuid = readOptionalString2(value.toUuid);
+  if (toUuid !== void 0) {
+    edge.toUuid = toUuid;
+  }
+  const weight = readOptionalNumber2(value.weight);
+  if (weight !== void 0) {
+    edge.weight = weight;
+  }
+  for (const timestampField of ["_creationTime", "createdAt", "updatedAt"]) {
+    const timestamp = readOptionalNumber2(value[timestampField]);
+    if (timestamp !== void 0) {
+      edge[timestampField] = timestamp;
+    }
+  }
+  return edge;
+}
 function getEdgeTimestamp(edge) {
   if (typeof edge.updatedAt === "number") {
     return edge.updatedAt;
@@ -1401,22 +1701,86 @@ function getEdgeTimestamp(edge) {
   }
   return null;
 }
+async function collectNodeEndpointRefs(ctx, nodeId) {
+  const refs = /* @__PURE__ */ new Set([String(nodeId)]);
+  const node = readMetricNodeDoc(await ctx.db.get(nodeId));
+  if (node?.globalId) {
+    refs.add(node.globalId);
+  }
+  return [...refs];
+}
+async function collectIncomingEdgeRows(ctx, nodeId, edgeType) {
+  const refs = await collectNodeEndpointRefs(ctx, nodeId);
+  const seen = /* @__PURE__ */ new Set();
+  const edges = [];
+  for (const ref of refs) {
+    const rows = edgeType === void 0 ? await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", ref)).collect() : await ctx.db.query("epistemicEdges").withIndex(
+      "by_to_type",
+      (q) => q.eq("toNodeId", ref).eq("edgeType", edgeType)
+    ).collect();
+    for (const row of rows) {
+      const edge = readIncomingEdgeRow(row);
+      if (!edge) {
+        continue;
+      }
+      if (edgeType !== void 0 && edge.edgeType !== edgeType) {
+        continue;
+      }
+      const key = edge._id === void 0 ? `${edge.fromNodeId}->${edge.toNodeId ?? ref}:${edge.edgeType ?? ""}` : String(edge._id);
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      edges.push(edge);
+    }
+  }
+  return edges;
+}
+function sourceEndpointRefs(edge) {
+  return [
+    edge.fromNodeId,
+    edge.sourceGlobalId,
+    edge.fromGlobalId,
+    edge.fromUuid
+  ].filter((value) => value !== void 0);
+}
+async function resolveEndpointNode(ctx, refs) {
+  const candidates = refs.map((value) => value.trim()).filter(
+    (value, index, values) => value.length > 0 && values.indexOf(value) === index
+  );
+  for (const candidate of candidates) {
+    try {
+      const direct = readMetricNodeDoc(
+        await ctx.db.get(candidate)
+      );
+      if (direct) {
+        return direct;
+      }
+    } catch {
+    }
+    const byGlobalId = readMetricNodeDoc(
+      await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", candidate)).first()
+    );
+    if (byGlobalId) {
+      return byGlobalId;
+    }
+  }
+  return null;
+}
 async function getEvidenceLinks(ctx, beliefNodeId) {
-  const edges = await ctx.db.query("epistemicEdges").withIndex(
-    "by_to_type",
-    (q) => q.eq("toNodeId", beliefNodeId).eq("edgeType", "informs")
-  ).collect();
+  const edges = await collectIncomingEdgeRows(ctx, beliefNodeId, "informs");
   if (edges.length === 0) {
     return [];
   }
-  const nodes = await Promise.all(edges.map((edge) => ctx.db.get(edge.fromNodeId)));
-  return edges.flatMap((edge, index) => {
-    const node = nodes[index];
-    if (!node || node.nodeType !== "evidence" || node.status === "archived") {
-      return [];
+  const links = [];
+  for (const edge of edges) {
+    const node = await resolveEndpointNode(ctx, sourceEndpointRefs(edge));
+    if (node?.nodeType !== "evidence" || node.status === "archived") {
+      continue;
     }
-    return [{ edge, node }];
-  });
+    links.push({ edge, node });
+  }
+  return links;
 }
 function getEvidenceTags(node) {
   const metadata = node.metadata && typeof node.metadata === "object" ? node.metadata : null;
@@ -1442,7 +1806,8 @@ async function computeTaggedEvidenceCount(args) {
   };
 }
 async function computeContradictionCounts(ctx, beliefNodeId) {
-  const contradictions = await ctx.db.query("contradictions").withIndex("by_beliefId", (q) => q.eq("beliefId", beliefNodeId)).collect();
+  const contradictionDb = ctx.db;
+  const contradictions = await contradictionDb.query("contradictions").withIndex("by_beliefId", (q) => q.eq("beliefId", beliefNodeId)).collect();
   return contradictions.reduce(
     (counts, contradiction) => {
       const status = contradiction.resolutionStatus ?? contradiction.status ?? "unresolved";
@@ -1478,18 +1843,16 @@ async function computeEvidenceFreshness(ctx, beliefNodeId, now = Date.now()) {
   };
 }
 async function computeDependentBeliefCount(ctx, beliefNodeId) {
-  const incomingEdges = await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", beliefNodeId)).collect();
+  const incomingEdges = await collectIncomingEdgeRows(ctx, beliefNodeId);
   const dependencyEdges = incomingEdges.filter(
-    (edge) => DEPENDENT_EDGE_TYPES.has(edge.edgeType)
+    (edge) => edge.edgeType ? DEPENDENT_EDGE_TYPES.has(edge.edgeType) : false
   );
   if (dependencyEdges.length === 0) {
     return 0;
   }
-  const dependentBeliefs = await Promise.all(
-    dependencyEdges.map((edge) => ctx.db.get(edge.fromNodeId))
-  );
   const uniqueBeliefIds = /* @__PURE__ */ new Set();
-  for (const node of dependentBeliefs) {
+  for (const edge of dependencyEdges) {
+    const node = await resolveEndpointNode(ctx, sourceEndpointRefs(edge));
     if (node && node.nodeType === "belief" && node.status !== "archived" && node.status !== "deleted") {
       uniqueBeliefIds.add(String(node._id));
     }
@@ -1499,7 +1862,10 @@ async function computeDependentBeliefCount(ctx, beliefNodeId) {
 async function snapshotEvidentialMetric(args) {
   switch (args.metric) {
     case "evidence_count": {
-      const count = await computeEvidenceCountMetric(args.ctx, args.beliefNodeId);
+      const count = await computeEvidenceCountMetric(
+        args.ctx,
+        args.beliefNodeId
+      );
       return {
         metric: args.metric,
         value: count,
@@ -1507,7 +1873,10 @@ async function snapshotEvidentialMetric(args) {
       };
     }
     case "contradiction_status": {
-      const counts = await computeContradictionCounts(args.ctx, args.beliefNodeId);
+      const counts = await computeContradictionCounts(
+        args.ctx,
+        args.beliefNodeId
+      );
       return {
         metric: args.metric,
         value: counts.activeCount,
@@ -1527,7 +1896,10 @@ async function snapshotEvidentialMetric(args) {
       };
     }
     case "dependent_count": {
-      const count = await computeDependentBeliefCount(args.ctx, args.beliefNodeId);
+      const count = await computeDependentBeliefCount(
+        args.ctx,
+        args.beliefNodeId
+      );
       return {
         metric: args.metric,
         value: count,
@@ -1543,7 +1915,9 @@ async function snapshotEvidentialMetric(args) {
   }
 }
 async function evaluateBuiltInEvidentialContract(args) {
-  const config = parseEvidentialEvaluatorConfig(args.contract.condition.evaluatorConfig);
+  const config = parseEvidentialEvaluatorConfig(
+    args.contract.condition.evaluatorConfig
+  );
   const snapshot = await snapshotEvidentialMetric({
     ctx: args.ctx,
     beliefNodeId: args.belief._id,
@@ -1551,7 +1925,10 @@ async function evaluateBuiltInEvidentialContract(args) {
     now: args.now
   });
   const comparisonSatisfied = snapshot.value !== null && compareMetricValue(config.operator, snapshot.value, config.threshold);
-  const result = args.contract.direction === "falsifies" ? comparisonSatisfied ? "disconfirmed" : "confirmed" : comparisonSatisfied ? "confirmed" : "disconfirmed";
+  const result = resolveComparisonResult(
+    args.contract.direction,
+    comparisonSatisfied
+  );
   return {
     result,
     rationale: buildEvidentialRationale({
@@ -1571,57 +1948,66 @@ async function evaluateBuiltInEvidentialContract(args) {
     }
   };
 }
-async function evaluateMetricCheckerContract(args) {
-  const config = parseMetricCheckerConfig(args.contract.condition.evaluatorConfig);
-  const input = getEvaluatorInputRecord(args.inputData, "metricData");
-  const metric = typeof input.metric === "string" && input.metric.length > 0 ? input.metric : config.metric;
-  const observedValue = pickFiniteNumber(input, [
-    "observedValue",
-    "currentValue",
-    "metricValue",
-    "value"
-  ]) ?? config.observedValue ?? config.currentValue ?? config.metricValue ?? null;
-  if (observedValue === null) {
+function evaluateMetricCheckerContract(args) {
+  return Promise.resolve().then(() => {
+    const config = parseMetricCheckerConfig(
+      args.contract.condition.evaluatorConfig
+    );
+    const input = getEvaluatorInputRecord(args.inputData, "metricData");
+    const metric = typeof input.metric === "string" && input.metric.length > 0 ? input.metric : config.metric;
+    const observedValue = pickFiniteNumber(input, [
+      "observedValue",
+      "currentValue",
+      "metricValue",
+      "value"
+    ]) ?? config.observedValue ?? config.currentValue ?? config.metricValue ?? null;
+    if (observedValue === null) {
+      return {
+        result: "inconclusive",
+        rationale: `metric_checker is awaiting data for ${metric ?? args.contract.condition.expression}.`,
+        data: {
+          metric,
+          observedValue: null,
+          operator: config.operator,
+          threshold: config.threshold,
+          unit: config.unit
+        }
+      };
+    }
+    const comparisonSatisfied = compareMetricValue(
+      config.operator,
+      observedValue,
+      config.threshold
+    );
+    const result = resolveComparisonResult(
+      args.contract.direction,
+      comparisonSatisfied
+    );
     return {
-      result: "inconclusive",
-      rationale: `metric_checker is awaiting data for ${metric ?? args.contract.condition.expression}.`,
+      result,
+      rationale: buildComparisonRationale({
+        label: metric ?? "metric",
+        observedValue,
+        operator: config.operator,
+        threshold: config.threshold,
+        comparisonSatisfied,
+        result,
+        unit: config.unit
+      }),
       data: {
         metric,
-        observedValue: null,
+        observedValue,
         operator: config.operator,
         threshold: config.threshold,
         unit: config.unit
       }
     };
-  }
-  const comparisonSatisfied = compareMetricValue(
-    config.operator,
-    observedValue,
-    config.threshold
-  );
-  const result = resolveComparisonResult(args.contract.direction, comparisonSatisfied);
-  return {
-    result,
-    rationale: buildComparisonRationale({
-      label: metric ?? "metric",
-      observedValue,
-      operator: config.operator,
-      threshold: config.threshold,
-      comparisonSatisfied,
-      result,
-      unit: config.unit
-    }),
-    data: {
-      metric,
-      observedValue,
-      operator: config.operator,
-      threshold: config.threshold,
-      unit: config.unit
-    }
-  };
+  });
 }
 async function evaluateReferenceCheckCounterContract(args) {
-  const config = parseReferenceCheckCounterConfig(args.contract.condition.evaluatorConfig);
+  const config = parseReferenceCheckCounterConfig(
+    args.contract.condition.evaluatorConfig
+  );
   const input = getEvaluatorInputRecord(args.inputData, "referenceCheckData");
   const tag = typeof input.tag === "string" && input.tag.trim().length > 0 ? input.tag.trim() : config.tag;
   const snapshot = await computeTaggedEvidenceCount({
@@ -1635,7 +2021,10 @@ async function evaluateReferenceCheckCounterContract(args) {
     snapshot.count,
     config.threshold
   );
-  const result = resolveComparisonResult(args.contract.direction, comparisonSatisfied);
+  const result = resolveComparisonResult(
+    args.contract.direction,
+    comparisonSatisfied
+  );
   return {
     result,
     rationale: buildComparisonRationale({
@@ -1657,130 +2046,167 @@ async function evaluateReferenceCheckCounterContract(args) {
     }
   };
 }
-async function evaluateTemporalDeadlineContract(args) {
-  if (typeof args.contract.deadline !== "number" || !Number.isFinite(args.contract.deadline)) {
-    throw new Error(
-      "temporal_deadline requires contract.deadline to be set to a finite timestamp."
-    );
-  }
-  const config = parseTemporalDeadlineConfig(args.contract.condition.evaluatorConfig);
-  const input = getEvaluatorInputRecord(args.inputData, "temporalData");
-  const label = (typeof input.label === "string" && input.label.length > 0 ? input.label : config.label) ?? args.contract.title ?? args.contract.condition.expression;
-  const completedAt = pickFiniteNumber(input, [
-    "completedAt",
-    "observedAt",
-    "satisfiedAt",
-    "achievedAt"
-  ]) ?? config.completedAt ?? config.observedAt ?? config.satisfiedAt ?? config.achievedAt;
-  const completed = input.completed === true || config.completed === true || completedAt !== void 0;
-  if (completed) {
-    if (completedAt !== void 0 && completedAt > args.contract.deadline) {
-      return {
-        result: "expired",
-        rationale: `${label} completed at ${completedAt}, after deadline ${args.contract.deadline}.`,
-        data: {
-          label,
-          deadline: args.contract.deadline,
-          completed: true,
-          completedAt,
-          missedDeadline: true,
-          overdueByMs: completedAt - args.contract.deadline
-        }
-      };
-    }
-    const result = args.contract.direction === "falsifies" ? "disconfirmed" : "confirmed";
+function resolveCompletedTemporalDeadlineResult(args) {
+  const { completedAt, context, deadline, label } = args;
+  if (completedAt !== void 0 && completedAt > deadline) {
     return {
-      result,
-      rationale: `${label} completed before deadline ${args.contract.deadline}.`,
+      result: "expired",
+      rationale: `${label} completed at ${completedAt}, after deadline ${deadline}.`,
       data: {
         label,
-        deadline: args.contract.deadline,
+        deadline,
         completed: true,
-        completedAt: completedAt ?? null,
-        missedDeadline: false
+        completedAt,
+        missedDeadline: true,
+        overdueByMs: completedAt - deadline
       }
     };
   }
-  if (args.now > args.contract.deadline) {
+  const result = context.contract.direction === "falsifies" ? "disconfirmed" : "confirmed";
+  return {
+    result,
+    rationale: `${label} completed before deadline ${deadline}.`,
+    data: {
+      label,
+      deadline,
+      completed: true,
+      completedAt: completedAt ?? null,
+      missedDeadline: false
+    }
+  };
+}
+function resolveOpenTemporalDeadlineResult(args) {
+  const { context, deadline, label } = args;
+  if (context.now > deadline) {
     return {
       result: "expired",
-      rationale: `${label} missed deadline ${args.contract.deadline}; temporal contract expired.`,
+      rationale: `${label} missed deadline ${deadline}; temporal contract expired.`,
       data: {
         label,
-        deadline: args.contract.deadline,
+        deadline,
         completed: false,
-        overdueByMs: args.now - args.contract.deadline
+        overdueByMs: context.now - deadline
       }
     };
   }
   return {
     result: "inconclusive",
-    rationale: `${label} is still before deadline ${args.contract.deadline}; awaiting outcome.`,
+    rationale: `${label} is still before deadline ${deadline}; awaiting outcome.`,
     data: {
       label,
-      deadline: args.contract.deadline,
+      deadline,
       completed: false,
-      timeRemainingMs: args.contract.deadline - args.now
+      timeRemainingMs: deadline - context.now
     }
   };
 }
-async function evaluateMarketIndexComparatorContract(args) {
-  const config = parseMarketIndexComparatorConfig(args.contract.condition.evaluatorConfig);
-  const input = getEvaluatorInputRecord(args.inputData, "marketIndexData");
-  const subject = typeof input.subject === "string" && input.subject.length > 0 ? input.subject : config.subject;
-  const benchmark = typeof input.benchmark === "string" && input.benchmark.length > 0 ? input.benchmark : config.benchmark;
-  const subjectValue = pickFiniteNumber(input, ["subjectValue", "primaryValue", "leftValue"]) ?? config.subjectValue ?? config.primaryValue ?? null;
-  const benchmarkValue = pickFiniteNumber(input, ["benchmarkValue", "comparisonValue", "rightValue"]) ?? config.benchmarkValue ?? config.comparisonValue ?? null;
-  if (subjectValue === null || benchmarkValue === null) {
+function evaluateTemporalDeadlineContract(args) {
+  return Promise.resolve().then(() => {
+    if (typeof args.contract.deadline !== "number" || !Number.isFinite(args.contract.deadline)) {
+      throw new Error(
+        "temporal_deadline requires contract.deadline to be set to a finite timestamp."
+      );
+    }
+    const deadline = args.contract.deadline;
+    const config = parseTemporalDeadlineConfig(
+      args.contract.condition.evaluatorConfig
+    );
+    const input = getEvaluatorInputRecord(args.inputData, "temporalData");
+    const label = (typeof input.label === "string" && input.label.length > 0 ? input.label : config.label) ?? args.contract.title ?? args.contract.condition.expression;
+    const completedAt = pickFiniteNumber(input, [
+      "completedAt",
+      "observedAt",
+      "satisfiedAt",
+      "achievedAt"
+    ]) ?? config.completedAt ?? config.observedAt ?? config.satisfiedAt ?? config.achievedAt;
+    const completed = input.completed === true || config.completed === true || completedAt !== void 0;
+    if (completed) {
+      return resolveCompletedTemporalDeadlineResult({
+        completedAt,
+        context: args,
+        deadline,
+        label
+      });
+    }
+    return resolveOpenTemporalDeadlineResult({
+      context: args,
+      deadline,
+      label
+    });
+  });
+}
+function evaluateMarketIndexComparatorContract(args) {
+  return Promise.resolve().then(() => {
+    const config = parseMarketIndexComparatorConfig(
+      args.contract.condition.evaluatorConfig
+    );
+    const input = getEvaluatorInputRecord(args.inputData, "marketIndexData");
+    const subject = typeof input.subject === "string" && input.subject.length > 0 ? input.subject : config.subject;
+    const benchmark = typeof input.benchmark === "string" && input.benchmark.length > 0 ? input.benchmark : config.benchmark;
+    const subjectValue = pickFiniteNumber(input, ["subjectValue", "primaryValue", "leftValue"]) ?? config.subjectValue ?? config.primaryValue ?? null;
+    const benchmarkValue = pickFiniteNumber(input, [
+      "benchmarkValue",
+      "comparisonValue",
+      "rightValue"
+    ]) ?? config.benchmarkValue ?? config.comparisonValue ?? null;
+    if (subjectValue === null || benchmarkValue === null) {
+      return {
+        result: "inconclusive",
+        rationale: "market_index_comparator is awaiting both subject and benchmark values.",
+        data: {
+          subject,
+          subjectValue,
+          benchmark,
+          benchmarkValue,
+          operator: config.operator,
+          threshold: config.threshold
+        }
+      };
+    }
+    if (benchmarkValue === 0) {
+      throw new Error(
+        "market_index_comparator cannot compare against a zero benchmark value."
+      );
+    }
+    const differentialPercent = (subjectValue - benchmarkValue) / Math.abs(benchmarkValue) * 100;
+    const comparisonSatisfied = compareMetricValue(
+      config.operator,
+      differentialPercent,
+      config.threshold
+    );
+    const result = resolveComparisonResult(
+      args.contract.direction,
+      comparisonSatisfied
+    );
     return {
-      result: "inconclusive",
-      rationale: "market_index_comparator is awaiting both subject and benchmark values.",
+      result,
+      rationale: buildComparisonRationale({
+        label: `${subject ?? "subject"} vs ${benchmark ?? "benchmark"} differential`,
+        observedValue: differentialPercent,
+        operator: config.operator,
+        threshold: config.threshold,
+        comparisonSatisfied,
+        result,
+        unit: "%"
+      }),
       data: {
         subject,
         subjectValue,
         benchmark,
         benchmarkValue,
+        differentialPercent,
         operator: config.operator,
         threshold: config.threshold
       }
     };
-  }
-  if (benchmarkValue === 0) {
-    throw new Error(
-      "market_index_comparator cannot compare against a zero benchmark value."
-    );
-  }
-  const differentialPercent = (subjectValue - benchmarkValue) / Math.abs(benchmarkValue) * 100;
-  const comparisonSatisfied = compareMetricValue(
-    config.operator,
-    differentialPercent,
-    config.threshold
-  );
-  const result = resolveComparisonResult(args.contract.direction, comparisonSatisfied);
-  return {
-    result,
-    rationale: buildComparisonRationale({
-      label: `${subject ?? "subject"} vs ${benchmark ?? "benchmark"} differential`,
-      observedValue: differentialPercent,
-      operator: config.operator,
-      threshold: config.threshold,
-      comparisonSatisfied,
-      result,
-      unit: "%"
-    }),
-    data: {
-      subject,
-      subjectValue,
-      benchmark,
-      benchmarkValue,
-      differentialPercent,
-      operator: config.operator,
-      threshold: config.threshold
-    }
-  };
+  });
 }
 var METRIC_COMPARATOR_EVALUATOR_NAMES = {
-  evidentialAliases: /* @__PURE__ */ new Set(["evidential", "built_in_evidential", "builtin_evidential"]),
+  evidentialAliases: /* @__PURE__ */ new Set([
+    "evidential",
+    "built_in_evidential",
+    "builtin_evidential"
+  ]),
   metricChecker: "metric_checker",
   referenceCheckCounter: "reference_check_counter",
   temporalDeadline: "temporal_deadline",
@@ -1788,6 +2214,8 @@ var METRIC_COMPARATOR_EVALUATOR_NAMES = {
 };
 
 // src/evaluators/shared.ts
+var WINDOWS_PATH_SEPARATORS = /\\/g;
+var LEADING_DOT_SLASH = /^\.\//;
 function asArray(value) {
   return Array.isArray(value) ? value : [];
 }
@@ -1829,7 +2257,7 @@ function extractTextCandidates(value) {
   return Array.from(new Set(candidates));
 }
 function normalizeFilePath(value) {
-  return value.replace(/\\/g, "/").replace(/^\.\//, "");
+  return value.replace(WINDOWS_PATH_SEPARATORS, "/").replace(LEADING_DOT_SLASH, "");
 }
 function normalizeToolResultEnvelope(value) {
   const record = asRecord(value);
@@ -1883,7 +2311,7 @@ function somePatternMatches(filePath, patterns) {
   return patterns.some((pattern) => patternMatchesPath(filePath, pattern));
 }
 
-// src/evaluators/lintCheckerEvaluator.ts
+// src/evaluators/lint-checker-evaluator.ts
 function parseConfig(condition) {
   const record = asRecord(condition.evaluatorConfig);
   if (!record) {
@@ -1955,7 +2383,10 @@ var lintCheckerEvaluator = {
     }
     const envelope = normalizeToolResultEnvelope(args.resultData);
     const exitCode = asNumber(envelope.exitCode);
-    const matchedDiagnostics = getMatchedDiagnostics(args.contract, args.resultData);
+    const matchedDiagnostics = getMatchedDiagnostics(
+      args.contract,
+      args.resultData
+    );
     if (matchedDiagnostics.length === 0 && exitCode !== 0 && exitCode !== null) {
       return {
         result: "inconclusive",
@@ -1981,7 +2412,7 @@ var lintCheckerEvaluator = {
   }
 };
 
-// src/evaluators/sentryCheckerEvaluator.ts
+// src/evaluators/sentry-checker-evaluator.ts
 function parseConfig2(condition) {
   const record = asRecord(condition.evaluatorConfig);
   if (!record) {
@@ -2066,7 +2497,7 @@ var sentryCheckerEvaluator = {
   }
 };
 
-// src/evaluators/testRunnerEvaluator.ts
+// src/evaluators/test-runner-evaluator.ts
 function parseConfig3(condition) {
   const record = asRecord(condition.evaluatorConfig);
   if (!record) {
@@ -2212,7 +2643,7 @@ var testRunnerEvaluator = {
   }
 };
 
-// src/evaluators/tscCheckerEvaluator.ts
+// src/evaluators/tsc-checker-evaluator.ts
 function parseConfig4(condition) {
   const record = asRecord(condition.evaluatorConfig);
   if (!record) {
@@ -2297,7 +2728,10 @@ var tscCheckerEvaluator = {
     }
     const envelope = normalizeToolResultEnvelope(args.resultData);
     const exitCode = asNumber(envelope.exitCode);
-    const matchedDiagnostics = getMatchedDiagnostics2(args.contract, args.resultData);
+    const matchedDiagnostics = getMatchedDiagnostics2(
+      args.contract,
+      args.resultData
+    );
     if (matchedDiagnostics.length === 0 && exitCode !== 0 && exitCode !== null) {
       return {
         result: "inconclusive",
@@ -2346,6 +2780,18 @@ var BUILT_IN_REFERENCE_CHECK_COUNTER2 = METRIC_COMPARATOR_EVALUATOR_NAMES.refere
 var BUILT_IN_TEMPORAL_DEADLINE2 = METRIC_COMPARATOR_EVALUATOR_NAMES.temporalDeadline;
 var BUILT_IN_MARKET_INDEX_COMPARATOR2 = METRIC_COMPARATOR_EVALUATOR_NAMES.marketIndexComparator;
 var MAX_CONTRACT_EVALUATION_BATCH_SIZE = 50;
+function confidenceSeed(args) {
+  if (typeof args.currentConfidence === "number") {
+    return args.currentConfidence;
+  }
+  if (typeof args.beliefConfidence === "number") {
+    return args.beliefConfidence;
+  }
+  return 0.5;
+}
+function contractDocId(contract) {
+  return contract._id;
+}
 function clearEpistemicEvaluators() {
   evaluatorRegistry.clear();
   ensureBuiltInEvaluators();
@@ -2438,7 +2884,10 @@ async function executeContractEvaluation(args) {
       rationale: `No epistemic evaluator registered for "${args.contract.condition.evaluator}".`
     };
   }
-  const confidenceBefore = typeof args.currentConfidence === "number" ? args.currentConfidence : typeof args.belief.confidence === "number" ? args.belief.confidence : 0.5;
+  const confidenceBefore = confidenceSeed({
+    beliefConfidence: args.belief.confidence,
+    currentConfidence: args.currentConfidence
+  });
   const modulationPlan = deriveContractModulationPlan({
     currentConfidence: confidenceBefore,
     modulation: args.contract.modulation,
@@ -2478,16 +2927,16 @@ async function executeContractEvaluation(args) {
     modulationRationale: evaluation.rationale,
     topicId: args.contract.topicId
   });
-  const nextStatus = deriveContractStatus(evaluation.result, args.contract.status);
-  await args.ctx.db.patch(
-    args.contract._id,
-    {
-      status: nextStatus,
-      lastEvaluatedAt: args.now,
-      evaluationCount: (args.contract.evaluationCount ?? 0) + 1,
-      updatedAt: args.now
-    }
+  const nextStatus = deriveContractStatus(
+    evaluation.result,
+    args.contract.status
   );
+  await args.ctx.db.patch(contractDocId(args.contract), {
+    status: nextStatus,
+    lastEvaluatedAt: args.now,
+    evaluationCount: (args.contract.evaluationCount ?? 0) + 1,
+    updatedAt: args.now
+  });
   return {
     evaluationId,
     result: evaluation.result,
@@ -2572,7 +3021,8 @@ async function evaluateContractsForTriggerBatch(args) {
   };
 }
 async function loadContractsForBelief(args) {
-  return await args.ctx.db.query("epistemicContracts").withIndex("by_belief", (q) => q.eq("beliefNodeId", args.beliefNodeId)).collect();
+  const rows = await args.ctx.db.query("epistemicContracts").withIndex("by_belief", (q) => q.eq("beliefNodeId", args.beliefNodeId)).collect();
+  return rows;
 }
 async function loadContractsForTrigger(args) {
   const contracts = await loadContractsForBelief(args);
@@ -2607,6 +3057,24 @@ function resolveSchedulesForTrigger2(trigger) {
   }
   return /* @__PURE__ */ new Set(["event_driven"]);
 }
+function contractTables(ctx) {
+  return ctx.db;
+}
+function assertBeliefNode(value, message = "Belief not found.") {
+  if (!value || typeof value !== "object" || value.nodeType !== "belief") {
+    throw new Error(message);
+  }
+  return value;
+}
+function normalizeEngineeringTrigger(trigger) {
+  if (trigger === "manual") {
+    return "manual";
+  }
+  if (trigger === "evidence_added") {
+    return "evidence_added";
+  }
+  return trigger;
+}
 async function requireAuth(ctx) {
   const userId = await getCurrentUserId(ctx);
   if (!userId) {
@@ -2642,17 +3110,21 @@ async function requireTopicReadAccess(ctx, beliefs, userId) {
     projectIds.add(belief.projectId);
   }
   for (const projectId of projectIds) {
-    const hasAccess = await checkProjectAccess(ctx, projectId, userId);
+    const hasAccess = await checkProjectAccess(
+      ctx,
+      projectId,
+      userId
+    );
     if (!hasAccess) {
       throw new Error("Project access required.");
     }
   }
 }
 async function getContractByContractId(ctx, contractId) {
-  return await ctx.db.query("epistemicContracts").withIndex("by_contractId", (q) => q.eq("contractId", contractId)).first();
+  return await contractTables(ctx).query("epistemicContracts").withIndex("by_contractId", (q) => q.eq("contractId", contractId)).first();
 }
 async function getLatestEvaluation(ctx, contractId) {
-  const evaluations = await ctx.db.query("contractEvaluations").withIndex("by_contract_time", (q) => q.eq("contractId", contractId)).order("desc").take(1);
+  const evaluations = await contractTables(ctx).query("contractEvaluations").withIndex("by_contract_time", (q) => q.eq("contractId", contractId)).order("desc").take(1);
   return evaluations[0] ?? null;
 }
 var evaluateEvidenceCount = query({
@@ -2662,10 +3134,7 @@ var evaluateEvidenceCount = query({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const userId = await requireAuth(ctx);
-    const belief = await ctx.db.get(args.beliefNodeId);
-    if (!belief || belief.nodeType !== "belief") {
-      throw new Error("Belief not found.");
-    }
+    const belief = assertBeliefNode(await ctx.db.get(args.beliefNodeId));
     await requireBeliefProjectAccess(ctx, belief, userId);
     return await computeEvidenceCountMetric(ctx, args.beliefNodeId);
   }
@@ -2677,10 +3146,7 @@ var evaluateContradictionStatus = query({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const userId = await requireAuth(ctx);
-    const belief = await ctx.db.get(args.beliefNodeId);
-    if (!belief || belief.nodeType !== "belief") {
-      throw new Error("Belief not found.");
-    }
+    const belief = assertBeliefNode(await ctx.db.get(args.beliefNodeId));
     await requireBeliefProjectAccess(ctx, belief, userId);
     return await computeContradictionCounts(ctx, args.beliefNodeId);
   }
@@ -2692,10 +3158,7 @@ var evaluateEdgeFreshness = query({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const userId = await requireAuth(ctx);
-    const belief = await ctx.db.get(args.beliefNodeId);
-    if (!belief || belief.nodeType !== "belief") {
-      throw new Error("Belief not found.");
-    }
+    const belief = assertBeliefNode(await ctx.db.get(args.beliefNodeId));
     await requireBeliefProjectAccess(ctx, belief, userId);
     return await computeEvidenceFreshness(ctx, args.beliefNodeId);
   }
@@ -2707,10 +3170,7 @@ var evaluateDependentBeliefCount = query({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const userId = await requireAuth(ctx);
-    const belief = await ctx.db.get(args.beliefNodeId);
-    if (!belief || belief.nodeType !== "belief") {
-      throw new Error("Belief not found.");
-    }
+    const belief = assertBeliefNode(await ctx.db.get(args.beliefNodeId));
     await requireBeliefProjectAccess(ctx, belief, userId);
     return await computeDependentBeliefCount(ctx, args.beliefNodeId);
   }
@@ -2774,10 +3234,7 @@ var createEpistemicContract = mutation({
       ctx,
       args.authenticatedUserId
     );
-    const belief = await ctx.db.get(args.beliefNodeId);
-    if (!belief || belief.nodeType !== "belief") {
-      throw new Error("Belief not found.");
-    }
+    const belief = assertBeliefNode(await ctx.db.get(args.beliefNodeId));
     await requireBeliefProjectAccess(ctx, belief, userId);
     const now = Date.now();
     const contractId = generateGlobalId();
@@ -2832,10 +3289,10 @@ var evaluateContract = mutation({
     if (contract.status === "archived") {
       throw new Error("Archived contracts cannot be evaluated.");
     }
-    const belief = await ctx.db.get(contract.beliefNodeId);
-    if (!belief || belief.nodeType !== "belief") {
-      throw new Error("Belief not found for contract.");
-    }
+    const belief = assertBeliefNode(
+      await ctx.db.get(contract.beliefNodeId),
+      "Belief not found for contract."
+    );
     await requireBeliefProjectAccess(ctx, belief, userId);
     const evaluation = await executeContractEvaluation({
       ctx,
@@ -2873,14 +3330,11 @@ var evaluateEngineeringContracts = mutation({
       ctx,
       args.authenticatedUserId
     );
-    const belief = await ctx.db.get(args.beliefNodeId);
-    if (!belief || belief.nodeType !== "belief") {
-      throw new Error("Belief not found.");
-    }
+    const belief = assertBeliefNode(await ctx.db.get(args.beliefNodeId));
     await requireBeliefProjectAccess(ctx, belief, userId);
     const trigger = args.trigger ?? "event_driven";
     const allowedSchedules = resolveSchedulesForTrigger2(
-      trigger === "manual" ? "manual" : trigger === "evidence_added" ? "evidence_added" : trigger
+      normalizeEngineeringTrigger(trigger)
     );
     const payloadByEvaluator = /* @__PURE__ */ new Map([
       ["test_runner", args.testOutput],
@@ -2959,10 +3413,7 @@ var evaluateContractsForTrigger = mutation({
       ctx,
       args.authenticatedUserId
     );
-    const belief = await ctx.db.get(args.beliefNodeId);
-    if (!belief || belief.nodeType !== "belief") {
-      throw new Error("Belief not found.");
-    }
+    const belief = assertBeliefNode(await ctx.db.get(args.beliefNodeId));
     await requireBeliefProjectAccess(ctx, belief, userId);
     return await evaluateContractsForTriggerBatch({
       ctx,
@@ -2985,10 +3436,7 @@ var processContractEvaluationOverflow = internalMutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const belief = await ctx.db.get(args.beliefNodeId);
-    if (!belief || belief.nodeType !== "belief") {
-      throw new Error("Belief not found.");
-    }
+    const belief = assertBeliefNode(await ctx.db.get(args.beliefNodeId));
     return await evaluateContractsForTriggerBatch({
       ctx,
       belief,
@@ -3027,15 +3475,9 @@ var getContractStatus = query({
       const contract = await getContractByContractId(ctx, args.contractId);
       contracts = contract ? [contract] : [];
     } else if (args.beliefNodeId) {
-      const belief = await ctx.db.get(args.beliefNodeId);
-      if (!belief || belief.nodeType !== "belief") {
-        throw new Error("Belief not found.");
-      }
+      const belief = assertBeliefNode(await ctx.db.get(args.beliefNodeId));
       await requireBeliefProjectAccess(ctx, belief, userId);
-      contracts = await ctx.db.query("epistemicContracts").withIndex(
-        "by_belief",
-        (q) => q.eq("beliefNodeId", args.beliefNodeId)
-      ).collect();
+      contracts = await contractTables(ctx).query("epistemicContracts").withIndex("by_belief", (q) => q.eq("beliefNodeId", args.beliefNodeId)).collect();
     }
     if (contracts.length > 0) {
       const contractBeliefDocs = await Promise.all(
@@ -3043,15 +3485,14 @@ var getContractStatus = query({
       );
       const contractBeliefs = [];
       for (const belief of contractBeliefDocs) {
-        if (!belief || belief.nodeType !== "belief") {
-          throw new Error("Belief not found.");
-        }
-        contractBeliefs.push(belief);
+        contractBeliefs.push(assertBeliefNode(belief));
       }
       await requireTopicReadAccess(ctx, contractBeliefs, userId);
     }
     if (args.status) {
-      contracts = contracts.filter((contract) => contract.status === args.status);
+      contracts = contracts.filter(
+        (contract) => contract.status === args.status
+      );
     }
     const rows = await Promise.all(
       contracts.map(async (contract) => ({
@@ -3070,21 +3511,22 @@ var getContractCoverage = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const contracts = await ctx.db.query("epistemicContracts").withIndex("by_topic", (q) => q.eq("topicId", args.topicId)).collect();
+    const contracts = await contractTables(ctx).query("epistemicContracts").withIndex("by_topic", (q) => q.eq("topicId", args.topicId)).collect();
     const userId = await resolveAuthenticatedUserId(
       ctx,
       args.authenticatedUserId
     );
-    const beliefs = await ctx.db.query("epistemicNodes").withIndex(
+    const beliefRows = await ctx.db.query("epistemicNodes").withIndex(
       "by_topic_type",
       (q) => q.eq("topicId", args.topicId).eq("nodeType", "belief")
     ).collect();
+    const beliefs = beliefRows.map((belief) => assertBeliefNode(belief));
     await requireTopicReadAccess(ctx, beliefs, userId);
     const recentEvaluationLimit = Math.max(
       0,
       Math.min(args.recentEvaluationLimit ?? 5, 25)
     );
-    const recentEvaluations = recentEvaluationLimit === 0 ? [] : await ctx.db.query("contractEvaluations").withIndex("by_topic_time", (q) => q.eq("topicId", args.topicId)).order("desc").take(recentEvaluationLimit) ?? [];
+    const recentEvaluations = recentEvaluationLimit === 0 ? [] : await contractTables(ctx).query("contractEvaluations").withIndex("by_topic_time", (q) => q.eq("topicId", args.topicId)).order("desc").take(recentEvaluationLimit);
     const contractBeliefIds = new Set(
       contracts.filter((contract) => contract.status !== "archived").map((contract) => String(contract.beliefNodeId))
     );
@@ -3107,6 +3549,23 @@ function inheritContractsForFork(contracts, args) {
   return contracts.filter((contract) => contract.status !== "archived").map((contract) => createInheritedContractRecord(contract, args));
 }
 
-export { clearEpistemicEvaluators, createEpistemicContract, evaluateContract, evaluateContractsForTrigger, evaluateContradictionStatus, evaluateDependentBeliefCount, evaluateEdgeFreshness, evaluateEngineeringContracts, evaluateEvidenceCount, getContractCoverage, getContractStatus, getRegisteredEpistemicEvaluators, inheritContractsForFork, processContractEvaluationOverflow, registerEpistemicEvaluator };
+// src/epistemicContracts.ts
+var clearEpistemicEvaluators2 = clearEpistemicEvaluators;
+var getRegisteredEpistemicEvaluators2 = getRegisteredEpistemicEvaluators;
+var registerEpistemicEvaluator2 = registerEpistemicEvaluator;
+var createEpistemicContract2 = createEpistemicContract;
+var evaluateContract2 = evaluateContract;
+var evaluateContractsForTrigger2 = evaluateContractsForTrigger;
+var evaluateContradictionStatus2 = evaluateContradictionStatus;
+var evaluateDependentBeliefCount2 = evaluateDependentBeliefCount;
+var evaluateEdgeFreshness2 = evaluateEdgeFreshness;
+var evaluateEngineeringContracts2 = evaluateEngineeringContracts;
+var evaluateEvidenceCount2 = evaluateEvidenceCount;
+var getContractCoverage2 = getContractCoverage;
+var getContractStatus2 = getContractStatus;
+var inheritContractsForFork2 = inheritContractsForFork;
+var processContractEvaluationOverflow2 = processContractEvaluationOverflow;
+
+export { clearEpistemicEvaluators2 as clearEpistemicEvaluators, createEpistemicContract2 as createEpistemicContract, evaluateContract2 as evaluateContract, evaluateContractsForTrigger2 as evaluateContractsForTrigger, evaluateContradictionStatus2 as evaluateContradictionStatus, evaluateDependentBeliefCount2 as evaluateDependentBeliefCount, evaluateEdgeFreshness2 as evaluateEdgeFreshness, evaluateEngineeringContracts2 as evaluateEngineeringContracts, evaluateEvidenceCount2 as evaluateEvidenceCount, getContractCoverage2 as getContractCoverage, getContractStatus2 as getContractStatus, getRegisteredEpistemicEvaluators2 as getRegisteredEpistemicEvaluators, inheritContractsForFork2 as inheritContractsForFork, processContractEvaluationOverflow2 as processContractEvaluationOverflow, registerEpistemicEvaluator2 as registerEpistemicEvaluator };
 //# sourceMappingURL=epistemicContracts.js.map
 //# sourceMappingURL=epistemicContracts.js.map