@lucern/graph-primitives 1.0.28 → 1.0.30

package/dist/epistemicContracts.handlers.js

@@ -1,1105 +1,640 @@
-import { v, ConvexError } from 'convex/values';
-import { checkProjectAccess } from '@lucern/access-control/access';
+import { checkProjectAccess, requireScopeWriteAccess } from '@lucern/access-control/access';
 import { getCurrentUserId } from '@lucern/access-control/auth';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-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 { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, internalMutationGeneric, queryGeneric, mutationGeneric } from 'convex/server';
+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 '@lucern/access-control/audience';
-import { componentsGeneric, internalMutationGeneric, anyApi, queryGeneric, mutationGeneric } from 'convex/server';
+import { throwStructuredMutationError } from '@lucern/access-control/structuredMutationError';
 import '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
 import { generateGlobalId } from '@lucern/contracts/ids';
 
 // src/epistemicContracts.handlers.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/epistemicContracts.metrics.ts
-var ACTIVE_CONTRADICTION_STATUSES = /* @__PURE__ */ new Set([
-  "unresolved",
-  "investigating",
-  "accepted_as_permanent"
-]);
-var DEPENDENT_EDGE_TYPES = /* @__PURE__ */ new Set([
-  "depends_on"
-]);
-function classifyContradictionStatus(status) {
-  if (typeof status !== "string") {
-    return "active";
+// 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;
   }
-  if (ACTIVE_CONTRADICTION_STATUSES.has(status)) {
+  console.debug(message, context ?? {});
+}
+
+// src/beliefLifecycle.ts
+var BELIEF_STATUS_VALUES = [
+  "assumption",
+  "hypothesis",
+  "active",
+  "superseded",
+  "resolved_true",
+  "resolved_false"
+];
+function isBeliefLifecycleStatus(value) {
+  return typeof value === "string" && BELIEF_STATUS_VALUES.includes(value);
+}
+function normalizeLegacyBeliefStatus(value) {
+  if (isBeliefLifecycleStatus(value)) {
+    return value;
+  }
+  if (value === "belief" || value === "established" || value === "emerging") {
     return "active";
   }
-  if (status === "resolved_support" || status === "resolved_contra" || status === "belief_forked") {
-    return "resolved";
+  if (value === "fact" || value === "confirmed") {
+    return "resolved_true";
   }
-  return "resolved";
+  if (value === "disconfirmed" || value === "expired") {
+    return "resolved_false";
+  }
+  if (value === "deprecated") {
+    return "superseded";
+  }
+  return null;
 }
-function getEdgeTimestamp(edge) {
-  if (typeof edge.updatedAt === "number") {
-    return edge.updatedAt;
+function normalizeBeliefConfidence(confidence) {
+  if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
+    return null;
   }
-  if (typeof edge.createdAt === "number") {
-    return edge.createdAt;
+  if (confidence >= 0 && confidence <= 1) {
+    return confidence;
   }
-  if (typeof edge._creationTime === "number") {
-    return edge._creationTime;
+  if (confidence > 1 && confidence <= 100) {
+    return confidence / 100;
   }
   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();
-  if (edges.length === 0) {
-    return [];
+function isResolvedByConfidence(confidence) {
+  const normalized = normalizeBeliefConfidence(confidence);
+  if (normalized === null) {
+    return false;
   }
-  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 [];
-    }
-    return [{ edge, node }];
-  });
+  return normalized <= 0 || normalized >= 1;
 }
-function getEvidenceTags(node) {
-  const metadata = node.metadata && typeof node.metadata === "object" ? node.metadata : null;
-  const tags = metadata?.tags;
-  if (!Array.isArray(tags)) {
-    return [];
+function getPredictionMetaFromMetadata(metadata) {
+  return metadata?.predictionMeta;
+}
+function resolvedPredictionStatus(predictionMeta) {
+  if (!predictionMeta || typeof predictionMeta !== "object") {
+    return null;
   }
-  return tags.filter((tag) => typeof tag === "string");
+  const outcome = predictionMeta.outcome;
+  if (outcome === "confirmed") {
+    return "resolved_true";
+  }
+  if (outcome === "disconfirmed" || outcome === "expired") {
+    return "resolved_false";
+  }
+  return null;
 }
-async function computeEvidenceCountMetric(ctx, beliefNodeId) {
-  return (await getEvidenceLinks(ctx, beliefNodeId)).length;
+function shouldTreatBeliefAsResolved(opts) {
+  if (isResolvedByConfidence(opts.confidence)) {
+    const normalized = normalizeBeliefConfidence(opts.confidence);
+    return normalized === 0 ? "resolved_false" : "resolved_true";
+  }
+  const directPredictionStatus = resolvedPredictionStatus(opts.predictionMeta);
+  if (directPredictionStatus) {
+    return directPredictionStatus;
+  }
+  const metadataPredictionStatus = resolvedPredictionStatus(
+    getPredictionMetaFromMetadata(opts.metadata)
+  );
+  if (metadataPredictionStatus) {
+    return metadataPredictionStatus;
+  }
+  return null;
 }
-async function computeTaggedEvidenceCount(args) {
-  const expectedTag = args.caseSensitive ? args.tag : args.tag.toLowerCase();
-  const matchedEvidenceIds = (await getEvidenceLinks(args.ctx, args.beliefNodeId)).filter(
-    ({ node }) => getEvidenceTags(node).some(
-      (tag) => (args.caseSensitive ? tag : tag.toLowerCase()) === expectedTag
-    )
-  ).map(({ node }) => String(node._id));
-  return {
-    count: matchedEvidenceIds.length,
-    matchedEvidenceIds
-  };
+function resolveBeliefLifecycleStatus(opts) {
+  const resolvedStatus = shouldTreatBeliefAsResolved(opts);
+  if (resolvedStatus) {
+    return resolvedStatus;
+  }
+  const direct = opts.beliefStatus;
+  const normalizedDirect = normalizeLegacyBeliefStatus(direct);
+  if (normalizedDirect) {
+    const normalized = normalizeBeliefConfidence(opts.confidence);
+    if (normalized !== null && isPreValidationBeliefStatus(normalizedDirect)) {
+      return "active";
+    }
+    return normalizedDirect;
+  }
+  const metaStatus = opts.metadata?.beliefStatus;
+  const normalizedMetaStatus = normalizeLegacyBeliefStatus(metaStatus);
+  if (normalizedMetaStatus) {
+    const normalized = normalizeBeliefConfidence(opts.confidence);
+    if (normalized !== null && isPreValidationBeliefStatus(normalizedMetaStatus)) {
+      return "active";
+    }
+    return normalizedMetaStatus;
+  }
+  return "assumption";
 }
-async function computeContradictionCounts(ctx, beliefNodeId) {
-  const contradictions = await ctx.db.query("contradictions").withIndex("by_beliefId", (q) => q.eq("beliefId", beliefNodeId)).collect();
-  return contradictions.reduce(
-    (counts, contradiction) => {
-      const status = contradiction.resolutionStatus ?? contradiction.status ?? "unresolved";
-      if (classifyContradictionStatus(status) === "active") {
-        counts.activeCount += 1;
-      } else {
-        counts.resolvedCount += 1;
-      }
-      return counts;
-    },
-    { activeCount: 0, resolvedCount: 0 }
-  );
+function isPreValidationBeliefStatus(status) {
+  return status === "assumption" || status === "hypothesis";
 }
-async function computeEvidenceFreshness(ctx, beliefNodeId, now = Date.now()) {
-  const timestamps = (await getEvidenceLinks(ctx, beliefNodeId)).map(({ edge }) => getEdgeTimestamp(edge)).filter((value) => value !== null);
-  if (timestamps.length === 0) {
-    return {
-      newestAgeMs: null,
-      oldestAgeMs: null,
-      newestEdgeAt: null,
-      oldestEdgeAt: null,
-      edgeCount: 0
-    };
+function promoteBeliefStatusAfterScoring(status, opts) {
+  const resolvedStatus = shouldTreatBeliefAsResolved({ ...opts });
+  if (resolvedStatus) {
+    return resolvedStatus;
+  }
+  if (isPreValidationBeliefStatus(status)) {
+    return "active";
+  }
+  return status;
+}
+var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
+async function resolveTopicNodeScopeOrNull(ctx, ref) {
+  if (!ctx?.db || typeof ctx.db.query !== "function") {
+    return null;
+  }
+  let node = null;
+  try {
+    const byGlobalId = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", ref)).first();
+    if (byGlobalId && byGlobalId.nodeType === "topic") {
+      node = byGlobalId;
+    }
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] topic-node scope lookup by globalId failed",
+      { error, ref }
+    );
+  }
+  if (!node) {
+    return null;
+  }
+  const scopeKey = normalizeScopeValue(node.topicId) ?? normalizeScopeValue(node.globalId);
+  if (!scopeKey) {
+    return null;
   }
-  const newestEdgeAt = Math.max(...timestamps);
-  const oldestEdgeAt = Math.min(...timestamps);
   return {
-    newestAgeMs: Math.max(0, now - newestEdgeAt),
-    oldestAgeMs: Math.max(0, now - oldestEdgeAt),
-    newestEdgeAt,
-    oldestEdgeAt,
-    edgeCount: timestamps.length
+    topicId: scopeKey,
+    projectId: asMappedProjectId(node),
+    source: "topic_node"
   };
 }
-async function computeDependentBeliefCount(ctx, beliefNodeId) {
-  const incomingEdges = await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", beliefNodeId)).collect();
-  const dependencyEdges = incomingEdges.filter(
-    (edge) => DEPENDENT_EDGE_TYPES.has(edge.edgeType)
-  );
-  if (dependencyEdges.length === 0) {
-    return 0;
+function asMappedProjectId(topic) {
+  if (!topic) {
+    return;
   }
-  const dependentBeliefs = await Promise.all(
-    dependencyEdges.map((edge) => ctx.db.get(edge.fromNodeId))
+  const directLegacyProjectId = normalizeScopeValue(
+    topic[LEGACY_SCOPE_FIELD]
   );
-  const uniqueBeliefIds = /* @__PURE__ */ new Set();
-  for (const node of dependentBeliefs) {
-    if (node && node.nodeType === "belief" && node.status !== "archived" && node.status !== "deleted") {
-      uniqueBeliefIds.add(String(node._id));
-    }
+  if (directLegacyProjectId) {
+    return directLegacyProjectId;
   }
-  return uniqueBeliefIds.size;
+  const metadata = topic.metadata || {};
+  const candidate = metadata[LEGACY_SCOPE_FIELD] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
+  return typeof candidate === "string" ? normalizeScopeValue(candidate) : void 0;
 }
-async function snapshotEvidentialMetric(args) {
-  switch (args.metric) {
-    case "evidence_count": {
-      const count = await computeEvidenceCountMetric(args.ctx, args.beliefNodeId);
-      return {
-        metric: args.metric,
-        value: count,
-        data: { evidenceCount: count }
-      };
-    }
-    case "contradiction_status": {
-      const counts = await computeContradictionCounts(args.ctx, args.beliefNodeId);
-      return {
-        metric: args.metric,
-        value: counts.activeCount,
-        data: counts
-      };
-    }
-    case "edge_freshness": {
-      const freshness = await computeEvidenceFreshness(
-        args.ctx,
-        args.beliefNodeId,
-        args.now
-      );
-      return {
-        metric: args.metric,
-        value: freshness.newestAgeMs,
-        data: freshness
-      };
+function normalizeScopeValue(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function pickPrimaryTopic(candidates) {
+  return [...candidates].sort((a, b) => {
+    const depthA = a.depth ?? 9999;
+    const depthB = b.depth ?? 9999;
+    if (depthA !== depthB) {
+      return depthA - depthB;
     }
-    case "dependent_count": {
-      const count = await computeDependentBeliefCount(args.ctx, args.beliefNodeId);
-      return {
-        metric: args.metric,
-        value: count,
-        data: { dependentCount: count }
-      };
+    const createdA = a.createdAt ?? Number.MAX_SAFE_INTEGER;
+    const createdB = b.createdAt ?? Number.MAX_SAFE_INTEGER;
+    if (createdA !== createdB) {
+      return createdA - createdB;
     }
-    default:
-      return {
-        metric: args.metric,
-        value: null,
-        data: {}
-      };
+    return String(a.name || "").localeCompare(String(b.name || ""));
+  })[0];
+}
+async function findTopicsByScopeAlias(ctx, scopeId) {
+  const query2 = ctx.db.query("topics");
+  try {
+    return await query2.withIndex(
+      "by_graph_scope_project",
+      (q) => q.eq(LEGACY_SCOPE_FIELD, scopeId)
+    ).collect();
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve scope alias via index",
+      {
+        error,
+        scopeId
+      }
+    );
+    const topics = await query2.collect();
+    return topics.filter((topic) => {
+      const normalizedGlobalId = normalizeScopeValue(topic.globalId);
+      const mappedProjectId = asMappedProjectId(topic);
+      return String(topic._id) === scopeId || normalizedGlobalId === scopeId || mappedProjectId === scopeId;
+    });
   }
 }
-async function evaluateBuiltInEvidentialContract(args) {
-  const config = parseEvidentialEvaluatorConfig(args.contract.condition.evaluatorConfig);
-  const snapshot = await snapshotEvidentialMetric({
-    ctx: args.ctx,
-    beliefNodeId: args.belief._id,
-    metric: config.metric,
-    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";
-  return {
-    result,
-    rationale: buildEvidentialRationale({
-      config,
-      snapshot,
-      comparisonSatisfied,
-      result
-    }),
-    data: {
-      ...snapshot.data,
-      metric: config.metric,
-      observedValue: snapshot.value,
-      operator: config.operator,
-      threshold: config.threshold,
-      action: config.action ?? "append_sl_scoring",
-      actionParams: config.actionParams
-    }
-  };
+async function tryResolveHostTopicById(ctx, topicId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api.topics.get, {
+      id: topicId
+    }) ?? null;
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve topic by host query",
+      {
+        error,
+        topicId
+      }
+    );
+    return null;
+  }
 }
-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) {
-    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
+async function tryResolveHostTopicByLegacyScope(ctx, legacyScopeId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api.topics.getByLegacyScopeId, {
+      projectId: legacyScopeId
+    }) ?? null;
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve topic by legacy scope",
+      {
+        error,
+        legacyScopeId
       }
-    };
+    );
+    return null;
   }
-  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 resolveInheritedWorkspaceScope(ctx, topic) {
+  const MAX_DEPTH = 10;
+  let tenantId = normalizeScopeValue(topic.tenantId);
+  let workspaceId = normalizeScopeValue(topic.workspaceId);
+  if (tenantId && workspaceId) {
+    return { tenantId, workspaceId };
+  }
+  let current = topic;
+  for (let i = 0; i < MAX_DEPTH && current?.parentTopicId; i++) {
+    current = await ctx.db.get(current.parentTopicId);
+    if (!current) {
+      break;
     }
-  };
+    if (!tenantId) {
+      tenantId = normalizeScopeValue(current.tenantId);
+    }
+    if (!workspaceId) {
+      workspaceId = normalizeScopeValue(current.workspaceId);
+    }
+    if (tenantId && workspaceId) {
+      break;
+    }
+  }
+  return { tenantId, workspaceId };
 }
-async function evaluateReferenceCheckCounterContract(args) {
-  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({
-    ctx: args.ctx,
-    beliefNodeId: args.belief._id,
-    tag,
-    caseSensitive: config.caseSensitive
-  });
-  const comparisonSatisfied = compareMetricValue(
-    config.operator,
-    snapshot.count,
-    config.threshold
+async function resolveTopicProjectScope(ctx, args) {
+  if (args.topicId) {
+    return await resolveScopeFromTopicId(ctx, args.topicId);
+  }
+  if (args.projectId) {
+    return await resolveScopeFromLegacyProjectId(ctx, args.projectId);
+  }
+  throw new Error(
+    "Missing scope: provide topicId (preferred) or legacy projectId alias."
   );
-  const result = resolveComparisonResult(args.contract.direction, comparisonSatisfied);
-  return {
-    result,
-    rationale: buildComparisonRationale({
-      label: `reference checks tagged "${tag}"`,
-      observedValue: snapshot.count,
-      operator: config.operator,
-      threshold: config.threshold,
-      comparisonSatisfied,
-      result
-    }),
-    data: {
-      tag,
-      observedValue: snapshot.count,
-      referenceCheckCount: snapshot.count,
-      matchedEvidenceIds: snapshot.matchedEvidenceIds,
-      operator: config.operator,
-      threshold: config.threshold,
-      caseSensitive: config.caseSensitive ?? false
-    }
-  };
 }
-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."
-    );
+async function resolveScopeFromTopicId(ctx, topicId) {
+  const topic = await resolveTopicDocFromTopicId(ctx, topicId);
+  if (topic) {
+    return await buildTopicScope(ctx, topic, "topic");
   }
-  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";
-    return {
-      result,
-      rationale: `${label} completed before deadline ${args.contract.deadline}.`,
-      data: {
-        label,
-        deadline: args.contract.deadline,
-        completed: true,
-        completedAt: completedAt ?? null,
-        missedDeadline: false
-      }
-    };
+  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;
   }
-  if (args.now > args.contract.deadline) {
+  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 {
-      result: "expired",
-      rationale: `${label} missed deadline ${args.contract.deadline}; temporal contract expired.`,
-      data: {
-        label,
-        deadline: args.contract.deadline,
-        completed: false,
-        overdueByMs: args.now - args.contract.deadline
-      }
+      ...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 {
-    result: "inconclusive",
-    rationale: `${label} is still before deadline ${args.contract.deadline}; awaiting outcome.`,
-    data: {
-      label,
-      deadline: args.contract.deadline,
-      completed: false,
-      timeRemainingMs: args.contract.deadline - args.now
-    }
+    topicId: topic._id,
+    ...mapped || options.fallbackProjectId ? { projectId: mapped ?? options.fallbackProjectId } : {},
+    tenantId: inherited.tenantId,
+    workspaceId: inherited.workspaceId,
+    source
   };
 }
-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) {
-    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."
-    );
+({
+  projectId: v.optional(v.string()),
+  topicId: v.optional(v.string())
+});
+function normalizeScopeValue2(value) {
+  if (typeof value !== "string") {
+    return;
   }
-  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"]),
-  metricChecker: "metric_checker",
-  referenceCheckCounter: "reference_check_counter",
-  temporalDeadline: "temporal_deadline",
-  marketIndexComparator: "market_index_comparator"
-};
-
-// src/beliefLifecycle.ts
-var BELIEF_STATUS_VALUES = [
-  "assumption",
-  "hypothesis",
-  "active",
-  "superseded",
-  "resolved_true",
-  "resolved_false"
-];
-function isBeliefLifecycleStatus(value) {
-  return typeof value === "string" && BELIEF_STATUS_VALUES.includes(value);
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
 }
-function normalizeLegacyBeliefStatus(value) {
-  if (isBeliefLifecycleStatus(value)) {
-    return value;
-  }
-  if (value === "belief" || value === "established" || value === "emerging") {
-    return "active";
-  }
-  if (value === "fact" || value === "confirmed") {
-    return "resolved_true";
-  }
-  if (value === "disconfirmed" || value === "expired") {
-    return "resolved_false";
+function nodeMatchesWorkspaceReasoningScope(node, scope) {
+  if (!node) {
+    return false;
   }
-  if (value === "deprecated") {
-    return "superseded";
+  const scopeTenantId = normalizeScopeValue2(scope.tenantId);
+  const scopeWorkspaceId = normalizeScopeValue2(scope.workspaceId);
+  const nodeTenantId = normalizeScopeValue2(node.tenantId);
+  const nodeWorkspaceId = normalizeScopeValue2(node.workspaceId);
+  const epistemicLayer = typeof node.epistemicLayer === "string" ? node.epistemicLayer : void 0;
+  if (scopeTenantId && nodeTenantId && scopeTenantId !== nodeTenantId) {
+    return false;
   }
-  return null;
-}
-function normalizeBeliefConfidence(confidence) {
-  if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
-    return null;
+  if (epistemicLayer === "ontological" && nodeWorkspaceId === void 0) {
+    return true;
   }
-  if (confidence >= 0 && confidence <= 1) {
-    return confidence;
+  if (!scopeWorkspaceId && node.publicationStatus === "published") {
+    return true;
   }
-  if (confidence > 1 && confidence <= 100) {
-    return confidence / 100;
+  if (!scopeWorkspaceId) {
+    return nodeWorkspaceId === void 0;
   }
-  return null;
+  return scopeWorkspaceId === nodeWorkspaceId;
 }
-function isResolvedByConfidence(confidence) {
-  const normalized = normalizeBeliefConfidence(confidence);
-  if (normalized === null) {
+function edgeMatchesWorkspaceReasoningScope(edge, scope) {
+  if (!edge) {
     return false;
   }
-  return normalized <= 0 || normalized >= 1;
-}
-function getPredictionMetaFromMetadata(metadata) {
-  return metadata?.predictionMeta;
-}
-function resolvedPredictionStatus(predictionMeta) {
-  if (!predictionMeta || typeof predictionMeta !== "object") {
-    return null;
-  }
-  const outcome = predictionMeta.outcome;
-  if (outcome === "confirmed") {
-    return "resolved_true";
+  const scopeTenantId = normalizeScopeValue2(scope.tenantId);
+  const scopeWorkspaceId = normalizeScopeValue2(scope.workspaceId);
+  const edgeTenantId = normalizeScopeValue2(edge.tenantId);
+  const edgeWorkspaceId = normalizeScopeValue2(edge.workspaceId);
+  if (scopeTenantId && edgeTenantId && scopeTenantId !== edgeTenantId) {
+    return false;
   }
-  if (outcome === "disconfirmed" || outcome === "expired") {
-    return "resolved_false";
+  if (!scopeWorkspaceId) {
+    return edgeWorkspaceId === void 0;
   }
-  return null;
+  return scopeWorkspaceId === edgeWorkspaceId;
 }
-function shouldTreatBeliefAsResolved(opts) {
-  if (isResolvedByConfidence(opts.confidence)) {
-    const normalized = normalizeBeliefConfidence(opts.confidence);
-    return normalized === 0 ? "resolved_false" : "resolved_true";
-  }
-  const directPredictionStatus = resolvedPredictionStatus(opts.predictionMeta);
-  if (directPredictionStatus) {
-    return directPredictionStatus;
+async function resolveNodeScopeForWorkspaceIsolation(ctx, node) {
+  const epistemicLayer = typeof node?.epistemicLayer === "string" ? node.epistemicLayer : void 0;
+  const resolved = {
+    tenantId: normalizeScopeValue2(node?.tenantId),
+    workspaceId: normalizeScopeValue2(node?.workspaceId),
+    epistemicLayer,
+    nodeType: typeof node?.nodeType === "string" ? node.nodeType : void 0
+  };
+  if (!node) {
+    return resolved;
   }
-  const metadataPredictionStatus = resolvedPredictionStatus(
-    getPredictionMetaFromMetadata(opts.metadata)
-  );
-  if (metadataPredictionStatus) {
-    return metadataPredictionStatus;
+  if (resolved.epistemicLayer === "ontological") {
+    return resolved;
   }
-  return null;
-}
-function resolveBeliefLifecycleStatus(opts) {
-  const resolvedStatus = shouldTreatBeliefAsResolved(opts);
-  if (resolvedStatus) {
-    return resolvedStatus;
+  if (resolved.tenantId || resolved.workspaceId) {
+    return resolved;
   }
-  const direct = opts.beliefStatus;
-  const normalizedDirect = normalizeLegacyBeliefStatus(direct);
-  if (normalizedDirect) {
-    const normalized = normalizeBeliefConfidence(opts.confidence);
-    if (normalized !== null && isPreValidationBeliefStatus(normalizedDirect)) {
-      return "active";
-    }
-    return normalizedDirect;
+  const topicId = normalizeScopeValue2(node.topicId);
+  if (topicId) {
+    const topicScope = await resolveTopicProjectScope(ctx, {
+      topicId
+    });
+    return {
+      ...resolved,
+      tenantId: topicScope.tenantId,
+      workspaceId: topicScope.workspaceId
+    };
   }
-  const metaStatus = opts.metadata?.beliefStatus;
-  const normalizedMetaStatus = normalizeLegacyBeliefStatus(metaStatus);
-  if (normalizedMetaStatus) {
-    const normalized = normalizeBeliefConfidence(opts.confidence);
-    if (normalized !== null && isPreValidationBeliefStatus(normalizedMetaStatus)) {
-      return "active";
-    }
-    return normalizedMetaStatus;
+  if (node.projectId) {
+    const topicScope = await resolveTopicProjectScope(ctx, {
+      projectId: String(node.projectId)
+    });
+    return {
+      ...resolved,
+      tenantId: topicScope.tenantId,
+      workspaceId: topicScope.workspaceId
+    };
   }
-  return "assumption";
+  return resolved;
 }
-function isPreValidationBeliefStatus(status) {
-  return status === "assumption" || status === "hypothesis";
+v.id("epistemicNodes");
+var DEFAULT_CONFIDENCE_POLICY = {
+  scoringMode: "after_worktree",
+  tupleContradiction: normalizeTupleContradictionPolicy()
+};
+function buildBeliefConfidenceRow(args) {
+  return {
+    beliefId: args.beliefId,
+    confidence: confidenceFromSL(
+      args.belief,
+      args.disbelief,
+      args.uncertainty,
+      args.baseRate
+    ),
+    belief: args.belief,
+    disbelief: args.disbelief,
+    uncertainty: args.uncertainty,
+    baseRate: args.baseRate,
+    slOperator: args.slOperator ?? "prior_seed",
+    trigger: args.trigger,
+    ...args.rationale ? { rationale: args.rationale } : {},
+    assessedBy: args.assessedBy,
+    assessedAt: args.assessedAt,
+    ...args.triggeringEvidenceId ? {
+      triggeringEvidenceId: args.triggeringEvidenceId,
+      triggeringEvidenceIds: [String(args.triggeringEvidenceId)]
+    } : {},
+    ...args.triggeringContradictionId ? {
+      triggeringContradictionId: args.triggeringContradictionId
+    } : {},
+    ...args.triggeringWorktreeId ? { triggeringWorktreeId: args.triggeringWorktreeId } : {}
+  };
 }
-function promoteBeliefStatusAfterScoring(status, opts) {
-  const resolvedStatus = shouldTreatBeliefAsResolved({ ...opts });
-  if (resolvedStatus) {
-    return resolvedStatus;
-  }
-  if (isPreValidationBeliefStatus(status)) {
-    return "active";
+function readTupleContradictedFlag(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function readBeliefOpinionSnapshot(node, metadata) {
+  try {
+    return readOpinionFromRecord({
+      ...metadata,
+      opinion_b: node.opinion_b,
+      opinion_d: node.opinion_d,
+      opinion_u: node.opinion_u,
+      opinion_a: node.opinion_a
+    });
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[epistemicBeliefs] Failed to read belief opinion snapshot",
+      {
+        error,
+        beliefId: node._id
+      }
+    );
+    return mkOpinion(0, 0, 1, 0.5);
   }
-  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") {
-    return null;
-  }
-  let node = null;
-  try {
-    const byGlobalId = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", ref)).first();
-    if (byGlobalId && byGlobalId.nodeType === "topic") {
-      node = byGlobalId;
-    }
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicScope] topic-node scope lookup by globalId failed",
-      { error, ref }
-    );
-  }
-  if (!node) {
-    return null;
+function deriveTupleContradictionSeverity(node) {
+  const metadata = node.metadata || {};
+  const criticality = typeof metadata.criticality === "string" ? metadata.criticality : void 0;
+  if (criticality === "blocking") {
+    return "critical";
   }
-  const scopeKey = normalizeScopeValue(node.topicId) ?? normalizeScopeValue(node.globalId);
-  if (!scopeKey) {
-    return null;
+  if (criticality === "supporting") {
+    return "minor";
   }
-  return {
-    topicId: scopeKey,
-    projectId: asMappedProjectId(node),
-    source: "topic_node"
-  };
+  return "significant";
 }
-function asMappedProjectId(topic) {
-  if (!topic) {
-    return;
-  }
-  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;
+function formatTupleContradictionDescription(args) {
+  return `Tuple-space contradiction detected: b=${args.opinion.b.toFixed(2)} > ${args.policy.beliefThreshold.toFixed(2)} and d=${args.opinion.d.toFixed(2)} > ${args.policy.disbeliefThreshold.toFixed(2)}.`;
 }
-function normalizeScopeValue(value) {
-  if (typeof value !== "string") {
-    return;
-  }
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : void 0;
+function resolveBeliefStatus(node, metadata) {
+  return resolveBeliefLifecycleStatus({
+    beliefStatus: node.beliefStatus,
+    confidence: node.confidence,
+    predictionMeta: node.predictionMeta,
+    metadata
+  });
 }
-function pickPrimaryTopic(candidates) {
-  return [...candidates].sort((a, b) => {
-    const depthA = a.depth ?? 9999;
-    const depthB = b.depth ?? 9999;
-    if (depthA !== depthB) {
-      return depthA - depthB;
-    }
-    const createdA = a.createdAt ?? Number.MAX_SAFE_INTEGER;
-    const createdB = b.createdAt ?? Number.MAX_SAFE_INTEGER;
-    if (createdA !== createdB) {
-      return createdA - createdB;
+async function hasCompletedWorktreeForBelief(ctx, beliefNodeId) {
+  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") {
+      return true;
     }
-    return String(a.name || "").localeCompare(String(b.name || ""));
-  })[0];
-}
-async function findTopicsByScopeAlias(ctx, scopeId) {
-  try {
-    return await ctx.db.query("topics").withIndex(
-      "by_graph_scope_project",
-      (q) => q.eq(LEGACY_SCOPE_FIELD, scopeId)
-    ).collect();
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicScope] Failed to resolve scope alias via index",
-      {
-        error,
-        scopeId
-      }
-    );
-    const topics = await ctx.db.query("topics").collect();
-    return topics.filter((topic) => {
-      const normalizedGlobalId = normalizeScopeValue(topic.globalId);
-      const mappedProjectId = asMappedProjectId(topic);
-      return String(topic._id) === scopeId || normalizedGlobalId === scopeId || mappedProjectId === scopeId;
-    });
   }
+  return false;
 }
-async function tryResolveHostTopicById(ctx, topicId) {
-  if (typeof ctx.runQuery !== "function") {
-    return null;
-  }
+async function getActiveConfidencePolicy(ctx) {
   try {
-    return await ctx.runQuery(api.topics.get, {
-      id: topicId
-    }) ?? null;
+    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(
+        activeConfig?.tupleContradictionPolicy
+      )
+    };
   } catch (error) {
     debugGraphPrimitiveFallback(
-      "[topicScope] Failed to resolve topic by host query",
+      "[epistemicBeliefs] Failed to load active confidence policy",
       {
-        error,
-        topicId
+        error
       }
     );
-    return null;
+    return DEFAULT_CONFIDENCE_POLICY;
   }
 }
-async function tryResolveHostTopicByLegacyScope(ctx, legacyScopeId) {
-  if (typeof ctx.runQuery !== "function") {
-    return null;
-  }
-  try {
-    return await ctx.runQuery(api.topics.getByLegacyScopeId, {
-      projectId: legacyScopeId
-    }) ?? null;
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicScope] Failed to resolve topic by legacy scope",
-      {
-        error,
-        legacyScopeId
-      }
-    );
-    return null;
-  }
+
+// src/edges/contains.ts
+var containsPropagationSpec = {
+  edgeType: "contains",
+  direction: "outgoing",
+  transitivity: "none",
+  damping: 1,
+  maxHops: 1,
+  operator: () => null,
+  description: "Structural containment only. Traversed for explicit semantics, but it never propagates opinions."
+};
+function readEdgeMetadata(edge) {
+  return {
+    constraint: edge.constraint ?? void 0,
+    normalization: edge.normalization ?? void 0,
+    propagation: edge.propagation ?? void 0,
+    conditionalA: edge.conditionalA ?? void 0,
+    conditionalNotA: edge.conditionalNotA ?? void 0
+  };
 }
-async function resolveInheritedWorkspaceScope(ctx, topic) {
-  const MAX_DEPTH = 10;
-  let tenantId = normalizeScopeValue(topic.tenantId);
-  let workspaceId = normalizeScopeValue(topic.workspaceId);
-  if (tenantId && workspaceId) {
-    return { tenantId, workspaceId };
-  }
-  let current = topic;
-  for (let i = 0; i < MAX_DEPTH && current?.parentTopicId; i++) {
-    current = await ctx.db.get(current.parentTopicId);
-    if (!current) break;
-    if (!tenantId) {
-      tenantId = normalizeScopeValue(current.tenantId);
-    }
-    if (!workspaceId) {
-      workspaceId = normalizeScopeValue(current.workspaceId);
-    }
-    if (tenantId && workspaceId) break;
+function applyPerHopDamping(sourceOpinion, damping) {
+  if (damping >= 1) {
+    return sourceOpinion;
   }
-  return { tenantId, workspaceId };
+  return trustDiscount(sourceOpinion, Math.max(0, damping));
 }
-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"
-    };
-  }
-  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.`
-    );
-  }
-  throw new Error(
-    "Missing scope: provide topicId (preferred) or legacy projectId alias."
-  );
-}
-({
-  projectId: v.optional(v.string()),
-  topicId: v.optional(v.string())
-});
-function normalizeScopeValue2(value) {
-  if (typeof value !== "string") {
-    return;
-  }
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : void 0;
-}
-function nodeMatchesWorkspaceReasoningScope(node, scope) {
-  if (!node) {
-    return false;
-  }
-  const scopeTenantId = normalizeScopeValue2(scope.tenantId);
-  const scopeWorkspaceId = normalizeScopeValue2(scope.workspaceId);
-  const nodeTenantId = normalizeScopeValue2(node.tenantId);
-  const nodeWorkspaceId = normalizeScopeValue2(node.workspaceId);
-  const epistemicLayer = typeof node.epistemicLayer === "string" ? node.epistemicLayer : void 0;
-  if (scopeTenantId && nodeTenantId && scopeTenantId !== nodeTenantId) {
-    return false;
-  }
-  if (epistemicLayer === "ontological" && nodeWorkspaceId === void 0) {
-    return true;
-  }
-  if (!scopeWorkspaceId && node.publicationStatus === "published") {
-    return true;
-  }
-  if (!scopeWorkspaceId) {
-    return nodeWorkspaceId === void 0;
-  }
-  return scopeWorkspaceId === nodeWorkspaceId;
-}
-function edgeMatchesWorkspaceReasoningScope(edge, scope) {
-  if (!edge) {
-    return false;
-  }
-  const scopeTenantId = normalizeScopeValue2(scope.tenantId);
-  const scopeWorkspaceId = normalizeScopeValue2(scope.workspaceId);
-  const edgeTenantId = normalizeScopeValue2(edge.tenantId);
-  const edgeWorkspaceId = normalizeScopeValue2(edge.workspaceId);
-  if (scopeTenantId && edgeTenantId && scopeTenantId !== edgeTenantId) {
-    return false;
-  }
-  if (!scopeWorkspaceId) {
-    return edgeWorkspaceId === void 0;
-  }
-  return scopeWorkspaceId === edgeWorkspaceId;
-}
-async function resolveNodeScopeForWorkspaceIsolation(ctx, node) {
-  const epistemicLayer = typeof node?.epistemicLayer === "string" ? node.epistemicLayer : void 0;
-  const resolved = {
-    tenantId: normalizeScopeValue2(node?.tenantId),
-    workspaceId: normalizeScopeValue2(node?.workspaceId),
-    epistemicLayer,
-    nodeType: typeof node?.nodeType === "string" ? node.nodeType : void 0
-  };
-  if (!node) {
-    return resolved;
-  }
-  if (resolved.epistemicLayer === "ontological") {
-    return resolved;
-  }
-  if (resolved.tenantId || resolved.workspaceId) {
-    return resolved;
-  }
-  if (node.topicId) {
-    const topicScope = await resolveTopicProjectScope(ctx, {
-      topicId: node.topicId
-    });
-    return {
-      ...resolved,
-      tenantId: topicScope.tenantId,
-      workspaceId: topicScope.workspaceId
-    };
-  }
-  if (node.projectId) {
-    const topicScope = await resolveTopicProjectScope(ctx, {
-      projectId: String(node.projectId)
-    });
-    return {
-      ...resolved,
-      tenantId: topicScope.tenantId,
-      workspaceId: topicScope.workspaceId
-    };
-  }
-  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,
-    confidence: confidenceFromSL(
-      args.belief,
-      args.disbelief,
-      args.uncertainty,
-      args.baseRate
-    ),
-    belief: args.belief,
-    disbelief: args.disbelief,
-    uncertainty: args.uncertainty,
-    baseRate: args.baseRate,
-    slOperator: args.slOperator ?? "prior_seed",
-    trigger: args.trigger,
-    ...args.rationale ? { rationale: args.rationale } : {},
-    assessedBy: args.assessedBy,
-    assessedAt: args.assessedAt,
-    ...args.triggeringEvidenceId ? {
-      triggeringEvidenceId: args.triggeringEvidenceId,
-      triggeringEvidenceIds: [String(args.triggeringEvidenceId)]
-    } : {},
-    ...args.triggeringContradictionId ? {
-      triggeringContradictionId: args.triggeringContradictionId
-    } : {},
-    ...args.triggeringWorktreeId ? { triggeringWorktreeId: args.triggeringWorktreeId } : {}
-  };
-}
-function readTupleContradictedFlag(value) {
-  return typeof value === "boolean" ? value : void 0;
-}
-function readBeliefOpinionSnapshot(node, metadata) {
-  try {
-    return readOpinionFromRecord({
-      ...metadata,
-      opinion_b: node.opinion_b,
-      opinion_d: node.opinion_d,
-      opinion_u: node.opinion_u,
-      opinion_a: node.opinion_a
-    });
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[epistemicBeliefs] Failed to read belief opinion snapshot",
-      {
-        error,
-        beliefId: node._id
-      }
-    );
-    return mkOpinion(0, 0, 1, 0.5);
-  }
-}
-function deriveTupleContradictionSeverity(node) {
-  const metadata = node.metadata || {};
-  const criticality = typeof metadata.criticality === "string" ? metadata.criticality : void 0;
-  if (criticality === "blocking") {
-    return "critical";
-  }
-  if (criticality === "supporting") {
-    return "minor";
-  }
-  return "significant";
-}
-function formatTupleContradictionDescription(args) {
-  return `Tuple-space contradiction detected: b=${args.opinion.b.toFixed(2)} > ${args.policy.beliefThreshold.toFixed(2)} and d=${args.opinion.d.toFixed(2)} > ${args.policy.disbeliefThreshold.toFixed(2)}.`;
-}
-function resolveBeliefStatus(node, metadata) {
-  return resolveBeliefLifecycleStatus({
-    beliefStatus: node.beliefStatus,
-    confidence: node.confidence,
-    predictionMeta: node.predictionMeta,
-    metadata
-  });
-}
-async function hasCompletedWorktreeForBelief(ctx, beliefNodeId) {
-  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") {
-      return true;
-    }
-  }
-  return false;
-}
-async function getActiveConfidencePolicy(ctx) {
-  try {
-    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(
-        activeConfig?.tupleContradictionPolicy
-      )
-    };
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[epistemicBeliefs] Failed to load active confidence policy",
-      {
-        error
-      }
-    );
-    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 = {
-  edgeType: "contains",
-  direction: "outgoing",
-  transitivity: "none",
-  damping: 1,
-  maxHops: 1,
-  operator: () => null,
-  description: "Structural containment only. Traversed for explicit semantics, but it never propagates opinions."
-};
-function readEdgeMetadata(edge) {
-  return {
-    constraint: edge.constraint ?? void 0,
-    normalization: edge.normalization ?? void 0,
-    propagation: edge.propagation ?? void 0,
-    conditionalA: edge.conditionalA ?? void 0,
-    conditionalNotA: edge.conditionalNotA ?? void 0
-  };
-}
-function applyPerHopDamping(sourceOpinion, damping) {
-  if (damping >= 1) {
-    return sourceOpinion;
-  }
-  return trustDiscount(sourceOpinion, Math.max(0, damping));
-}
-function annotateRationale(result, spec, hop) {
-  return {
-    ...result,
-    rationale: `hop=${hop} edge=${spec.edgeType} damping=${spec.damping.toFixed(
-      2
-    )} :: ${result.rationale}`
-  };
+function annotateRationale(result, spec, hop) {
+  return {
+    ...result,
+    rationale: `hop=${hop} edge=${spec.edgeType} damping=${spec.damping.toFixed(
+      2
+    )} :: ${result.rationale}`
+  };
 }
 function propagatePositiveSupport(sourceOpinion, targetOpinion, edgeWeight) {
   const discounted = trustDiscount(sourceOpinion, Math.abs(edgeWeight));
@@ -1203,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",
@@ -1256,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";
 }
@@ -1329,6 +864,9 @@ var testsPropagationSpec = {
 };
 
 // src/edges/index.ts
+var canContinueTransitively2 = canContinueTransitively;
+var canTraverseHop2 = canTraverseHop;
+var isPropagationTraversalDirection2 = isPropagationTraversalDirection;
 var EDGE_PROPAGATION_SPECS = [
   supportsPropagationSpec,
   informsPropagationSpec,
@@ -1345,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 ?? {};
@@ -1370,118 +907,354 @@ function readNodeOpinion(node) {
     return mkOpinion(0, 0, 1, 0.5);
   }
 }
-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 queue = [
-    {
-      nodeId: args.sourceNodeId,
-      opinion: args.sourceOpinion,
-      hop: 0,
-      visitedNodeIds: /* @__PURE__ */ new Set([String(args.sourceNodeId)])
-    }
-  ];
-  const loadNode = async (nodeId) => {
-    const cacheKey = String(nodeId);
-    if (!nodeCache.has(cacheKey)) {
-      nodeCache.set(cacheKey, await args.getNode(nodeId));
-    }
-    return nodeCache.get(cacheKey) ?? null;
+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)])
   };
-  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)
-              ])
-            });
-          }
-        }
-      }
+}
+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);
   }
-  return Array.from(dispatchesByTargetId.values()).sort((left, right) => {
+}
+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 = [
+    buildInitialState(args.sourceNodeId, args.sourceOpinion)
+  ];
+  while (queue.length > 0) {
+    const state = queue.shift();
+    if (!state) {
+      continue;
+    }
+    await processQueuedState(state, queue, scope);
+  }
+  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.",
@@ -1492,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,
@@ -1565,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,
@@ -1646,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,
@@ -1673,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,
@@ -1711,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") {
@@ -1745,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
@@ -1754,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,
@@ -1787,253 +1577,645 @@ internalMutation({
   }
 });
 
-// src/epistemicContracts.evaluators.ts
-var evaluatorRegistry = /* @__PURE__ */ new Map();
-var BUILT_IN_EVIDENTIAL_ALIASES2 = METRIC_COMPARATOR_EVALUATOR_NAMES.evidentialAliases;
-var BUILT_IN_METRIC_CHECKER2 = METRIC_COMPARATOR_EVALUATOR_NAMES.metricChecker;
-var BUILT_IN_REFERENCE_CHECK_COUNTER2 = METRIC_COMPARATOR_EVALUATOR_NAMES.referenceCheckCounter;
-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 ensureBuiltInEvaluators() {
-  for (const name of BUILT_IN_EVIDENTIAL_ALIASES2) {
-    if (evaluatorRegistry.has(name)) {
-      continue;
-    }
-    evaluatorRegistry.set(name, {
-      name,
-      evaluate: evaluateBuiltInEvidentialContract
-    });
+// src/epistemicContracts.metrics.ts
+var ACTIVE_CONTRADICTION_STATUSES = /* @__PURE__ */ new Set([
+  "unresolved",
+  "investigating",
+  "accepted_as_permanent"
+]);
+var DEPENDENT_EDGE_TYPES = /* @__PURE__ */ new Set(["depends_on"]);
+function classifyContradictionStatus(status) {
+  if (typeof status !== "string") {
+    return "active";
   }
-  for (const evaluator of ENGINEERING_EPISTEMIC_EVALUATORS) {
-    if (evaluatorRegistry.has(evaluator.name)) {
-      continue;
-    }
-    evaluatorRegistry.set(evaluator.name, evaluator);
+  if (ACTIVE_CONTRADICTION_STATUSES.has(status)) {
+    return "active";
   }
-  const researchEvaluators = [
-    [BUILT_IN_METRIC_CHECKER2, evaluateMetricCheckerContract],
-    [BUILT_IN_REFERENCE_CHECK_COUNTER2, evaluateReferenceCheckCounterContract],
-    [BUILT_IN_TEMPORAL_DEADLINE2, evaluateTemporalDeadlineContract],
-    [BUILT_IN_MARKET_INDEX_COMPARATOR2, evaluateMarketIndexComparatorContract]
-  ];
-  for (const [name, evaluate] of researchEvaluators) {
-    if (evaluatorRegistry.has(name)) {
-      continue;
-    }
-    evaluatorRegistry.set(name, { name, evaluate });
+  if (status === "resolved_support" || status === "resolved_contra" || status === "belief_forked") {
+    return "resolved";
   }
+  return "resolved";
 }
-function normalizeTrigger(trigger) {
-  if (trigger === "evidence_added") {
-    return "evidence_added";
+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;
   }
-  if (trigger === "periodic") {
-    return "periodic";
+  const id = readConvexId2(value._id);
+  const nodeType = readOptionalString2(value.nodeType);
+  if (!(id && nodeType)) {
+    return null;
   }
-  if (trigger === "manual") {
-    return "manual";
+  const node = { _id: id, nodeType };
+  const globalId = readOptionalString2(value.globalId);
+  if (globalId !== void 0) {
+    node.globalId = globalId;
   }
-  return "event_driven";
-}
-function resolveSchedulesForTrigger(trigger) {
-  if (trigger === "evidence_added") {
-    return /* @__PURE__ */ new Set(["on_evidence", "event_driven"]);
+  if ("metadata" in value) {
+    node.metadata = value.metadata;
   }
-  if (trigger === "periodic") {
-    return /* @__PURE__ */ new Set(["periodic"]);
+  const status = readOptionalString2(value.status);
+  if (status !== void 0) {
+    node.status = status;
   }
-  if (trigger === "manual") {
-    return /* @__PURE__ */ new Set(["on_demand", "event_driven"]);
+  return node;
+}
+function readIncomingEdgeRow(value) {
+  if (!isRecord2(value)) {
+    return null;
   }
-  return /* @__PURE__ */ new Set(["event_driven"]);
+  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;
 }
-async function executeContractEvaluation(args) {
-  ensureBuiltInEvaluators();
-  const evaluator = evaluatorRegistry.get(args.contract.condition.evaluator);
-  let evaluation;
-  if (evaluator) {
+function getEdgeTimestamp(edge) {
+  if (typeof edge.updatedAt === "number") {
+    return edge.updatedAt;
+  }
+  if (typeof edge.createdAt === "number") {
+    return edge.createdAt;
+  }
+  if (typeof edge._creationTime === "number") {
+    return edge._creationTime;
+  }
+  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 {
-      evaluation = await evaluator.evaluate({
-        belief: args.belief,
-        contract: args.contract,
-        ctx: args.ctx,
-        now: args.now,
-        resultData: args.resultData,
-        trigger: args.trigger,
-        inputData: args.inputData
-      });
-    } catch (error) {
-      evaluation = {
-        result: "error",
-        rationale: error instanceof Error ? error.message : "Unknown evaluator error."
-      };
+      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;
     }
-  } else {
-    evaluation = {
-      result: "error",
-      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 modulationPlan = deriveContractModulationPlan({
-    currentConfidence: confidenceBefore,
-    modulation: args.contract.modulation,
-    result: evaluation.result,
-    resultConfidence: evaluation.confidence
-  });
-  let beliefConfidenceId;
-  let confidenceAfter = confidenceBefore;
-  if (modulationPlan) {
-    const contractB = Math.max(0, Math.min(1, modulationPlan.confidenceAfter));
-    const modulationResult = await applyBeliefConfidenceChange(args.ctx, {
-      nodeId: args.contract.beliefNodeId,
-      belief: contractB,
-      disbelief: 1 - contractB,
-      uncertainty: 0,
-      baseRate: 0.5,
-      trigger: modulationPlan.trigger,
-      rationale: `Epistemic contract "${args.contract.title}" ${evaluation.result}: ${evaluation.rationale}`,
-      authenticatedUserId: args.authenticatedUserId
-    });
-    beliefConfidenceId = modulationResult.beliefConfidenceId;
-    confidenceAfter = typeof modulationResult.newConfidence === "number" ? modulationResult.newConfidence : modulationPlan.confidenceAfter;
+  return null;
+}
+async function getEvidenceLinks(ctx, beliefNodeId) {
+  const edges = await collectIncomingEdgeRows(ctx, beliefNodeId, "informs");
+  if (edges.length === 0) {
+    return [];
   }
-  const evaluationId = await args.ctx.db.insert("contractEvaluations", {
-    contractId: args.contract.contractId,
-    beliefNodeId: args.contract.beliefNodeId,
-    result: evaluation.result,
-    evaluatedAt: args.now,
-    evaluator: args.contract.condition.evaluator,
-    trigger: args.trigger,
-    resultData: evaluation.data,
-    modulationApplied: Boolean(modulationPlan),
-    confidenceDelta: modulationPlan?.confidenceDelta,
-    confidenceBefore: modulationPlan?.confidenceBefore,
-    confidenceAfter: modulationPlan ? confidenceAfter : void 0,
-    beliefConfidenceId,
-    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 links = [];
+  for (const edge of edges) {
+    const node = await resolveEndpointNode(ctx, sourceEndpointRefs(edge));
+    if (node?.nodeType !== "evidence" || node.status === "archived") {
+      continue;
     }
+    links.push({ edge, node });
+  }
+  return links;
+}
+function getEvidenceTags(node) {
+  const metadata = node.metadata && typeof node.metadata === "object" ? node.metadata : null;
+  const tags = metadata?.tags;
+  if (!Array.isArray(tags)) {
+    return [];
+  }
+  return tags.filter((tag) => typeof tag === "string");
+}
+async function computeEvidenceCountMetric(ctx, beliefNodeId) {
+  return (await getEvidenceLinks(ctx, beliefNodeId)).length;
+}
+async function computeTaggedEvidenceCount(args) {
+  const expectedTag = args.caseSensitive ? args.tag : args.tag.toLowerCase();
+  const matchedEvidenceIds = (await getEvidenceLinks(args.ctx, args.beliefNodeId)).filter(
+    ({ node }) => getEvidenceTags(node).some(
+      (tag) => (args.caseSensitive ? tag : tag.toLowerCase()) === expectedTag
+    )
+  ).map(({ node }) => String(node._id));
+  return {
+    count: matchedEvidenceIds.length,
+    matchedEvidenceIds
+  };
+}
+async function computeContradictionCounts(ctx, beliefNodeId) {
+  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";
+      if (classifyContradictionStatus(status) === "active") {
+        counts.activeCount += 1;
+      } else {
+        counts.resolvedCount += 1;
+      }
+      return counts;
+    },
+    { activeCount: 0, resolvedCount: 0 }
   );
+}
+async function computeEvidenceFreshness(ctx, beliefNodeId, now = Date.now()) {
+  const timestamps = (await getEvidenceLinks(ctx, beliefNodeId)).map(({ edge }) => getEdgeTimestamp(edge)).filter((value) => value !== null);
+  if (timestamps.length === 0) {
+    return {
+      newestAgeMs: null,
+      oldestAgeMs: null,
+      newestEdgeAt: null,
+      oldestEdgeAt: null,
+      edgeCount: 0
+    };
+  }
+  const newestEdgeAt = Math.max(...timestamps);
+  const oldestEdgeAt = Math.min(...timestamps);
   return {
-    evaluationId,
-    result: evaluation.result,
-    status: nextStatus,
-    confidenceBefore,
-    confidenceAfter,
-    rationale: evaluation.rationale,
-    data: evaluation.data,
-    currentConfidence: confidenceAfter
+    newestAgeMs: Math.max(0, now - newestEdgeAt),
+    oldestAgeMs: Math.max(0, now - oldestEdgeAt),
+    newestEdgeAt,
+    oldestEdgeAt,
+    edgeCount: timestamps.length
   };
 }
-async function evaluateContractsForTriggerBatch(args) {
-  const startedAt = Date.now();
-  const contracts = await loadContractsForTrigger({
+async function computeDependentBeliefCount(ctx, beliefNodeId) {
+  const incomingEdges = await collectIncomingEdgeRows(ctx, beliefNodeId);
+  const dependencyEdges = incomingEdges.filter(
+    (edge) => edge.edgeType ? DEPENDENT_EDGE_TYPES.has(edge.edgeType) : false
+  );
+  if (dependencyEdges.length === 0) {
+    return 0;
+  }
+  const uniqueBeliefIds = /* @__PURE__ */ new Set();
+  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));
+    }
+  }
+  return uniqueBeliefIds.size;
+}
+async function snapshotEvidentialMetric(args) {
+  switch (args.metric) {
+    case "evidence_count": {
+      const count = await computeEvidenceCountMetric(
+        args.ctx,
+        args.beliefNodeId
+      );
+      return {
+        metric: args.metric,
+        value: count,
+        data: { evidenceCount: count }
+      };
+    }
+    case "contradiction_status": {
+      const counts = await computeContradictionCounts(
+        args.ctx,
+        args.beliefNodeId
+      );
+      return {
+        metric: args.metric,
+        value: counts.activeCount,
+        data: counts
+      };
+    }
+    case "edge_freshness": {
+      const freshness = await computeEvidenceFreshness(
+        args.ctx,
+        args.beliefNodeId,
+        args.now
+      );
+      return {
+        metric: args.metric,
+        value: freshness.newestAgeMs,
+        data: freshness
+      };
+    }
+    case "dependent_count": {
+      const count = await computeDependentBeliefCount(
+        args.ctx,
+        args.beliefNodeId
+      );
+      return {
+        metric: args.metric,
+        value: count,
+        data: { dependentCount: count }
+      };
+    }
+    default:
+      return {
+        metric: args.metric,
+        value: null,
+        data: {}
+      };
+  }
+}
+async function evaluateBuiltInEvidentialContract(args) {
+  const config = parseEvidentialEvaluatorConfig(
+    args.contract.condition.evaluatorConfig
+  );
+  const snapshot = await snapshotEvidentialMetric({
     ctx: args.ctx,
     beliefNodeId: args.belief._id,
-    trigger: normalizeTrigger(args.trigger),
-    contractIds: args.contractIds
+    metric: config.metric,
+    now: args.now
   });
-  const batchLimit = Math.max(
-    1,
-    Math.min(
-      args.maxBatchSize ?? MAX_CONTRACT_EVALUATION_BATCH_SIZE,
-      MAX_CONTRACT_EVALUATION_BATCH_SIZE
-    )
+  const comparisonSatisfied = snapshot.value !== null && compareMetricValue(config.operator, snapshot.value, config.threshold);
+  const result = resolveComparisonResult(
+    args.contract.direction,
+    comparisonSatisfied
   );
-  const currentBatch = contracts.slice(0, batchLimit);
-  const overflowContracts = contracts.slice(batchLimit);
-  let runningConfidence = typeof args.belief.confidence === "number" ? args.belief.confidence : 0.5;
-  const results = [];
-  for (const contract of currentBatch) {
-    const evaluation = await executeContractEvaluation({
-      ctx: args.ctx,
-      belief: args.belief,
-      contract,
-      now: Date.now(),
-      trigger: normalizeTrigger(args.trigger),
-      inputData: args.inputData,
-      authenticatedUserId: args.authenticatedUserId,
-      currentConfidence: runningConfidence
-    });
-    runningConfidence = evaluation.currentConfidence;
-    args.belief.confidence = runningConfidence;
-    results.push({
-      contractId: contract.contractId,
-      result: evaluation.result,
-      status: evaluation.status,
-      confidenceAfter: evaluation.confidenceAfter
-    });
-  }
-  if (overflowContracts.length > 0) {
-    await args.ctx.scheduler.runAfter(
-      0,
-      "epistemicContracts.processContractEvaluationOverflow",
-      {
-        beliefNodeId: args.belief._id,
-        trigger: normalizeTrigger(args.trigger),
-        contractIds: overflowContracts.map((contract) => contract.contractId),
-        inputData: args.inputData,
-        authenticatedUserId: args.authenticatedUserId,
-        maxBatchSize: batchLimit
-      }
+  return {
+    result,
+    rationale: buildEvidentialRationale({
+      config,
+      snapshot,
+      comparisonSatisfied,
+      result
+    }),
+    data: {
+      ...snapshot.data,
+      metric: config.metric,
+      observedValue: snapshot.value,
+      operator: config.operator,
+      threshold: config.threshold,
+      action: config.action ?? "append_sl_scoring",
+      actionParams: config.actionParams
+    }
+  };
+}
+function evaluateMetricCheckerContract(args) {
+  return Promise.resolve().then(() => {
+    const config = parseMetricCheckerConfig(
+      args.contract.condition.evaluatorConfig
     );
-  }
-  const executionTimeMs = Date.now() - startedAt;
-  console.info("[epistemicContracts] processed contract evaluation batch", {
-    beliefNodeId: String(args.belief._id),
-    trigger: normalizeTrigger(args.trigger),
-    batchSize: currentBatch.length,
-    overflowCount: overflowContracts.length,
-    executionTimeMs
+    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,
+      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 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({
+    ctx: args.ctx,
+    beliefNodeId: args.belief._id,
+    tag,
+    caseSensitive: config.caseSensitive
   });
+  const comparisonSatisfied = compareMetricValue(
+    config.operator,
+    snapshot.count,
+    config.threshold
+  );
+  const result = resolveComparisonResult(
+    args.contract.direction,
+    comparisonSatisfied
+  );
   return {
-    totalContracts: contracts.length,
-    processedCount: currentBatch.length,
-    overflowCount: overflowContracts.length,
-    scheduledOverflow: overflowContracts.length > 0,
-    batchSize: currentBatch.length,
-    executionTimeMs,
-    trigger: normalizeTrigger(args.trigger),
-    results
+    result,
+    rationale: buildComparisonRationale({
+      label: `reference checks tagged "${tag}"`,
+      observedValue: snapshot.count,
+      operator: config.operator,
+      threshold: config.threshold,
+      comparisonSatisfied,
+      result
+    }),
+    data: {
+      tag,
+      observedValue: snapshot.count,
+      referenceCheckCount: snapshot.count,
+      matchedEvidenceIds: snapshot.matchedEvidenceIds,
+      operator: config.operator,
+      threshold: config.threshold,
+      caseSensitive: config.caseSensitive ?? false
+    }
   };
 }
-async function loadContractsForBelief(args) {
-  return await args.ctx.db.query("epistemicContracts").withIndex("by_belief", (q) => q.eq("beliefNodeId", args.beliefNodeId)).collect();
+function resolveCompletedTemporalDeadlineResult(args) {
+  const { completedAt, context, deadline, label } = args;
+  if (completedAt !== void 0 && completedAt > deadline) {
+    return {
+      result: "expired",
+      rationale: `${label} completed at ${completedAt}, after deadline ${deadline}.`,
+      data: {
+        label,
+        deadline,
+        completed: true,
+        completedAt,
+        missedDeadline: true,
+        overdueByMs: completedAt - 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
+    }
+  };
 }
-async function loadContractsForTrigger(args) {
-  const contracts = await loadContractsForBelief(args);
-  ensureBuiltInEvaluators();
-  const allowedSchedules = resolveSchedulesForTrigger(args.trigger);
-  const contractIdFilter = args.contractIds && args.contractIds.length > 0 ? new Set(args.contractIds) : null;
-  return contracts.filter((contract) => {
-    if (contract.status === "archived") {
-      return false;
+function resolveOpenTemporalDeadlineResult(args) {
+  const { context, deadline, label } = args;
+  if (context.now > deadline) {
+    return {
+      result: "expired",
+      rationale: `${label} missed deadline ${deadline}; temporal contract expired.`,
+      data: {
+        label,
+        deadline,
+        completed: false,
+        overdueByMs: context.now - deadline
+      }
+    };
+  }
+  return {
+    result: "inconclusive",
+    rationale: `${label} is still before deadline ${deadline}; awaiting outcome.`,
+    data: {
+      label,
+      deadline,
+      completed: false,
+      timeRemainingMs: deadline - context.now
     }
-    if (contract.conditionType === "composite") {
-      return false;
+  };
+}
+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."
+      );
     }
-    if (!evaluatorRegistry.has(contract.condition.evaluator)) {
-      return false;
+    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
+      });
     }
-    if (contractIdFilter) {
-      return contractIdFilter.has(contract.contractId);
+    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
+        }
+      };
     }
-    return allowedSchedules.has(contract.evaluationSchedule);
+    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"
+  ]),
+  metricChecker: "metric_checker",
+  referenceCheckCounter: "reference_check_counter",
+  temporalDeadline: "temporal_deadline",
+  marketIndexComparator: "market_index_comparator"
+};
 
 // src/evaluators/shared.ts
+var WINDOWS_PATH_SEPARATORS = /\\/g;
+var LEADING_DOT_SLASH = /^\.\//;
 function asArray(value) {
   return Array.isArray(value) ? value : [];
 }
@@ -2075,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);
@@ -2129,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) {
@@ -2201,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",
@@ -2227,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) {
@@ -2312,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) {
@@ -2458,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) {
@@ -2470,118 +2655,383 @@ function parseConfig4(condition) {
   if (filePatterns.length === 0) {
     throw new Error("tsc_checker requires at least one file pattern.");
   }
-  return { filePatterns };
+  return { filePatterns };
+}
+function parseStructuredDiagnostics(resultData) {
+  const envelope = normalizeToolResultEnvelope(resultData);
+  const record = asRecord(envelope.report) ?? asRecord(envelope.data) ?? asRecord(resultData);
+  if (!record) {
+    return [];
+  }
+  return asArray(record.diagnostics).flatMap((entry) => {
+    const diagnostic = asRecord(entry);
+    if (!diagnostic) {
+      return [];
+    }
+    const filePath = asString(diagnostic.filePath) ?? asString(diagnostic.file) ?? asString(asRecord(diagnostic.location)?.filePath) ?? asString(asRecord(asRecord(diagnostic.location)?.path)?.file);
+    const message = asString(diagnostic.message) ?? "TypeScript error";
+    return [
+      {
+        code: asString(diagnostic.code) ?? void 0,
+        filePath: filePath ? normalizeFilePath(filePath) : null,
+        message
+      }
+    ];
+  });
+}
+function parseTextDiagnostics(resultData) {
+  const diagnostics = [];
+  const patterns = [
+    /^(.+?)\((\d+),(\d+)\): error TS(\d+): (.+)$/gm,
+    /^(.+?):(\d+):(\d+) - error TS(\d+): (.+)$/gm
+  ];
+  for (const text of extractTextCandidates(resultData)) {
+    for (const pattern of patterns) {
+      for (const match of text.matchAll(pattern)) {
+        diagnostics.push({
+          code: match[4],
+          filePath: normalizeFilePath(match[1] ?? ""),
+          message: match[5] ?? "TypeScript error"
+        });
+      }
+    }
+  }
+  return diagnostics;
+}
+function parseDiagnostics2(resultData) {
+  const structured = parseStructuredDiagnostics(resultData);
+  return structured.length > 0 ? structured : parseTextDiagnostics(resultData);
+}
+function getMatchedDiagnostics2(contract, resultData) {
+  const config = parseConfig4(contract.condition);
+  return parseDiagnostics2(resultData).filter(
+    (diagnostic) => somePatternMatches(diagnostic.filePath, config.filePatterns)
+  );
+}
+var tscCheckerEvaluator = {
+  name: "tsc_checker",
+  matches({ contract, resultData }) {
+    const envelope = normalizeToolResultEnvelope(resultData);
+    const exitCode = asNumber(envelope.exitCode);
+    if (exitCode === 0) {
+      return true;
+    }
+    return getMatchedDiagnostics2(contract, resultData).length > 0;
+  },
+  evaluate(args) {
+    const config = parseConfig4(args.contract.condition);
+    if (!args.resultData) {
+      return {
+        result: "error",
+        rationale: "tsc_checker requires TypeScript diagnostic resultData."
+      };
+    }
+    const envelope = normalizeToolResultEnvelope(args.resultData);
+    const exitCode = asNumber(envelope.exitCode);
+    const matchedDiagnostics = getMatchedDiagnostics2(
+      args.contract,
+      args.resultData
+    );
+    if (matchedDiagnostics.length === 0 && exitCode !== 0 && exitCode !== null) {
+      return {
+        result: "inconclusive",
+        rationale: "TypeScript reported errors, but none matched the configured file patterns."
+      };
+    }
+    const conditionSatisfied = exitCode === 0 || exitCode !== null && matchedDiagnostics.length === 0;
+    return {
+      result: deriveDirectionalResult(
+        args.contract.direction,
+        conditionSatisfied
+      ),
+      rationale: conditionSatisfied ? `TypeScript reported no matching diagnostics for ${config.filePatterns.join(", ")}.` : `TypeScript found ${matchedDiagnostics.length} matching diagnostic(s): ${matchedDiagnostics.map(
+        (diagnostic) => diagnostic.filePath ? `${diagnostic.filePath}${diagnostic.code ? ` (TS${diagnostic.code})` : ""}` : diagnostic.message
+      ).join(", ")}.`,
+      data: {
+        exitCode,
+        filePatterns: config.filePatterns,
+        matchedDiagnostics
+      }
+    };
+  }
+};
+
+// src/evaluators/index.ts
+var ENGINEERING_EPISTEMIC_EVALUATORS = [
+  testRunnerEvaluator,
+  tscCheckerEvaluator,
+  lintCheckerEvaluator,
+  sentryCheckerEvaluator
+];
+var ENGINEERING_EVALUATOR_NAMES = new Set(
+  ENGINEERING_EPISTEMIC_EVALUATORS.map((evaluator) => evaluator.name)
+);
+function getEngineeringEpistemicEvaluator(name) {
+  return ENGINEERING_EPISTEMIC_EVALUATORS.find(
+    (evaluator) => evaluator.name === name
+  );
+}
+
+// src/epistemicContracts.evaluators.ts
+var evaluatorRegistry = /* @__PURE__ */ new Map();
+var BUILT_IN_EVIDENTIAL_ALIASES2 = METRIC_COMPARATOR_EVALUATOR_NAMES.evidentialAliases;
+var BUILT_IN_METRIC_CHECKER2 = METRIC_COMPARATOR_EVALUATOR_NAMES.metricChecker;
+var BUILT_IN_REFERENCE_CHECK_COUNTER2 = METRIC_COMPARATOR_EVALUATOR_NAMES.referenceCheckCounter;
+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 ensureBuiltInEvaluators() {
+  for (const name of BUILT_IN_EVIDENTIAL_ALIASES2) {
+    if (evaluatorRegistry.has(name)) {
+      continue;
+    }
+    evaluatorRegistry.set(name, {
+      name,
+      evaluate: evaluateBuiltInEvidentialContract
+    });
+  }
+  for (const evaluator of ENGINEERING_EPISTEMIC_EVALUATORS) {
+    if (evaluatorRegistry.has(evaluator.name)) {
+      continue;
+    }
+    evaluatorRegistry.set(evaluator.name, evaluator);
+  }
+  const researchEvaluators = [
+    [BUILT_IN_METRIC_CHECKER2, evaluateMetricCheckerContract],
+    [BUILT_IN_REFERENCE_CHECK_COUNTER2, evaluateReferenceCheckCounterContract],
+    [BUILT_IN_TEMPORAL_DEADLINE2, evaluateTemporalDeadlineContract],
+    [BUILT_IN_MARKET_INDEX_COMPARATOR2, evaluateMarketIndexComparatorContract]
+  ];
+  for (const [name, evaluate] of researchEvaluators) {
+    if (evaluatorRegistry.has(name)) {
+      continue;
+    }
+    evaluatorRegistry.set(name, { name, evaluate });
+  }
+}
+function normalizeTrigger(trigger) {
+  if (trigger === "evidence_added") {
+    return "evidence_added";
+  }
+  if (trigger === "periodic") {
+    return "periodic";
+  }
+  if (trigger === "manual") {
+    return "manual";
+  }
+  return "event_driven";
+}
+function resolveSchedulesForTrigger(trigger) {
+  if (trigger === "evidence_added") {
+    return /* @__PURE__ */ new Set(["on_evidence", "event_driven"]);
+  }
+  if (trigger === "periodic") {
+    return /* @__PURE__ */ new Set(["periodic"]);
+  }
+  if (trigger === "manual") {
+    return /* @__PURE__ */ new Set(["on_demand", "event_driven"]);
+  }
+  return /* @__PURE__ */ new Set(["event_driven"]);
+}
+async function executeContractEvaluation(args) {
+  ensureBuiltInEvaluators();
+  const evaluator = evaluatorRegistry.get(args.contract.condition.evaluator);
+  let evaluation;
+  if (evaluator) {
+    try {
+      evaluation = await evaluator.evaluate({
+        belief: args.belief,
+        contract: args.contract,
+        ctx: args.ctx,
+        now: args.now,
+        resultData: args.resultData,
+        trigger: args.trigger,
+        inputData: args.inputData
+      });
+    } catch (error) {
+      evaluation = {
+        result: "error",
+        rationale: error instanceof Error ? error.message : "Unknown evaluator error."
+      };
+    }
+  } else {
+    evaluation = {
+      result: "error",
+      rationale: `No epistemic evaluator registered for "${args.contract.condition.evaluator}".`
+    };
+  }
+  const confidenceBefore = confidenceSeed({
+    beliefConfidence: args.belief.confidence,
+    currentConfidence: args.currentConfidence
+  });
+  const modulationPlan = deriveContractModulationPlan({
+    currentConfidence: confidenceBefore,
+    modulation: args.contract.modulation,
+    result: evaluation.result,
+    resultConfidence: evaluation.confidence
+  });
+  let beliefConfidenceId;
+  let confidenceAfter = confidenceBefore;
+  if (modulationPlan) {
+    const contractB = Math.max(0, Math.min(1, modulationPlan.confidenceAfter));
+    const modulationResult = await applyBeliefConfidenceChange(args.ctx, {
+      nodeId: args.contract.beliefNodeId,
+      belief: contractB,
+      disbelief: 1 - contractB,
+      uncertainty: 0,
+      baseRate: 0.5,
+      trigger: modulationPlan.trigger,
+      rationale: `Epistemic contract "${args.contract.title}" ${evaluation.result}: ${evaluation.rationale}`,
+      authenticatedUserId: args.authenticatedUserId
+    });
+    beliefConfidenceId = modulationResult.beliefConfidenceId;
+    confidenceAfter = typeof modulationResult.newConfidence === "number" ? modulationResult.newConfidence : modulationPlan.confidenceAfter;
+  }
+  const evaluationId = await args.ctx.db.insert("contractEvaluations", {
+    contractId: args.contract.contractId,
+    beliefNodeId: args.contract.beliefNodeId,
+    result: evaluation.result,
+    evaluatedAt: args.now,
+    evaluator: args.contract.condition.evaluator,
+    trigger: args.trigger,
+    resultData: evaluation.data,
+    modulationApplied: Boolean(modulationPlan),
+    confidenceDelta: modulationPlan?.confidenceDelta,
+    confidenceBefore: modulationPlan?.confidenceBefore,
+    confidenceAfter: modulationPlan ? confidenceAfter : void 0,
+    beliefConfidenceId,
+    modulationRationale: evaluation.rationale,
+    topicId: args.contract.topicId
+  });
+  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,
+    status: nextStatus,
+    confidenceBefore,
+    confidenceAfter,
+    rationale: evaluation.rationale,
+    data: evaluation.data,
+    currentConfidence: confidenceAfter
+  };
 }
-function parseStructuredDiagnostics(resultData) {
-  const envelope = normalizeToolResultEnvelope(resultData);
-  const record = asRecord(envelope.report) ?? asRecord(envelope.data) ?? asRecord(resultData);
-  if (!record) {
-    return [];
+async function evaluateContractsForTriggerBatch(args) {
+  const startedAt = Date.now();
+  const contracts = await loadContractsForTrigger({
+    ctx: args.ctx,
+    beliefNodeId: args.belief._id,
+    trigger: normalizeTrigger(args.trigger),
+    contractIds: args.contractIds
+  });
+  const batchLimit = Math.max(
+    1,
+    Math.min(
+      args.maxBatchSize ?? MAX_CONTRACT_EVALUATION_BATCH_SIZE,
+      MAX_CONTRACT_EVALUATION_BATCH_SIZE
+    )
+  );
+  const currentBatch = contracts.slice(0, batchLimit);
+  const overflowContracts = contracts.slice(batchLimit);
+  let runningConfidence = typeof args.belief.confidence === "number" ? args.belief.confidence : 0.5;
+  const results = [];
+  for (const contract of currentBatch) {
+    const evaluation = await executeContractEvaluation({
+      ctx: args.ctx,
+      belief: args.belief,
+      contract,
+      now: Date.now(),
+      trigger: normalizeTrigger(args.trigger),
+      inputData: args.inputData,
+      authenticatedUserId: args.authenticatedUserId,
+      currentConfidence: runningConfidence
+    });
+    runningConfidence = evaluation.currentConfidence;
+    args.belief.confidence = runningConfidence;
+    results.push({
+      contractId: contract.contractId,
+      result: evaluation.result,
+      status: evaluation.status,
+      confidenceAfter: evaluation.confidenceAfter
+    });
   }
-  return asArray(record.diagnostics).flatMap((entry) => {
-    const diagnostic = asRecord(entry);
-    if (!diagnostic) {
-      return [];
-    }
-    const filePath = asString(diagnostic.filePath) ?? asString(diagnostic.file) ?? asString(asRecord(diagnostic.location)?.filePath) ?? asString(asRecord(asRecord(diagnostic.location)?.path)?.file);
-    const message = asString(diagnostic.message) ?? "TypeScript error";
-    return [
+  if (overflowContracts.length > 0) {
+    await args.ctx.scheduler.runAfter(
+      0,
+      "epistemicContracts.processContractEvaluationOverflow",
       {
-        code: asString(diagnostic.code) ?? void 0,
-        filePath: filePath ? normalizeFilePath(filePath) : null,
-        message
-      }
-    ];
-  });
-}
-function parseTextDiagnostics(resultData) {
-  const diagnostics = [];
-  const patterns = [
-    /^(.+?)\((\d+),(\d+)\): error TS(\d+): (.+)$/gm,
-    /^(.+?):(\d+):(\d+) - error TS(\d+): (.+)$/gm
-  ];
-  for (const text of extractTextCandidates(resultData)) {
-    for (const pattern of patterns) {
-      for (const match of text.matchAll(pattern)) {
-        diagnostics.push({
-          code: match[4],
-          filePath: normalizeFilePath(match[1] ?? ""),
-          message: match[5] ?? "TypeScript error"
-        });
+        beliefNodeId: args.belief._id,
+        trigger: normalizeTrigger(args.trigger),
+        contractIds: overflowContracts.map((contract) => contract.contractId),
+        inputData: args.inputData,
+        authenticatedUserId: args.authenticatedUserId,
+        maxBatchSize: batchLimit
       }
-    }
+    );
   }
-  return diagnostics;
-}
-function parseDiagnostics2(resultData) {
-  const structured = parseStructuredDiagnostics(resultData);
-  return structured.length > 0 ? structured : parseTextDiagnostics(resultData);
+  const executionTimeMs = Date.now() - startedAt;
+  console.info("[epistemicContracts] processed contract evaluation batch", {
+    beliefNodeId: String(args.belief._id),
+    trigger: normalizeTrigger(args.trigger),
+    batchSize: currentBatch.length,
+    overflowCount: overflowContracts.length,
+    executionTimeMs
+  });
+  return {
+    totalContracts: contracts.length,
+    processedCount: currentBatch.length,
+    overflowCount: overflowContracts.length,
+    scheduledOverflow: overflowContracts.length > 0,
+    batchSize: currentBatch.length,
+    executionTimeMs,
+    trigger: normalizeTrigger(args.trigger),
+    results
+  };
 }
-function getMatchedDiagnostics2(contract, resultData) {
-  const config = parseConfig4(contract.condition);
-  return parseDiagnostics2(resultData).filter(
-    (diagnostic) => somePatternMatches(diagnostic.filePath, config.filePatterns)
-  );
+async function loadContractsForBelief(args) {
+  const rows = await args.ctx.db.query("epistemicContracts").withIndex("by_belief", (q) => q.eq("beliefNodeId", args.beliefNodeId)).collect();
+  return rows;
 }
-var tscCheckerEvaluator = {
-  name: "tsc_checker",
-  matches({ contract, resultData }) {
-    const envelope = normalizeToolResultEnvelope(resultData);
-    const exitCode = asNumber(envelope.exitCode);
-    if (exitCode === 0) {
-      return true;
+async function loadContractsForTrigger(args) {
+  const contracts = await loadContractsForBelief(args);
+  ensureBuiltInEvaluators();
+  const allowedSchedules = resolveSchedulesForTrigger(args.trigger);
+  const contractIdFilter = args.contractIds && args.contractIds.length > 0 ? new Set(args.contractIds) : null;
+  return contracts.filter((contract) => {
+    if (contract.status === "archived") {
+      return false;
     }
-    return getMatchedDiagnostics2(contract, resultData).length > 0;
-  },
-  evaluate(args) {
-    const config = parseConfig4(args.contract.condition);
-    if (!args.resultData) {
-      return {
-        result: "error",
-        rationale: "tsc_checker requires TypeScript diagnostic resultData."
-      };
+    if (contract.conditionType === "composite") {
+      return false;
     }
-    const envelope = normalizeToolResultEnvelope(args.resultData);
-    const exitCode = asNumber(envelope.exitCode);
-    const matchedDiagnostics = getMatchedDiagnostics2(args.contract, args.resultData);
-    if (matchedDiagnostics.length === 0 && exitCode !== 0 && exitCode !== null) {
-      return {
-        result: "inconclusive",
-        rationale: "TypeScript reported errors, but none matched the configured file patterns."
-      };
+    if (!evaluatorRegistry.has(contract.condition.evaluator)) {
+      return false;
     }
-    const conditionSatisfied = exitCode === 0 || exitCode !== null && matchedDiagnostics.length === 0;
-    return {
-      result: deriveDirectionalResult(
-        args.contract.direction,
-        conditionSatisfied
-      ),
-      rationale: conditionSatisfied ? `TypeScript reported no matching diagnostics for ${config.filePatterns.join(", ")}.` : `TypeScript found ${matchedDiagnostics.length} matching diagnostic(s): ${matchedDiagnostics.map(
-        (diagnostic) => diagnostic.filePath ? `${diagnostic.filePath}${diagnostic.code ? ` (TS${diagnostic.code})` : ""}` : diagnostic.message
-      ).join(", ")}.`,
-      data: {
-        exitCode,
-        filePatterns: config.filePatterns,
-        matchedDiagnostics
-      }
-    };
-  }
-};
-
-// src/evaluators/index.ts
-var ENGINEERING_EPISTEMIC_EVALUATORS = [
-  testRunnerEvaluator,
-  tscCheckerEvaluator,
-  lintCheckerEvaluator,
-  sentryCheckerEvaluator
-];
-var ENGINEERING_EVALUATOR_NAMES = new Set(
-  ENGINEERING_EPISTEMIC_EVALUATORS.map((evaluator) => evaluator.name)
-);
-function getEngineeringEpistemicEvaluator(name) {
-  return ENGINEERING_EPISTEMIC_EVALUATORS.find(
-    (evaluator) => evaluator.name === name
-  );
+    if (contractIdFilter) {
+      return contractIdFilter.has(contract.contractId);
+    }
+    return allowedSchedules.has(contract.evaluationSchedule);
+  });
 }
 
 // src/epistemicContracts.handlers.ts
@@ -2597,6 +3047,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) {
@@ -2632,17 +3100,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({
@@ -2652,10 +3124,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);
   }
@@ -2667,10 +3136,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);
   }
@@ -2682,10 +3148,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);
   }
@@ -2697,10 +3160,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);
   }
@@ -2764,10 +3224,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();
@@ -2822,10 +3279,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,
@@ -2863,14 +3320,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],
@@ -2949,10 +3403,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,
@@ -2975,10 +3426,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,
@@ -3017,15 +3465,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(
@@ -3033,15 +3475,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) => ({
@@ -3060,21 +3501,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))
     );