@lucern/graph-primitives 1.0.0 → 1.0.1

package/dist/epistemicBeliefs.lifecycle.js

@@ -0,0 +1,1608 @@
+import { v } from 'convex/values';
+import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
+import { componentsGeneric, anyApi, internalMutationGeneric, mutationGeneric } from 'convex/server';
+import '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
+import { normalizeTupleContradictionPolicy, mkOpinion, conditionalDeduction, project, dampedDependencyCascade, hasProjectedOpinionChanged, confidenceFromSL, detectTupleContradiction, evaluateTupleContradictionTransition, trustDiscount, applyNegativeSupport, cumulativeFusion, applyNegativeEvidence, readOpinionFromRecord } from '@lucern/confidence';
+import { checkProjectAccess } from '@lucern/access-control/access';
+import '@lucern/access-control/audience';
+import { getCurrentUserId } from '@lucern/access-control/auth';
+
+// src/epistemicBeliefs.lifecycle.ts
+var api = anyApi;
+componentsGeneric();
+var internal = anyApi;
+var internalMutation = internalMutationGeneric;
+var mutation = mutationGeneric;
+
+// src/debug.ts
+function isGraphPrimitiveDebugEnabled() {
+  const env = globalThis.process?.env;
+  return env?.LUCERN_COMPAT_FALLBACK_DEBUG === "1" || env?.LUCERN_GRAPH_DEBUG === "1";
+}
+function debugGraphPrimitiveFallback(message, context) {
+  if (!isGraphPrimitiveDebugEnabled()) {
+    return;
+  }
+  console.debug(message, context ?? {});
+}
+
+// src/topicScope.ts
+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())
+});
+
+// src/workspaceIsolation.ts
+function normalizeScopeValue2(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function throwWorkspaceIsolationError(args) {
+  const error = new Error(args.message);
+  error.status = 409;
+  error.code = "INVARIANT_VIOLATION";
+  error.invariantCode = args.invariantCode;
+  error.suggestion = args.suggestion;
+  error.details = args.details;
+  throw error;
+}
+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;
+}
+function resolveRuntimePackMutationContext(args) {
+  if (!args.runtimeToolName && !args.runtimePackKey && !args.runtimePackInstallScope) {
+    return;
+  }
+  return {
+    toolName: args.runtimeToolName,
+    packKey: args.runtimePackKey,
+    packInstallScope: args.runtimePackInstallScope
+  };
+}
+function assertTenantPackWorkspaceMutationAllowed(args) {
+  if (!args.runtime?.packKey || args.runtime.packInstallScope !== "tenant") {
+    return;
+  }
+  const targetWorkspaceId = normalizeScopeValue2(args.target.workspaceId);
+  const targetLayer = typeof args.target.epistemicLayer === "string" ? args.target.epistemicLayer : void 0;
+  if (!targetWorkspaceId || targetLayer === "ontological") {
+    return;
+  }
+  throwWorkspaceIsolationError({
+    message: `Tenant-scoped pack "${args.runtime.packKey}" cannot mutate workspace-scoped reasoning state.`,
+    invariantCode: "workspace.tenant_pack_reasoning_write_forbidden",
+    suggestion: "Use a workspace-scoped pack for workspace-local graph mutations, or route the change through tenant-global canonical entity flows.",
+    details: {
+      mutationName: args.mutationName,
+      toolName: args.runtime.toolName,
+      packKey: args.runtime.packKey,
+      targetWorkspaceId,
+      targetNodeType: args.target.nodeType,
+      targetLayer
+    }
+  });
+}
+
+// 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";
+}
+
+// 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));
+  });
+}
+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 requireAuthenticatedUserId(ctx) {
+  const userId = await getCurrentUserId(
+    ctx
+  );
+  if (!userId) {
+    throwStructuredMutationError({
+      message: "Authentication required.",
+      status: 401,
+      code: "AUTHENTICATION_REQUIRED",
+      invariantCode: "auth.required",
+      suggestion: "Provide a valid bearer token before invoking belief mutations."
+    });
+  }
+  return userId;
+}
+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/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/epistemicBeliefs.lifecycle.ts
+var modulateConfidence = mutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    // SL opinion — the ONLY confidence input (EK-7)
+    belief: v.number(),
+    // b: evidence FOR [0,1]
+    disbelief: v.number(),
+    // d: evidence AGAINST [0,1]
+    uncertainty: v.number(),
+    // u: lack of evidence [0,1]
+    baseRate: v.number(),
+    // a: prior probability [0,1]
+    trigger: v.union(
+      v.literal("evidence_added"),
+      v.literal("evidence_removed"),
+      v.literal("contradiction_detected"),
+      v.literal("contradiction_resolved"),
+      v.literal("manual"),
+      v.literal("decay"),
+      v.literal("agent_assessment"),
+      v.literal("worktree_outcome"),
+      v.literal("worktree_completed"),
+      // SL-specific triggers
+      v.literal("fusion"),
+      v.literal("discount"),
+      v.literal("deduction"),
+      v.literal("backfill_synthetic")
+    ),
+    rationale: v.optional(v.string()),
+    userId: v.string(),
+    // SL operator provenance (optional — defaults to manual_assessment)
+    slOperator: v.optional(
+      v.union(
+        v.literal("cumulative_fusion"),
+        v.literal("averaging_fusion"),
+        v.literal("trust_discount"),
+        v.literal("conditional_deduction"),
+        v.literal("dependency_cascade"),
+        v.literal("negation"),
+        v.literal("constraint_fusion"),
+        v.literal("manual_assessment")
+      )
+    ),
+    triggeringEvidenceId: v.optional(v.id("epistemicNodes")),
+    triggeringWorktreeId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const result = await applyBeliefConfidenceChange(ctx, {
+      nodeId: args.nodeId,
+      belief: args.belief,
+      disbelief: args.disbelief,
+      uncertainty: args.uncertainty,
+      baseRate: args.baseRate,
+      trigger: args.trigger,
+      rationale: args.rationale,
+      authenticatedUserId,
+      slOperator: args.slOperator,
+      triggeringEvidenceId: args.triggeringEvidenceId,
+      triggeringWorktreeId: args.triggeringWorktreeId
+    });
+    if (Math.abs(result.newConfidence - result.previousConfidence) >= 0.01) {
+      await ctx.scheduler.runAfter(
+        0,
+        internal.epistemicBeliefs.propagateConfidenceChange,
+        {
+          nodeId: args.nodeId,
+          opinion_b: args.belief,
+          opinion_d: args.disbelief,
+          opinion_u: args.uncertainty,
+          opinion_a: args.baseRate ?? 0.5,
+          userId: authenticatedUserId
+        }
+      );
+    }
+    return {
+      nodeId: result.nodeId,
+      previousConfidence: result.previousConfidence,
+      newConfidence: result.newConfidence,
+      opinion: result.opinion
+    };
+  }
+});
+var updateStatus = mutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    status: v.union(
+      v.literal("active"),
+      v.literal("superseded"),
+      v.literal("archived")
+    ),
+    reason: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const now = Date.now();
+    const node = await ctx.db.get(args.nodeId);
+    if (!node || node.nodeType !== "belief") {
+      throw new Error("Belief not found");
+    }
+    if (!node.projectId) {
+      throw new Error("Belief has no project scope");
+    }
+    await requireProjectWriteAccess(ctx, node.projectId, authenticatedUserId);
+    const previousStatus = node.status;
+    const metadata = node.metadata || {};
+    await ctx.db.patch(args.nodeId, {
+      status: args.status,
+      updatedAt: now,
+      metadata: {
+        ...metadata,
+        status: args.status
+      }
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: args.nodeId,
+      operation: "upsert"
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "belief",
+      entityId: args.nodeId,
+      changeType: "status_changed",
+      previousState: { status: previousStatus },
+      newState: { status: args.status, reason: args.reason },
+      changedBy: authenticatedUserId,
+      isAgent: false,
+      changedAt: now,
+      projectId: node.projectId
+    });
+    return { nodeId: args.nodeId, previousStatus, newStatus: args.status };
+  }
+});
+var archive = mutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    reason: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const node = await ctx.db.get(args.nodeId);
+    if (!node || node.nodeType !== "belief") {
+      throw new Error("Belief not found");
+    }
+    if (!node.projectId) {
+      throw new Error("Belief has no project scope");
+    }
+    await requireProjectWriteAccess(ctx, node.projectId, authenticatedUserId);
+    return await ctx.runMutation(
+      // Use updateStatus internally
+      internal.epistemicBeliefs.updateStatusInternal,
+      {
+        nodeId: args.nodeId,
+        status: "archived",
+        reason: args.reason,
+        userId: authenticatedUserId
+      }
+    );
+  }
+});
+var updateRationale = mutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    rationale: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const now = Date.now();
+    const node = await ctx.db.get(args.nodeId);
+    if (!node || node.nodeType !== "belief") {
+      throw new Error("Belief not found");
+    }
+    if (!node.projectId) {
+      throw new Error("Belief has no project scope");
+    }
+    await requireProjectWriteAccess(ctx, node.projectId, authenticatedUserId);
+    const metadata = node.metadata || {};
+    const previousRationale = typeof metadata.rationale === "string" ? metadata.rationale : void 0;
+    const nextRationale = args.rationale?.trim();
+    await ctx.db.patch(args.nodeId, {
+      metadata: {
+        ...metadata,
+        rationale: nextRationale && nextRationale.length > 0 ? nextRationale : void 0
+      },
+      updatedAt: now
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: args.nodeId,
+      operation: "upsert"
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "belief",
+      entityId: args.nodeId,
+      changeType: "updated",
+      previousState: { rationale: previousRationale },
+      newState: {
+        rationale: nextRationale && nextRationale.length > 0 ? nextRationale : void 0
+      },
+      changedBy: authenticatedUserId,
+      isAgent: false,
+      changedAt: now,
+      projectId: node.projectId
+    });
+    return {
+      nodeId: args.nodeId,
+      previousRationale,
+      newRationale: nextRationale
+    };
+  }
+});
+var updateStatusInternal = internalMutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    status: v.union(
+      v.literal("active"),
+      v.literal("superseded"),
+      v.literal("archived")
+    ),
+    reason: v.optional(v.string()),
+    userId: v.string(),
+    runtimeToolName: v.optional(v.string()),
+    runtimePackKey: v.optional(v.string()),
+    runtimePackInstallScope: v.optional(
+      v.union(v.literal("tenant"), v.literal("workspace"))
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const node = await ctx.db.get(args.nodeId);
+    if (!node || node.nodeType !== "belief") {
+      throw new Error("Belief not found");
+    }
+    assertTenantPackWorkspaceMutationAllowed({
+      runtime: resolveRuntimePackMutationContext(args),
+      target: await resolveNodeScopeForWorkspaceIsolation(ctx, node),
+      mutationName: "epistemicBeliefs.updateStatusInternal"
+    });
+    const previousStatus = node.status;
+    await ctx.db.patch(args.nodeId, {
+      status: args.status,
+      updatedAt: now
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "belief",
+      entityId: args.nodeId,
+      changeType: "status_changed",
+      previousState: { status: previousStatus },
+      newState: { status: args.status, reason: args.reason },
+      changedBy: args.userId,
+      isAgent: false,
+      changedAt: now,
+      projectId: node.projectId
+    });
+    return { nodeId: args.nodeId, previousStatus, newStatus: args.status };
+  }
+});
+
+export { archive, modulateConfidence, updateRationale, updateStatus, updateStatusInternal };
+//# sourceMappingURL=epistemicBeliefs.lifecycle.js.map
+//# sourceMappingURL=epistemicBeliefs.lifecycle.js.map