@lucern/graph-primitives 1.0.0 → 1.0.1

package/dist/epistemicContracts.handlers.js

@@ -0,0 +1,3029 @@
+import { v } from 'convex/values';
+import { checkProjectAccess } 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 '@lucern/access-control/audience';
+import { componentsGeneric, internalMutationGeneric, anyApi, queryGeneric, mutationGeneric } from 'convex/server';
+import '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
+
+// src/epistemicContracts.handlers.ts
+
+// 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";
+  }
+  if (ACTIVE_CONTRADICTION_STATUSES.has(status)) {
+    return "active";
+  }
+  if (status === "resolved_support" || status === "resolved_contra" || status === "belief_forked") {
+    return "resolved";
+  }
+  return "resolved";
+}
+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 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 [];
+  }
+  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 }];
+  });
+}
+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 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 }
+  );
+}
+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 {
+    newestAgeMs: Math.max(0, now - newestEdgeAt),
+    oldestAgeMs: Math.max(0, now - oldestEdgeAt),
+    newestEdgeAt,
+    oldestEdgeAt,
+    edgeCount: timestamps.length
+  };
+}
+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;
+  }
+  const dependentBeliefs = await Promise.all(
+    dependencyEdges.map((edge) => ctx.db.get(edge.fromNodeId))
+  );
+  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));
+    }
+  }
+  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,
+    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 ?? "modulate_confidence",
+      actionParams: config.actionParams
+    }
+  };
+}
+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
+      }
+    };
+  }
+  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 {
+    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."
+    );
+  }
+  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
+      }
+    };
+  }
+  if (args.now > args.contract.deadline) {
+    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
+      }
+    };
+  }
+  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
+    }
+  };
+}
+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."
+    );
+  }
+  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",
+  "belief",
+  "fact"
+];
+var RESOLVED_PREDICTION_OUTCOMES = [
+  "confirmed",
+  "disconfirmed",
+  "partial",
+  "expired"
+];
+function isBeliefLifecycleStatus(value) {
+  return typeof value === "string" && BELIEF_STATUS_VALUES.includes(value);
+}
+function normalizeBeliefConfidence(confidence) {
+  if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
+    return null;
+  }
+  if (confidence >= 0 && confidence <= 1) {
+    return confidence;
+  }
+  if (confidence > 1 && confidence <= 100) {
+    return confidence / 100;
+  }
+  return null;
+}
+function isResolvedByConfidence(confidence) {
+  const normalized = normalizeBeliefConfidence(confidence);
+  if (normalized === null) {
+    return false;
+  }
+  return normalized <= 0 || normalized >= 1;
+}
+function hasResolvedPredictionOutcome(predictionMeta) {
+  if (!predictionMeta || typeof predictionMeta !== "object") {
+    return false;
+  }
+  const outcome = predictionMeta.outcome;
+  return typeof outcome === "string" && RESOLVED_PREDICTION_OUTCOMES.includes(outcome);
+}
+function getPredictionMetaFromMetadata(metadata) {
+  return metadata?.predictionMeta;
+}
+function shouldTreatBeliefAsFact(opts) {
+  if (isResolvedByConfidence(opts.confidence)) {
+    return true;
+  }
+  if (hasResolvedPredictionOutcome(opts.predictionMeta)) {
+    return true;
+  }
+  if (hasResolvedPredictionOutcome(getPredictionMetaFromMetadata(opts.metadata))) {
+    return true;
+  }
+  return false;
+}
+function resolveBeliefLifecycleStatus(opts) {
+  if (shouldTreatBeliefAsFact(opts)) {
+    return "fact";
+  }
+  const direct = opts.beliefStatus;
+  if (isBeliefLifecycleStatus(direct)) {
+    const normalized = normalizeBeliefConfidence(opts.confidence);
+    if (normalized !== null && isPreValidationBeliefStatus(direct)) {
+      return "belief";
+    }
+    return direct;
+  }
+  const metaStatus = opts.metadata?.beliefStatus;
+  if (isBeliefLifecycleStatus(metaStatus)) {
+    const normalized = normalizeBeliefConfidence(opts.confidence);
+    if (normalized !== null && isPreValidationBeliefStatus(metaStatus)) {
+      return "belief";
+    }
+    return metaStatus;
+  }
+  return "assumption";
+}
+function isPreValidationBeliefStatus(status) {
+  return status === "assumption" || status === "hypothesis";
+}
+function promoteBeliefStatusAfterScoring(status, opts) {
+  if (shouldTreatBeliefAsFact({ ...opts })) {
+    return "fact";
+  }
+  if (isPreValidationBeliefStatus(status)) {
+    return "belief";
+  }
+  return status === "fact" ? "fact" : "belief";
+}
+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";
+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 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;
+    }
+    const createdA = a.createdAt ?? Number.MAX_SAFE_INTEGER;
+    const createdB = b.createdAt ?? Number.MAX_SAFE_INTEGER;
+    if (createdA !== createdB) {
+      return createdA - createdB;
+    }
+    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;
+    });
+  }
+}
+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 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;
+  }
+}
+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 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) {
+      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"
+      };
+    }
+    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 error = new Error(args.message);
+  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 ?? "manual_assessment",
+    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 access required.",
+      status: 403,
+      code: "FORBIDDEN",
+      invariantCode: "policy.scope_required",
+      suggestion: "Request write access for the project and retry.",
+      details: { projectId, 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 propagatePositiveSupport(sourceOpinion, targetOpinion, edgeWeight) {
+  const discounted = trustDiscount(sourceOpinion, Math.abs(edgeWeight));
+  return {
+    opinion: cumulativeFusion(targetOpinion, discounted),
+    operator: "cumulative_fusion",
+    rationale: `Supporting evidence (weight=${edgeWeight.toFixed(
+      2
+    )}) from source at ${project(sourceOpinion).toFixed(2)}`
+  };
+}
+function propagatePositiveInform(sourceOpinion, targetOpinion, edgeWeight) {
+  const discounted = trustDiscount(sourceOpinion, Math.abs(edgeWeight));
+  return {
+    opinion: cumulativeFusion(targetOpinion, discounted),
+    operator: "cumulative_fusion",
+    rationale: `Supporting evidence (weight=${edgeWeight.toFixed(2)})`
+  };
+}
+function propagateNegativeSupportWithMetadata(sourceOpinion, targetOpinion, edgeWeight, edge) {
+  return applyNegativeSupport(
+    sourceOpinion,
+    targetOpinion,
+    edgeWeight,
+    readEdgeMetadata(edge)
+  );
+}
+var propagateNegativeInform = applyNegativeEvidence;
+
+// src/edges/contradicts.ts
+var contradictsPropagationSpec = {
+  edgeType: "contradicts",
+  direction: "bidirectional",
+  transitivity: "none",
+  damping: 0.85,
+  maxHops: 1,
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const negativeWeight = -Math.abs(edge.weight ?? 1);
+    const result = propagateNegativeSupportWithMetadata(
+      dampedSource,
+      targetOpinion,
+      negativeWeight,
+      edge
+    );
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Legacy contradiction edges move negative pressure in either direction, but never beyond one hop."
+};
+var dependsOnPropagationSpec = {
+  edgeType: "depends_on",
+  direction: "incoming",
+  transitivity: "damped",
+  damping: 0.8,
+  maxHops: "unbounded",
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const metadata = readEdgeMetadata(edge);
+    if (metadata.conditionalA && metadata.conditionalNotA) {
+      const deducedOpinion = conditionalDeduction(
+        dampedSource,
+        mkOpinion(
+          metadata.conditionalA.b,
+          metadata.conditionalA.d,
+          metadata.conditionalA.u,
+          metadata.conditionalA.a
+        ),
+        mkOpinion(
+          metadata.conditionalNotA.b,
+          metadata.conditionalNotA.d,
+          metadata.conditionalNotA.u,
+          metadata.conditionalNotA.a
+        ),
+        targetOpinion.a
+      );
+      return annotateRationale(
+        {
+          opinion: deducedOpinion,
+          operator: "conditional_deduction",
+          rationale: `Conditional deduction: prerequisite at ${project(
+            dampedSource
+          ).toFixed(2)}`
+        },
+        context.spec,
+        context.hop
+      );
+    }
+    const result = dampedDependencyCascade(
+      dampedSource,
+      targetOpinion,
+      metadata.propagation ?? "continuous"
+    );
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Structural gating. Textbook conditional deduction when edge conditionals exist, otherwise damped dependency cascade through downstream chains."
+};
+
+// src/edges/derivedFrom.ts
+var derivedFromPropagationSpec = {
+  edgeType: "derived_from",
+  direction: "incoming",
+  transitivity: "none",
+  damping: 1,
+  maxHops: 1,
+  operator: () => null,
+  description: "Provenance only. The traversal surface stays explicit, but confidence does not move across derived_from edges."
+};
+
+// src/edges/elaborates.ts
+var elaboratesPropagationSpec = {
+  edgeType: "elaborates",
+  direction: "outgoing",
+  transitivity: "damped",
+  damping: 0.7,
+  maxHops: 2,
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const contextualWeight = Math.min(Math.abs(edge.weight ?? 0.35), 0.35);
+    const result = propagatePositiveInform(
+      dampedSource,
+      targetOpinion,
+      contextualWeight
+    );
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Context-rich supporting detail. Elaborates carries a small positive effect with short, damped chaining."
+};
+
+// src/edges/informs.ts
+var informsPropagationSpec = {
+  edgeType: "informs",
+  direction: "outgoing",
+  transitivity: "full",
+  damping: 0.92,
+  maxHops: "unbounded",
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const weight = edge.weight ?? 1;
+    const result = weight < 0 ? propagateNegativeInform(dampedSource, targetOpinion, weight) : propagatePositiveInform(dampedSource, targetOpinion, weight);
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Evidence-bearing influence. Informs can chain through the graph with light per-hop damping."
+};
+
+// src/edges/propagationTypes.ts
+function isPropagationTraversalDirection(direction) {
+  return direction === "outgoing" || direction === "incoming";
+}
+function canTraverseHop(spec, nextHop) {
+  return spec.maxHops === "unbounded" || nextHop <= spec.maxHops;
+}
+function canContinueTransitively(spec, currentHop) {
+  if (spec.transitivity === "none") {
+    return false;
+  }
+  return spec.maxHops === "unbounded" || currentHop < spec.maxHops;
+}
+
+// src/edges/refutes.ts
+var refutesPropagationSpec = {
+  edgeType: "refutes",
+  direction: "outgoing",
+  transitivity: "none",
+  damping: 0.9,
+  maxHops: 1,
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const negativeWeight = -Math.abs(edge.weight ?? 1);
+    const result = propagateNegativeInform(
+      dampedSource,
+      targetOpinion,
+      negativeWeight
+    );
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Explicit negative evidence semantics. Refutes is treated as strong one-hop counter-evidence."
+};
+
+// src/edges/supports.ts
+var supportsPropagationSpec = {
+  edgeType: "supports",
+  direction: "outgoing",
+  transitivity: "full",
+  damping: 0.85,
+  maxHops: "unbounded",
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const weight = edge.weight ?? 1;
+    const result = weight < 0 ? propagateNegativeSupportWithMetadata(
+      dampedSource,
+      targetOpinion,
+      weight,
+      edge
+    ) : propagatePositiveSupport(dampedSource, targetOpinion, weight);
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Belief-to-belief influence. Supports chains transitively with moderate per-hop damping."
+};
+
+// src/edges/tests.ts
+var testsPropagationSpec = {
+  edgeType: "tests",
+  direction: "outgoing",
+  transitivity: "none",
+  damping: 1,
+  maxHops: 1,
+  operator: () => null,
+  description: "Interrogation linkage only. Tests edges do not directly move confidence."
+};
+
+// src/edges/index.ts
+var EDGE_PROPAGATION_SPECS = [
+  supportsPropagationSpec,
+  informsPropagationSpec,
+  dependsOnPropagationSpec,
+  derivedFromPropagationSpec,
+  containsPropagationSpec,
+  testsPropagationSpec,
+  contradictsPropagationSpec,
+  refutesPropagationSpec,
+  elaboratesPropagationSpec
+];
+new Map(EDGE_PROPAGATION_SPECS.map((spec) => [spec.edgeType, spec]));
+function getEdgePropagationSpecs() {
+  return EDGE_PROPAGATION_SPECS;
+}
+function getTraversalDirections(direction) {
+  if (isPropagationTraversalDirection(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 readNodeOpinion(node) {
+  const metadata = 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 {
+    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;
+  };
+  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)
+              ])
+            });
+          }
+        }
+      }
+    }
+  }
+  return Array.from(dispatchesByTargetId.values()).sort((left, right) => {
+    if (left.hop !== right.hop) {
+      return left.hop - right.hop;
+    }
+    return String(left.targetNodeId).localeCompare(String(right.targetNodeId));
+  });
+}
+
+// src/epistemicBeliefs.confidence.ts
+async function applyBeliefConfidenceChange(ctx, args) {
+  const now = Date.now();
+  const node = await ctx.db.get(args.nodeId);
+  if (!node) {
+    throwStructuredMutationError({
+      message: "Node not found.",
+      status: 404,
+      code: "NOT_FOUND",
+      invariantCode: "belief.exists",
+      suggestion: "Verify nodeId points to an existing node before modulating confidence.",
+      details: { nodeId: args.nodeId }
+    });
+  }
+  if (node.nodeType !== "belief") {
+    throwStructuredMutationError({
+      message: `modulateConfidence 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. modulateConfidence 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 to modulate confidence.",
+      details: { nodeId: args.nodeId }
+    });
+  }
+  await requireProjectWriteAccess(
+    ctx,
+    node.projectId,
+    args.authenticatedUserId
+  );
+  const existingMetadata = node.metadata || {};
+  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 confidence modulation.",
+        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 isFirstScoring = typeof node.confidence !== "number" || !Number.isFinite(node.confidence);
+  const previousTupleContradicted = readTupleContradictedFlag(node.tupleContradicted) ?? readTupleContradictedFlag(existingMetadata.tupleContradicted) ?? detectTupleContradiction(
+    previousOpinion,
+    confidencePolicy.tupleContradiction.beliefThreshold,
+    confidencePolicy.tupleContradiction.disbeliefThreshold
+  );
+  const tupleTransition = evaluateTupleContradictionTransition({
+    previousTupleContradicted,
+    opinion: nextOpinion,
+    policy: confidencePolicy.tupleContradiction
+  });
+  const tupleContradictionDescription = formatTupleContradictionDescription({
+    opinion: nextOpinion,
+    policy: tupleTransition.policy
+  });
+  const newBeliefStatus = promoteBeliefStatusAfterScoring(currentBeliefStatus, {
+    confidence: derivedConfidence,
+    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
+      }
+    );
+  }
+  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,
+    metadata: {
+      ...existingMetadata,
+      beliefStatus: newBeliefStatus,
+      slBelief: slB,
+      slDisbelief: slD,
+      slUncertainty: slU,
+      slBaseRate: slA,
+      tupleContradicted: 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"
+        });
+      }
+    }
+  }
+  const storedRationale = args.rationale ?? `Confidence changed from ${previousConfidence.toFixed(2)} (nodeId: ${args.nodeId})`;
+  const beliefConfidenceId = await ctx.db.insert("beliefConfidence", {
+    ...buildBeliefConfidenceRow({
+      beliefId: args.nodeId,
+      belief: slB,
+      disbelief: slD,
+      uncertainty: slU,
+      baseRate: slA,
+      trigger: args.trigger,
+      rationale: storedRationale,
+      assessedBy: args.authenticatedUserId,
+      assessedAt: now,
+      slOperator: args.slOperator,
+      triggeringEvidenceId: args.triggeringEvidenceId,
+      triggeringContradictionId: tupleContradictionId,
+      triggeringWorktreeId: args.triggeringWorktreeId
+    })
+  });
+  await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+    nodeId: args.nodeId,
+    operation: "upsert"
+  });
+  await ctx.db.insert("epistemicAudit", {
+    entityType: "belief",
+    entityId: args.nodeId,
+    changeType: "confidence_changed",
+    previousState: {
+      confidence: previousConfidence,
+      tupleContradicted: previousTupleContradicted
+    },
+    newState: {
+      opinion: nextOpinion,
+      confidence: derivedConfidence,
+      trigger: args.trigger,
+      rationale: storedRationale,
+      tupleContradicted: tupleTransition.tupleContradicted,
+      tupleContradictionPolicy: tupleTransition.policy,
+      ...tupleContradictionId ? { tupleContradictionId: String(tupleContradictionId) } : {}
+    },
+    changedBy: args.authenticatedUserId,
+    isAgent: false,
+    changedAt: now,
+    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
+    });
+  }
+  if (Math.abs(derivedConfidence - previousConfidence) >= 0.15) {
+    await ctx.scheduler.runAfter(
+      5e3,
+      internal.bi.contradictionSemanticDetector.scanAffectedBeliefs,
+      {
+        beliefId: args.nodeId,
+        projectId: node.projectId
+      }
+    );
+  }
+  if (node.workspaceId && node.tenantId) {
+    await ctx.scheduler.runAfter(
+      0,
+      internal.publication.evaluateNodePublication,
+      { nodeId: args.nodeId }
+    );
+  }
+  return {
+    nodeId: args.nodeId,
+    previousConfidence,
+    newConfidence: derivedConfidence,
+    opinion: { b: slB, d: slD, u: slU, a: slA },
+    beliefConfidenceId
+  };
+}
+function propagationTriggerForEdge(edgeType, weight) {
+  if (edgeType === "contradicts" || edgeType === "refutes") {
+    return "contradiction_detected";
+  }
+  if ((edgeType === "supports" || edgeType === "informs") && weight < 0) {
+    return "contradiction_detected";
+  }
+  return "evidence_added";
+}
+internalMutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    opinion_b: v.number(),
+    opinion_d: v.number(),
+    opinion_u: v.number(),
+    opinion_a: v.number(),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const sourceOpinion = mkOpinion(
+      args.opinion_b,
+      args.opinion_d,
+      args.opinion_u,
+      args.opinion_a
+    );
+    const sourceNode = await ctx.db.get(args.nodeId);
+    const sourceScope = await resolveNodeScopeForWorkspaceIsolation(
+      ctx,
+      sourceNode
+    );
+    const dispatches = await collectConfidencePropagationDispatches({
+      sourceNodeId: args.nodeId,
+      sourceOpinion,
+      sourceScope,
+      queryEdges: async ({ nodeId, spec, direction }) => {
+        return 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)
+    });
+    for (const dispatch of dispatches) {
+      await applyBeliefConfidenceChange(ctx, {
+        nodeId: dispatch.targetNodeId,
+        belief: dispatch.opinion.b,
+        disbelief: dispatch.opinion.d,
+        uncertainty: dispatch.opinion.u,
+        baseRate: dispatch.opinion.a,
+        trigger: propagationTriggerForEdge(dispatch.edgeType, dispatch.weight),
+        rationale: `SL propagation via ${dispatch.edgeType} edge: ${dispatch.rationale}`,
+        authenticatedUserId: args.userId,
+        slOperator: dispatch.operator
+      });
+    }
+    return {
+      propagated: dispatches.map((dispatch) => ({
+        targetNodeId: String(dispatch.targetNodeId),
+        edgeType: dispatch.edgeType,
+        operator: dispatch.operator
+      })),
+      count: dispatches.length
+    };
+  }
+});
+
+// src/globalId.ts
+function generateGlobalId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(
+    ""
+  );
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// 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
+    });
+  }
+  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 = 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;
+  }
+  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
+    }
+  );
+  return {
+    evaluationId,
+    result: evaluation.result,
+    status: nextStatus,
+    confidenceBefore,
+    confidenceAfter,
+    rationale: evaluation.rationale,
+    data: evaluation.data,
+    currentConfidence: confidenceAfter
+  };
+}
+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
+    });
+  }
+  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
+      }
+    );
+  }
+  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
+  };
+}
+async function loadContractsForBelief(args) {
+  return await args.ctx.db.query("epistemicContracts").withIndex("by_belief", (q) => q.eq("beliefNodeId", args.beliefNodeId)).collect();
+}
+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;
+    }
+    if (contract.conditionType === "composite") {
+      return false;
+    }
+    if (!evaluatorRegistry.has(contract.condition.evaluator)) {
+      return false;
+    }
+    if (contractIdFilter) {
+      return contractIdFilter.has(contract.contractId);
+    }
+    return allowedSchedules.has(contract.evaluationSchedule);
+  });
+}
+
+// src/evaluators/shared.ts
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function deriveDirectionalResult(direction, conditionSatisfied) {
+  if (direction === "falsifies") {
+    return conditionSatisfied ? "disconfirmed" : "confirmed";
+  }
+  return conditionSatisfied ? "confirmed" : "disconfirmed";
+}
+function extractTextCandidates(value) {
+  const record = asRecord(value);
+  if (!record) {
+    const candidate = asString(value);
+    return candidate ? [candidate] : [];
+  }
+  const candidates = [
+    record.stdout,
+    record.stderr,
+    record.output,
+    record.text,
+    record.message,
+    record.raw
+  ].map(asString).filter((candidate) => Boolean(candidate));
+  for (const nestedKey of ["report", "result", "data", "payload"]) {
+    const nested = record[nestedKey];
+    if (nested !== value) {
+      candidates.push(...extractTextCandidates(nested));
+    }
+  }
+  return Array.from(new Set(candidates));
+}
+function normalizeFilePath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function normalizeToolResultEnvelope(value) {
+  const record = asRecord(value);
+  if (!record) {
+    return {
+      output: asString(value) ?? void 0
+    };
+  }
+  const exitCode = asNumber(record.exitCode) ?? asNumber(record.code) ?? asNumber(record.status) ?? null;
+  return {
+    command: asString(record.command) ?? void 0,
+    data: record.data ?? record.payload,
+    exitCode,
+    output: asString(record.output) ?? void 0,
+    report: record.report ?? record.json ?? record.result ?? record.payload ?? void 0,
+    stderr: asString(record.stderr) ?? void 0,
+    stdout: asString(record.stdout) ?? void 0
+  };
+}
+function parseJsonCandidate(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value !== "string") {
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[evaluators/shared] Failed to parse JSON candidate",
+      {
+        error,
+        valueType: typeof value
+      }
+    );
+    return null;
+  }
+}
+function patternMatchesPath(filePath, pattern) {
+  const normalizedPath = normalizeFilePath(filePath);
+  const normalizedPattern = normalizeFilePath(pattern);
+  const escaped = normalizedPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const regexPattern = escaped.replace(/\\\*\\\*/g, ".*").replace(/\\\*/g, "[^/]*").replace(/\\\?/g, "[^/]");
+  return new RegExp(`^${regexPattern}$`).test(normalizedPath);
+}
+function somePatternMatches(filePath, patterns) {
+  if (!filePath) {
+    return false;
+  }
+  return patterns.some((pattern) => patternMatchesPath(filePath, pattern));
+}
+
+// src/evaluators/lintCheckerEvaluator.ts
+function parseConfig(condition) {
+  const record = asRecord(condition.evaluatorConfig);
+  if (!record) {
+    throw new Error(
+      'lint_checker requires evaluatorConfig with { filePatterns: string[], linter: "biome" }.'
+    );
+  }
+  const filePatterns = asArray(record.filePatterns).map(asString).filter((pattern) => Boolean(pattern));
+  if (filePatterns.length === 0) {
+    throw new Error("lint_checker requires at least one file pattern.");
+  }
+  const linter = asString(record.linter);
+  if (linter !== "biome") {
+    throw new Error(`Unsupported linter: ${String(record.linter)}`);
+  }
+  return {
+    filePatterns,
+    linter
+  };
+}
+function parseDiagnostics(resultData) {
+  const envelope = normalizeToolResultEnvelope(resultData);
+  const record = asRecord(envelope.report) ?? asRecord(envelope.data) ?? asRecord(resultData);
+  if (!record) {
+    return [];
+  }
+  return asArray(record.diagnostics).map((entry) => {
+    const diagnostic = asRecord(entry);
+    if (!diagnostic) {
+      return null;
+    }
+    const location = asRecord(diagnostic.location);
+    const pathRecord = asRecord(location?.path);
+    const filePath = asString(diagnostic.filePath) ?? asString(diagnostic.file) ?? asString(location?.filePath) ?? asString(pathRecord?.file);
+    const severity = asString(diagnostic.severity) ?? "error";
+    const message = asString(diagnostic.message) ?? asString(diagnostic.description) ?? "Lint issue";
+    return {
+      filePath: filePath ? normalizeFilePath(filePath) : null,
+      message,
+      severity
+    };
+  }).filter(
+    (diagnostic) => Boolean(diagnostic)
+  );
+}
+function getMatchedDiagnostics(contract, resultData) {
+  const config = parseConfig(contract.condition);
+  return parseDiagnostics(resultData).filter(
+    (diagnostic) => somePatternMatches(diagnostic.filePath, config.filePatterns)
+  );
+}
+var lintCheckerEvaluator = {
+  name: "lint_checker",
+  matches({ contract, resultData }) {
+    const envelope = normalizeToolResultEnvelope(resultData);
+    const exitCode = asNumber(envelope.exitCode);
+    if (exitCode === 0) {
+      return true;
+    }
+    return getMatchedDiagnostics(contract, resultData).length > 0;
+  },
+  evaluate(args) {
+    const config = parseConfig(args.contract.condition);
+    if (!args.resultData) {
+      return {
+        result: "error",
+        rationale: "lint_checker requires Biome lint resultData."
+      };
+    }
+    const envelope = normalizeToolResultEnvelope(args.resultData);
+    const exitCode = asNumber(envelope.exitCode);
+    const matchedDiagnostics = getMatchedDiagnostics(args.contract, args.resultData);
+    if (matchedDiagnostics.length === 0 && exitCode !== 0 && exitCode !== null) {
+      return {
+        result: "inconclusive",
+        rationale: "Biome reported issues, 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 ? `Biome reported no matching lint diagnostics for ${config.filePatterns.join(", ")}.` : `Biome reported ${matchedDiagnostics.length} matching issue(s): ${matchedDiagnostics.map(
+        (diagnostic) => diagnostic.filePath ? `${diagnostic.filePath} (${diagnostic.severity})` : diagnostic.message
+      ).join(", ")}.`,
+      data: {
+        exitCode,
+        filePatterns: config.filePatterns,
+        linter: config.linter,
+        matchedDiagnostics
+      }
+    };
+  }
+};
+
+// src/evaluators/sentryCheckerEvaluator.ts
+function parseConfig2(condition) {
+  const record = asRecord(condition.evaluatorConfig);
+  if (!record) {
+    throw new Error(
+      "sentry_checker requires evaluatorConfig with { module, windowDays }."
+    );
+  }
+  const moduleName = asString(record.module);
+  const windowDays = asNumber(record.windowDays);
+  if (!moduleName || windowDays === null) {
+    throw new Error(
+      "sentry_checker requires a module name and numeric windowDays."
+    );
+  }
+  return {
+    module: moduleName,
+    windowDays
+  };
+}
+function parseIncidentCount(resultData) {
+  const envelope = normalizeToolResultEnvelope(resultData);
+  const record = asRecord(envelope.report) ?? asRecord(envelope.data) ?? asRecord(resultData);
+  if (!record) {
+    return {
+      incidentCount: null,
+      moduleName: null,
+      windowDays: null
+    };
+  }
+  const incidents = asArray(record.incidents);
+  const incidentCount = asNumber(record.incidentCount) ?? (incidents.length > 0 ? incidents.length : null);
+  return {
+    incidentCount,
+    moduleName: asString(record.module),
+    windowDays: asNumber(record.windowDays)
+  };
+}
+function matchesModule(contract, resultData) {
+  const config = parseConfig2(contract.condition);
+  const payload = parseIncidentCount(resultData);
+  return !payload.moduleName || payload.moduleName === config.module;
+}
+var sentryCheckerEvaluator = {
+  name: "sentry_checker",
+  matches({ contract, resultData }) {
+    return matchesModule(contract, resultData);
+  },
+  evaluate(args) {
+    const config = parseConfig2(args.contract.condition);
+    if (!args.resultData) {
+      return {
+        result: "error",
+        rationale: "sentry_checker requires incident count resultData."
+      };
+    }
+    const payload = parseIncidentCount(args.resultData);
+    if (payload.incidentCount === null) {
+      return {
+        result: "error",
+        rationale: "sentry_checker could not determine an incident count."
+      };
+    }
+    if (!matchesModule(args.contract, args.resultData)) {
+      return {
+        result: "inconclusive",
+        rationale: `Sentry result targeted ${payload.moduleName}, not ${config.module}.`
+      };
+    }
+    const conditionSatisfied = payload.incidentCount === 0;
+    return {
+      result: deriveDirectionalResult(
+        args.contract.direction,
+        conditionSatisfied
+      ),
+      rationale: conditionSatisfied ? `Sentry reported zero incidents for ${config.module} over ${config.windowDays} day(s).` : `Sentry reported ${payload.incidentCount} incident(s) for ${config.module} over ${config.windowDays} day(s).`,
+      data: {
+        incidentCount: payload.incidentCount,
+        module: config.module,
+        windowDays: config.windowDays
+      }
+    };
+  }
+};
+
+// src/evaluators/testRunnerEvaluator.ts
+function parseConfig3(condition) {
+  const record = asRecord(condition.evaluatorConfig);
+  if (!record) {
+    throw new Error(
+      'test_runner requires evaluatorConfig with { testPattern, runner: "vitest" }.'
+    );
+  }
+  const testPattern = asString(record.testPattern);
+  if (!testPattern) {
+    throw new Error("test_runner requires a non-empty testPattern.");
+  }
+  const runner = asString(record.runner);
+  if (runner !== "vitest") {
+    throw new Error(`Unsupported test runner: ${String(record.runner)}`);
+  }
+  return {
+    runner,
+    testPattern
+  };
+}
+function collectFailedTests(value) {
+  const record = asRecord(value);
+  if (!record) {
+    return [];
+  }
+  const fullName = asString(record.fullName);
+  const title = asString(record.title);
+  const label = fullName ?? title ?? "unnamed test";
+  const status = asString(record.status);
+  const state = asString(asRecord(record.result)?.state);
+  const isFailed = status === "failed" || status === "fail" || state === "failed" || state === "fail";
+  const failures = isFailed ? [label] : [];
+  for (const nestedKey of ["assertionResults", "tests", "tasks"]) {
+    for (const nested of asArray(record[nestedKey])) {
+      failures.push(...collectFailedTests(nested));
+    }
+  }
+  return failures;
+}
+function collectPassedTests(value) {
+  const record = asRecord(value);
+  if (!record) {
+    return [];
+  }
+  const fullName = asString(record.fullName);
+  const title = asString(record.title);
+  const label = fullName ?? title ?? "unnamed test";
+  const status = asString(record.status);
+  const state = asString(asRecord(record.result)?.state);
+  const isPassed = status === "passed" || state === "passed";
+  const passed = isPassed ? [label] : [];
+  for (const nestedKey of ["assertionResults", "tests", "tasks"]) {
+    for (const nested of asArray(record[nestedKey])) {
+      passed.push(...collectPassedTests(nested));
+    }
+  }
+  return passed;
+}
+function parseSuite(value) {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+  const filePath = asString(record.name) ?? asString(record.file) ?? asString(record.filePath) ?? asString(record.filepath);
+  if (!filePath) {
+    return null;
+  }
+  return {
+    failedTests: Array.from(new Set(collectFailedTests(record))),
+    filePath: normalizeFilePath(filePath),
+    passedTests: Array.from(new Set(collectPassedTests(record)))
+  };
+}
+function parseVitestSuites(resultData) {
+  const envelope = normalizeToolResultEnvelope(resultData);
+  const candidates = [
+    envelope.report,
+    envelope.data,
+    envelope.stdout,
+    envelope.output,
+    ...extractTextCandidates(resultData)
+  ];
+  for (const candidate of candidates) {
+    const parsed = parseJsonCandidate(candidate);
+    const report = asRecord(parsed);
+    if (!report) {
+      continue;
+    }
+    const suites = asArray(report.testResults).map(parseSuite).filter((suite) => Boolean(suite));
+    if (suites.length > 0) {
+      return suites;
+    }
+    const fileSuites = asArray(report.files).map(parseSuite).filter((suite) => Boolean(suite));
+    if (fileSuites.length > 0) {
+      return fileSuites;
+    }
+  }
+  return [];
+}
+function getMatchedSuites(contract, resultData) {
+  const config = parseConfig3(contract.condition);
+  return parseVitestSuites(resultData).filter(
+    (suite) => patternMatchesPath(suite.filePath, config.testPattern)
+  );
+}
+var testRunnerEvaluator = {
+  name: "test_runner",
+  matches({ contract, resultData }) {
+    return getMatchedSuites(contract, resultData).length > 0;
+  },
+  evaluate(args) {
+    const config = parseConfig3(args.contract.condition);
+    const matchedSuites = getMatchedSuites(args.contract, args.resultData);
+    if (!args.resultData) {
+      return {
+        result: "error",
+        rationale: "test_runner requires Vitest JSON resultData."
+      };
+    }
+    if (matchedSuites.length === 0) {
+      return {
+        result: "inconclusive",
+        rationale: `No Vitest suites matched ${config.testPattern}.`
+      };
+    }
+    const failedTests = matchedSuites.flatMap((suite) => suite.failedTests);
+    const passedTests = matchedSuites.flatMap((suite) => suite.passedTests);
+    const conditionSatisfied = failedTests.length === 0;
+    return {
+      result: deriveDirectionalResult(
+        args.contract.direction,
+        conditionSatisfied
+      ),
+      rationale: conditionSatisfied ? `Vitest matched ${matchedSuites.length} suite(s) for ${config.testPattern}; all ${passedTests.length} test assertions passed.` : `Vitest matched ${matchedSuites.length} suite(s) for ${config.testPattern}; failing tests: ${failedTests.join(", ")}.`,
+      data: {
+        runner: config.runner,
+        testPattern: config.testPattern,
+        matchedFiles: matchedSuites.map((suite) => suite.filePath),
+        failedTests,
+        passedTestCount: passedTests.length
+      }
+    };
+  }
+};
+
+// src/evaluators/tscCheckerEvaluator.ts
+function parseConfig4(condition) {
+  const record = asRecord(condition.evaluatorConfig);
+  if (!record) {
+    throw new Error(
+      "tsc_checker requires evaluatorConfig with { filePatterns: string[] }."
+    );
+  }
+  const filePatterns = asArray(record.filePatterns).map(asString).filter((pattern) => Boolean(pattern));
+  if (filePatterns.length === 0) {
+    throw new Error("tsc_checker requires at least one file pattern.");
+  }
+  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.handlers.ts
+function resolveSchedulesForTrigger2(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 requireAuth(ctx) {
+  const userId = await getCurrentUserId(ctx);
+  if (!userId) {
+    throw new Error("Authentication required.");
+  }
+  return userId;
+}
+async function resolveAuthenticatedUserId(ctx, explicitUserId) {
+  if (explicitUserId) {
+    return explicitUserId;
+  }
+  return requireAuth(ctx);
+}
+async function requireBeliefProjectAccess(ctx, belief, userId) {
+  if (!belief.projectId) {
+    throw new Error("Belief has no project scope.");
+  }
+  const hasAccess = await checkProjectAccess(
+    ctx,
+    belief.projectId,
+    userId
+  );
+  if (!hasAccess) {
+    throw new Error("Project access required.");
+  }
+}
+async function requireTopicReadAccess(ctx, beliefs, userId) {
+  const projectIds = /* @__PURE__ */ new Set();
+  for (const belief of beliefs) {
+    if (!belief.projectId) {
+      throw new Error("Belief has no project scope.");
+    }
+    projectIds.add(belief.projectId);
+  }
+  for (const projectId of projectIds) {
+    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();
+}
+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);
+  return evaluations[0] ?? null;
+}
+var evaluateEvidenceCount = query({
+  args: {
+    beliefNodeId: v.id("epistemicNodes")
+  },
+  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.");
+    }
+    await requireBeliefProjectAccess(ctx, belief, userId);
+    return await computeEvidenceCountMetric(ctx, args.beliefNodeId);
+  }
+});
+var evaluateContradictionStatus = query({
+  args: {
+    beliefNodeId: v.id("epistemicNodes")
+  },
+  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.");
+    }
+    await requireBeliefProjectAccess(ctx, belief, userId);
+    return await computeContradictionCounts(ctx, args.beliefNodeId);
+  }
+});
+var evaluateEdgeFreshness = query({
+  args: {
+    beliefNodeId: v.id("epistemicNodes")
+  },
+  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.");
+    }
+    await requireBeliefProjectAccess(ctx, belief, userId);
+    return await computeEvidenceFreshness(ctx, args.beliefNodeId);
+  }
+});
+var evaluateDependentBeliefCount = query({
+  args: {
+    beliefNodeId: v.id("epistemicNodes")
+  },
+  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.");
+    }
+    await requireBeliefProjectAccess(ctx, belief, userId);
+    return await computeDependentBeliefCount(ctx, args.beliefNodeId);
+  }
+});
+var createEpistemicContract = mutation({
+  args: {
+    beliefNodeId: v.id("epistemicNodes"),
+    title: v.string(),
+    description: v.optional(v.string()),
+    conditionType: v.union(
+      v.literal("assertion"),
+      v.literal("temporal"),
+      v.literal("evidential"),
+      v.literal("threshold"),
+      v.literal("composite")
+    ),
+    direction: v.union(v.literal("confirms"), v.literal("falsifies")),
+    condition: v.object({
+      expression: v.string(),
+      evaluator: v.string(),
+      evaluatorConfig: v.optional(v.any())
+    }),
+    deadline: v.optional(v.number()),
+    compositeOf: v.optional(v.array(v.string())),
+    compositeOperator: v.optional(
+      v.union(v.literal("all"), v.literal("any"), v.literal("majority"))
+    ),
+    modulation: v.object({
+      onConfirmed: v.object({
+        delta: v.number(),
+        ceiling: v.optional(v.number())
+      }),
+      onDisconfirmed: v.object({
+        delta: v.number(),
+        floor: v.optional(v.number())
+      }),
+      onExpired: v.optional(
+        v.object({
+          delta: v.number()
+        })
+      ),
+      onPartial: v.optional(
+        v.object({
+          threshold: v.number(),
+          delta: v.number()
+        })
+      )
+    }),
+    evaluationSchedule: v.union(
+      v.literal("on_demand"),
+      v.literal("on_evidence"),
+      v.literal("periodic"),
+      v.literal("event_driven")
+    ),
+    periodicIntervalMs: v.optional(v.number()),
+    authenticatedUserId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const userId = await resolveAuthenticatedUserId(
+      ctx,
+      args.authenticatedUserId
+    );
+    const belief = await ctx.db.get(args.beliefNodeId);
+    if (!belief || belief.nodeType !== "belief") {
+      throw new Error("Belief not found.");
+    }
+    await requireBeliefProjectAccess(ctx, belief, userId);
+    const now = Date.now();
+    const contractId = generateGlobalId();
+    const contractDoc = {
+      beliefNodeId: args.beliefNodeId,
+      contractId,
+      title: args.title,
+      description: args.description,
+      conditionType: args.conditionType,
+      direction: args.direction,
+      condition: args.condition,
+      deadline: args.deadline,
+      compositeOf: args.compositeOf,
+      compositeOperator: args.compositeOperator,
+      modulation: args.modulation,
+      evaluationSchedule: args.evaluationSchedule,
+      periodicIntervalMs: args.periodicIntervalMs,
+      status: "active",
+      lineageSource: "declared",
+      evaluationCount: 0,
+      topicId: belief.topicId,
+      createdAt: now,
+      createdBy: userId,
+      updatedAt: now
+    };
+    const insertedId = await ctx.db.insert(
+      "epistemicContracts",
+      contractDoc
+    );
+    return {
+      contractId,
+      id: insertedId,
+      status: contractDoc.status
+    };
+  }
+});
+var evaluateContract = mutation({
+  args: {
+    contractId: v.string(),
+    resultData: v.optional(v.any()),
+    trigger: v.optional(v.string()),
+    inputData: v.optional(v.any()),
+    authenticatedUserId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const userId = await resolveAuthenticatedUserId(
+      ctx,
+      args.authenticatedUserId
+    );
+    const contract = await getContractByContractId(ctx, args.contractId);
+    if (!contract) {
+      throw new Error(`Contract not found: ${args.contractId}`);
+    }
+    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.");
+    }
+    await requireBeliefProjectAccess(ctx, belief, userId);
+    const evaluation = await executeContractEvaluation({
+      ctx,
+      belief,
+      contract,
+      now: Date.now(),
+      resultData: args.resultData,
+      trigger: args.trigger ?? "manual",
+      inputData: args.inputData,
+      authenticatedUserId: userId
+    });
+    return {
+      evaluationId: evaluation.evaluationId,
+      result: evaluation.result,
+      status: evaluation.status,
+      confidenceBefore: evaluation.confidenceBefore,
+      confidenceAfter: evaluation.confidenceAfter,
+      rationale: evaluation.rationale
+    };
+  }
+});
+var evaluateEngineeringContracts = mutation({
+  args: {
+    beliefNodeId: v.id("epistemicNodes"),
+    testOutput: v.optional(v.any()),
+    tscOutput: v.optional(v.any()),
+    lintOutput: v.optional(v.any()),
+    sentryData: v.optional(v.any()),
+    trigger: v.optional(v.string()),
+    authenticatedUserId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const userId = await resolveAuthenticatedUserId(
+      ctx,
+      args.authenticatedUserId
+    );
+    const belief = await ctx.db.get(args.beliefNodeId);
+    if (!belief || belief.nodeType !== "belief") {
+      throw new Error("Belief not found.");
+    }
+    await requireBeliefProjectAccess(ctx, belief, userId);
+    const trigger = args.trigger ?? "event_driven";
+    const allowedSchedules = resolveSchedulesForTrigger2(
+      trigger === "manual" ? "manual" : trigger === "evidence_added" ? "evidence_added" : trigger
+    );
+    const payloadByEvaluator = /* @__PURE__ */ new Map([
+      ["test_runner", args.testOutput],
+      ["tsc_checker", args.tscOutput],
+      ["lint_checker", args.lintOutput],
+      ["sentry_checker", args.sentryData]
+    ]);
+    const contracts = (await loadContractsForBelief({
+      ctx,
+      beliefNodeId: args.beliefNodeId
+    })).filter((contract) => {
+      if (contract.status === "archived") {
+        return false;
+      }
+      if (!allowedSchedules.has(contract.evaluationSchedule)) {
+        return false;
+      }
+      return ENGINEERING_EVALUATOR_NAMES.has(contract.condition.evaluator);
+    });
+    let runningConfidence = typeof belief.confidence === "number" ? belief.confidence : 0.5;
+    const evaluations = [];
+    for (const contract of contracts) {
+      const resultData = payloadByEvaluator.get(contract.condition.evaluator);
+      if (resultData === void 0) {
+        continue;
+      }
+      const engineeringEvaluator = getEngineeringEpistemicEvaluator(
+        contract.condition.evaluator
+      );
+      if (!engineeringEvaluator?.matches({ contract, resultData })) {
+        continue;
+      }
+      const evaluation = await executeContractEvaluation({
+        ctx,
+        belief,
+        contract,
+        now: Date.now(),
+        trigger,
+        authenticatedUserId: userId,
+        currentConfidence: runningConfidence,
+        resultData
+      });
+      runningConfidence = evaluation.currentConfidence;
+      belief.confidence = runningConfidence;
+      evaluations.push({
+        contractId: contract.contractId,
+        evaluator: contract.condition.evaluator,
+        evaluationId: evaluation.evaluationId,
+        result: evaluation.result,
+        status: evaluation.status,
+        confidenceBefore: evaluation.confidenceBefore,
+        confidenceAfter: evaluation.confidenceAfter,
+        rationale: evaluation.rationale
+      });
+    }
+    return {
+      beliefNodeId: args.beliefNodeId,
+      trigger,
+      availableContracts: contracts.length,
+      evaluatedContracts: evaluations.length,
+      evaluations
+    };
+  }
+});
+var evaluateContractsForTrigger = mutation({
+  args: {
+    beliefNodeId: v.id("epistemicNodes"),
+    trigger: v.string(),
+    inputData: v.optional(v.any()),
+    maxBatchSize: v.optional(v.number()),
+    authenticatedUserId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const userId = await resolveAuthenticatedUserId(
+      ctx,
+      args.authenticatedUserId
+    );
+    const belief = await ctx.db.get(args.beliefNodeId);
+    if (!belief || belief.nodeType !== "belief") {
+      throw new Error("Belief not found.");
+    }
+    await requireBeliefProjectAccess(ctx, belief, userId);
+    return await evaluateContractsForTriggerBatch({
+      ctx,
+      belief,
+      trigger: args.trigger,
+      inputData: args.inputData,
+      authenticatedUserId: userId,
+      maxBatchSize: args.maxBatchSize
+    });
+  }
+});
+var processContractEvaluationOverflow = internalMutation({
+  args: {
+    beliefNodeId: v.id("epistemicNodes"),
+    trigger: v.string(),
+    contractIds: v.array(v.string()),
+    inputData: v.optional(v.any()),
+    authenticatedUserId: v.string(),
+    maxBatchSize: v.optional(v.number())
+  },
+  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.");
+    }
+    return await evaluateContractsForTriggerBatch({
+      ctx,
+      belief,
+      trigger: args.trigger,
+      inputData: args.inputData,
+      authenticatedUserId: args.authenticatedUserId,
+      contractIds: args.contractIds,
+      maxBatchSize: args.maxBatchSize
+    });
+  }
+});
+var getContractStatus = query({
+  args: {
+    beliefNodeId: v.optional(v.id("epistemicNodes")),
+    contractId: v.optional(v.string()),
+    status: v.optional(
+      v.union(
+        v.literal("active"),
+        v.literal("satisfied"),
+        v.literal("violated"),
+        v.literal("expired"),
+        v.literal("suspended"),
+        v.literal("archived")
+      )
+    ),
+    authenticatedUserId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const userId = await resolveAuthenticatedUserId(
+      ctx,
+      args.authenticatedUserId
+    );
+    let contracts = [];
+    if (args.contractId) {
+      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.");
+      }
+      await requireBeliefProjectAccess(ctx, belief, userId);
+      contracts = await ctx.db.query("epistemicContracts").withIndex(
+        "by_belief",
+        (q) => q.eq("beliefNodeId", args.beliefNodeId)
+      ).collect();
+    }
+    if (contracts.length > 0) {
+      const contractBeliefDocs = await Promise.all(
+        contracts.map((contract) => ctx.db.get(contract.beliefNodeId))
+      );
+      const contractBeliefs = [];
+      for (const belief of contractBeliefDocs) {
+        if (!belief || belief.nodeType !== "belief") {
+          throw new Error("Belief not found.");
+        }
+        contractBeliefs.push(belief);
+      }
+      await requireTopicReadAccess(ctx, contractBeliefs, userId);
+    }
+    if (args.status) {
+      contracts = contracts.filter((contract) => contract.status === args.status);
+    }
+    const rows = await Promise.all(
+      contracts.map(async (contract) => ({
+        ...contract,
+        latestEvaluation: await getLatestEvaluation(ctx, contract.contractId)
+      }))
+    );
+    return rows.sort((a, b) => b.createdAt - a.createdAt);
+  }
+});
+var getContractCoverage = query({
+  args: {
+    topicId: v.string(),
+    recentEvaluationLimit: v.optional(v.number()),
+    authenticatedUserId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const contracts = await ctx.db.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(
+      "by_topic_type",
+      (q) => q.eq("topicId", args.topicId).eq("nodeType", "belief")
+    ).collect();
+    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 contractBeliefIds = new Set(
+      contracts.filter((contract) => contract.status !== "archived").map((contract) => String(contract.beliefNodeId))
+    );
+    return {
+      active: contracts.filter((contract) => contract.status === "active").length,
+      violated: contracts.filter((contract) => contract.status === "violated").length,
+      expired: contracts.filter((contract) => contract.status === "expired").length,
+      unboundHighConfidence: beliefs.filter(
+        (belief) => typeof belief.confidence === "number" && belief.confidence >= 0.8 && !contractBeliefIds.has(String(belief._id))
+      ).map((belief) => ({
+        nodeId: belief._id,
+        canonicalText: belief.canonicalText,
+        confidence: belief.confidence
+      })),
+      recentEvaluations
+    };
+  }
+});
+function inheritContractsForFork(contracts, args) {
+  return contracts.filter((contract) => contract.status !== "archived").map((contract) => createInheritedContractRecord(contract, args));
+}
+
+export { createEpistemicContract, evaluateContract, evaluateContractsForTrigger, evaluateContradictionStatus, evaluateDependentBeliefCount, evaluateEdgeFreshness, evaluateEngineeringContracts, evaluateEvidenceCount, getContractCoverage, getContractStatus, inheritContractsForFork, processContractEvaluationOverflow };
+//# sourceMappingURL=epistemicContracts.handlers.js.map
+//# sourceMappingURL=epistemicContracts.handlers.js.map