@lucern/graph-primitives 1.0.16 → 1.0.18

package/dist/index.js

@@ -7,6 +7,7 @@ import { componentsGeneric, anyApi, internalMutationGeneric, mutationGeneric, qu
 import { isNodeType, getLayerForNodeType } from '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
 import { assertSchemaEnumValue } from '@lucern/contracts/schema-helpers/enumValidation';
+import { generateGlobalId, isUuidV7, generateUuidV7 } from '@lucern/contracts/ids';
 import { listAudienceRegistryRows } from '@lucern/access-control/audienceRegistry';
 import { scoreEntityTypeMatch, scoreEntityConnection, rankEntityTypeMatches, rankEntityConnections } from '@lucern/contracts/v1/ontologies/v1';
 import { wordTokenize, wordOverlapScore, tokenizeSearchText, tokenOverlapScore, stemToken, scoreLexicalSignals, scoreLexicalSignal, rerankLexicalWindow, rankWindowScore, prepareLexicalQuery, jaccardSimilarity, bigramTokenize } from '@lucern/contracts/text-matching.contract';
@@ -689,6 +690,7 @@ __export(beliefLifecycle_exports, {
   isPreValidationBeliefStatus: () => isPreValidationBeliefStatus,
   isPropagationEligibleBeliefStatus: () => isPropagationEligibleBeliefStatus,
   isResolvedByConfidence: () => isResolvedByConfidence,
+  promoteBeliefStatusAfterEvidence: () => promoteBeliefStatusAfterEvidence,
   promoteBeliefStatusAfterScoring: () => promoteBeliefStatusAfterScoring,
   resolveBeliefLifecycleStatus: () => resolveBeliefLifecycleStatus,
   shouldTreatBeliefAsFact: () => shouldTreatBeliefAsFact
@@ -696,8 +698,10 @@ __export(beliefLifecycle_exports, {
 var BELIEF_STATUS_VALUES = [
   "assumption",
   "hypothesis",
-  "belief",
-  "fact"
+  "active",
+  "superseded",
+  "resolved_true",
+  "resolved_false"
 ];
 var RESOLVED_PREDICTION_OUTCOMES = [
   "confirmed",
@@ -708,6 +712,24 @@ var RESOLVED_PREDICTION_OUTCOMES = [
 function isBeliefLifecycleStatus(value) {
   return typeof value === "string" && BELIEF_STATUS_VALUES.includes(value);
 }
+function normalizeLegacyBeliefStatus(value) {
+  if (isBeliefLifecycleStatus(value)) {
+    return value;
+  }
+  if (value === "belief" || value === "established" || value === "emerging") {
+    return "active";
+  }
+  if (value === "fact" || value === "confirmed") {
+    return "resolved_true";
+  }
+  if (value === "disconfirmed" || value === "expired") {
+    return "resolved_false";
+  }
+  if (value === "deprecated") {
+    return "superseded";
+  }
+  return null;
+}
 function normalizeBeliefConfidence(confidence) {
   if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
     return null;
@@ -749,25 +771,58 @@ function shouldTreatBeliefAsFact(opts) {
   }
   return false;
 }
+function resolvedPredictionStatus(predictionMeta) {
+  if (!predictionMeta || typeof predictionMeta !== "object") {
+    return null;
+  }
+  const outcome = predictionMeta.outcome;
+  if (outcome === "confirmed") {
+    return "resolved_true";
+  }
+  if (outcome === "disconfirmed" || outcome === "expired") {
+    return "resolved_false";
+  }
+  return null;
+}
+function shouldTreatBeliefAsResolved(opts) {
+  if (isResolvedByConfidence(opts.confidence)) {
+    const normalized = normalizeBeliefConfidence(opts.confidence);
+    return normalized === 0 ? "resolved_false" : "resolved_true";
+  }
+  const directPredictionStatus = resolvedPredictionStatus(opts.predictionMeta);
+  if (directPredictionStatus) {
+    return directPredictionStatus;
+  }
+  const metadataPredictionStatus = resolvedPredictionStatus(
+    getPredictionMetaFromMetadata(opts.metadata)
+  );
+  if (metadataPredictionStatus) {
+    return metadataPredictionStatus;
+  }
+  return null;
+}
 function resolveBeliefLifecycleStatus(opts) {
-  if (shouldTreatBeliefAsFact(opts)) {
-    return "fact";
+  const resolvedStatus = shouldTreatBeliefAsResolved(opts);
+  if (resolvedStatus) {
+    return resolvedStatus;
   }
   const direct = opts.beliefStatus;
-  if (isBeliefLifecycleStatus(direct)) {
+  const normalizedDirect = normalizeLegacyBeliefStatus(direct);
+  if (normalizedDirect) {
     const normalized = normalizeBeliefConfidence(opts.confidence);
-    if (normalized !== null && isPreValidationBeliefStatus(direct)) {
-      return "belief";
+    if (normalized !== null && isPreValidationBeliefStatus(normalizedDirect)) {
+      return "active";
     }
-    return direct;
+    return normalizedDirect;
   }
   const metaStatus = opts.metadata?.beliefStatus;
-  if (isBeliefLifecycleStatus(metaStatus)) {
+  const normalizedMetaStatus = normalizeLegacyBeliefStatus(metaStatus);
+  if (normalizedMetaStatus) {
     const normalized = normalizeBeliefConfidence(opts.confidence);
-    if (normalized !== null && isPreValidationBeliefStatus(metaStatus)) {
-      return "belief";
+    if (normalized !== null && isPreValidationBeliefStatus(normalizedMetaStatus)) {
+      return "active";
     }
-    return metaStatus;
+    return normalizedMetaStatus;
   }
   return "assumption";
 }
@@ -775,16 +830,20 @@ function isPreValidationBeliefStatus(status) {
   return status === "assumption" || status === "hypothesis";
 }
 function isPropagationEligibleBeliefStatus(status) {
-  return status === "belief" || status === "fact";
+  return status === "active" || status === "resolved_true";
 }
 function promoteBeliefStatusAfterScoring(status, opts) {
-  if (shouldTreatBeliefAsFact({ ...opts })) {
-    return "fact";
+  const resolvedStatus = shouldTreatBeliefAsResolved({ ...opts });
+  if (resolvedStatus) {
+    return resolvedStatus;
   }
   if (isPreValidationBeliefStatus(status)) {
-    return "belief";
+    return "active";
   }
-  return status === "fact" ? "fact" : "belief";
+  return status;
+}
+function promoteBeliefStatusAfterEvidence(status) {
+  return isPreValidationBeliefStatus(status) ? "active" : status;
 }
 var api = anyApi;
 componentsGeneric();
@@ -1607,7 +1666,7 @@ function buildBeliefConfidenceRow(args) {
     disbelief: args.disbelief,
     uncertainty: args.uncertainty,
     baseRate: args.baseRate,
-    slOperator: args.slOperator ?? "manual_assessment",
+    slOperator: args.slOperator ?? "prior_seed",
     trigger: args.trigger,
     ...args.rationale ? { rationale: args.rationale } : {},
     assessedBy: args.assessedBy,
@@ -2061,17 +2120,17 @@ async function applyBeliefConfidenceChange(ctx, args) {
       status: 404,
       code: "NOT_FOUND",
       invariantCode: "belief.exists",
-      suggestion: "Verify nodeId points to an existing node before modulating confidence.",
+      suggestion: "Verify nodeId points to an existing node before appending SL scoring.",
       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.`,
+      message: `appendSlScoring only applies to belief nodes. Received nodeType "${node.nodeType}". Entity nodes (company, person, investor, etc.) do not have confidence \u2014 use entityLifecycle.updateEntityAttributes for mutable entity data.`,
       status: 400,
       code: "INVALID_ARGUMENT",
       invariantCode: "entity.no_confidence",
-      suggestion: "Use entityLifecycle.updateEntityAttributes for entity mutations. modulateConfidence is for belief nodes only.",
+      suggestion: "Use entityLifecycle.updateEntityAttributes for entity mutations. appendSlScoring is for belief nodes only.",
       details: { nodeId: args.nodeId, nodeType: node.nodeType }
     });
   }
@@ -2081,7 +2140,7 @@ async function applyBeliefConfidenceChange(ctx, args) {
       status: 400,
       code: "MISSING_SCOPE",
       invariantCode: "belief.project_required",
-      suggestion: "Belief must have a projectId to modulate confidence.",
+      suggestion: "Belief must have a projectId before SL scoring can be appended.",
       details: { nodeId: args.nodeId }
     });
   }
@@ -2104,7 +2163,7 @@ async function applyBeliefConfidenceChange(ctx, args) {
         status: 409,
         code: "CONFLICT",
         invariantCode: "belief.confidence_append_only",
-        suggestion: "Complete a worktree linked to this belief before recording confidence modulation.",
+        suggestion: "Complete a worktree linked to this belief before recording SL scoring.",
         details: { nodeId: args.nodeId }
       });
     }
@@ -2359,6 +2418,199 @@ var propagateConfidenceChange = internalMutation({
   }
 });
 
+// src/epistemicBeliefs.forkEvidence.ts
+function normalizeForkTriggerRelation(value) {
+  if (value === "supports" || value === "supporting") {
+    return "supports";
+  }
+  if (value === "contradicts" || value === "contradicting") {
+    return "contradicts";
+  }
+  return null;
+}
+async function resolveForkTriggerEvidence(ctx, args) {
+  const evidence = await ctx.db.get(args.triggeringEvidenceId);
+  if (!evidence || evidence.nodeType !== "evidence") {
+    throwStructuredMutationError({
+      message: "Fork requires an existing evidence node.",
+      status: 400,
+      code: "INVALID_ARGUMENT",
+      invariantCode: "belief.fork_requires_evidence",
+      suggestion: "Create or link evidence first, then fork with triggeringEvidenceId.",
+      details: { triggeringEvidenceId: args.triggeringEvidenceId }
+    });
+  }
+  if (evidence.topicId && evidence.topicId !== args.parent.topicId) {
+    throwStructuredMutationError({
+      message: "Fork evidence belongs to a different topic scope.",
+      status: 400,
+      code: "INVALID_ARGUMENT",
+      invariantCode: "belief.fork_evidence_scope",
+      suggestion: "Use evidence from the same topic/workspace scope as the parent belief.",
+      details: {
+        parentNodeId: args.parentNodeId,
+        triggeringEvidenceId: args.triggeringEvidenceId
+      }
+    });
+  }
+  const evidenceMetadata = evidence.metadata && typeof evidence.metadata === "object" ? evidence.metadata : {};
+  const parentRefs = new Set(
+    [
+      String(args.parentNodeId),
+      String(args.parent.globalId ?? ""),
+      String(args.parent._id)
+    ].filter(Boolean)
+  );
+  const evidenceRefs = new Set(
+    [
+      String(args.triggeringEvidenceId),
+      String(evidence.globalId ?? ""),
+      String(evidence._id)
+    ].filter(Boolean)
+  );
+  let relation = null;
+  const linkedBeliefNodeId = String(
+    evidenceMetadata.linkedBeliefNodeId ?? ""
+  );
+  if (linkedBeliefNodeId && parentRefs.has(linkedBeliefNodeId)) {
+    relation = normalizeForkTriggerRelation(evidenceMetadata.evidenceRelation);
+  }
+  if (!relation) {
+    for (const parentRef of parentRefs) {
+      const links = await ctx.db.query("beliefEvidenceLinks").withIndex("by_beliefId", (q) => q.eq("beliefId", parentRef)).collect();
+      const matched = links.find((link) => evidenceRefs.has(String(link.insightId)));
+      if (matched) {
+        relation = normalizeForkTriggerRelation(matched.relation);
+        break;
+      }
+    }
+  }
+  if (!relation) {
+    throwStructuredMutationError({
+      message: "Fork evidence must already be attached to the parent belief through an SL evidence relation.",
+      status: 409,
+      code: "CONFLICT",
+      invariantCode: "belief.fork_requires_attached_evidence",
+      suggestion: "Attach the evidence to the parent belief as supports or contradicts before forking.",
+      details: {
+        parentNodeId: args.parentNodeId,
+        triggeringEvidenceId: args.triggeringEvidenceId
+      }
+    });
+  }
+  if (args.forkMode === "supersede" && relation !== "contradicts") {
+    throwStructuredMutationError({
+      message: "Superseding fork requires contradicting evidence against the parent belief.",
+      status: 409,
+      code: "CONFLICT",
+      invariantCode: "belief.supersede_requires_contradiction",
+      suggestion: "Use forkMode='branch' for a non-replacing fork, or attach contradicting evidence before superseding.",
+      details: {
+        parentNodeId: args.parentNodeId,
+        triggeringEvidenceId: args.triggeringEvidenceId,
+        relation
+      }
+    });
+  }
+  return { evidenceNodeId: args.triggeringEvidenceId, relation };
+}
+
+// src/epistemicBeliefs.topicAnchor.ts
+function cleanString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function topicNodeCandidates(topicRef) {
+  const normalized = topicRef.trim();
+  if (!normalized) {
+    return [];
+  }
+  const candidates = [normalized];
+  if (normalized.startsWith("top_")) {
+    candidates.push(normalized.slice(4));
+  }
+  return [...new Set(candidates)];
+}
+function readTopicNodeRef(args) {
+  return cleanString(args.topicGlobalId) ?? cleanString(args.topicNodeId) ?? cleanString(args.topicId);
+}
+async function resolveRequiredTopicAnchor(ctx, topicRef) {
+  for (const candidate of topicNodeCandidates(topicRef)) {
+    try {
+      const direct = await ctx.db.get(candidate);
+      if (direct?.nodeType === "topic" && cleanString(direct.globalId)) {
+        return direct;
+      }
+    } catch (_) {
+    }
+    const byGlobalId = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", candidate)).first();
+    if (byGlobalId?.nodeType === "topic" && cleanString(byGlobalId.globalId)) {
+      return byGlobalId;
+    }
+  }
+  throw new Error(
+    "Belief creation requires topicGlobalId or topicNodeId for a topic node in epistemicNodes. Legacy topics-table IDs are not valid belief anchors."
+  );
+}
+function scopeFromTopicAnchor(topicNode) {
+  return {
+    topicId: topicNode.globalId,
+    projectId: cleanString(topicNode.projectId),
+    tenantId: cleanString(topicNode.tenantId),
+    workspaceId: cleanString(topicNode.workspaceId),
+    source: "topic"
+  };
+}
+async function createRequiredBeliefTopicEdge(ctx, args) {
+  const topicGlobalId = args.topicNode.globalId;
+  const edgeGlobalId = `edge:${args.beliefGlobalId}:${topicGlobalId}:scoped_by`;
+  const now = Date.now();
+  const existing = await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", edgeGlobalId)).first();
+  if (!existing) {
+    await ctx.db.insert("epistemicEdges", {
+      globalId: edgeGlobalId,
+      fromNodeId: String(args.beliefNodeId),
+      toNodeId: String(args.topicNode._id),
+      sourceGlobalId: args.beliefGlobalId,
+      targetGlobalId: topicGlobalId,
+      edgeType: "scoped_by",
+      weight: 1,
+      confidence: 1,
+      context: "Belief creation topic anchor invariant.",
+      reasoningMethod: "implicit",
+      derivationType: "topic_scope_invariant",
+      metadata: { invariant: "belief.topic_edge_required" },
+      createdBy: args.createdBy,
+      createdAt: now,
+      updatedAt: now,
+      projectId: cleanString(args.topicNode.projectId),
+      topicId: topicGlobalId,
+      tenantId: cleanString(args.topicNode.tenantId),
+      workspaceId: cleanString(args.topicNode.workspaceId),
+      fromNodeType: "belief",
+      toNodeType: "topic",
+      fromLayer: "L3",
+      toLayer: args.topicNode.epistemicLayer ?? "ontological"
+    });
+  }
+  await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
+    globalId: edgeGlobalId,
+    fromGlobalId: args.beliefGlobalId,
+    toGlobalId: topicGlobalId,
+    edgeType: "scoped_by",
+    weight: 1,
+    confidence: 1,
+    context: "Belief creation topic anchor invariant.",
+    projectId: cleanString(args.topicNode.projectId),
+    topicId: topicGlobalId,
+    createdBy: args.createdBy,
+    fromNodeType: "belief",
+    toNodeType: "topic",
+    fromLayer: "L3",
+    toLayer: args.topicNode.epistemicLayer ?? "ontological",
+    metadata: { invariant: "belief.topic_edge_required" }
+  });
+}
+
 // src/embeddingTrigger.ts
 async function scheduleEmbeddingGeneration(args) {
   try {
@@ -2391,23 +2643,17 @@ async function scheduleEmbeddingGeneration(args) {
 // src/globalId.ts
 var globalId_exports = {};
 __export(globalId_exports, {
-  generateGlobalId: () => generateGlobalId
+  generateGlobalId: () => generateGlobalId,
+  generateUuidV7: () => generateUuidV7,
+  isUuidV7: () => isUuidV7
 });
-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/epistemicBeliefs.core.ts
 var create = mutation({
   args: {
     ...optionalBeliefScopeArgs,
+    topicNodeId: v.optional(v.string()),
+    topicGlobalId: v.optional(v.string()),
     formulation: v.string(),
     beliefType: v.optional(v.string()),
     rationale: v.optional(v.string()),
@@ -2452,20 +2698,32 @@ var create = mutation({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const authenticatedUserId = await requireAuthenticatedUserId(ctx);
-    const scope = await resolveTopicProjectScope(ctx, {
-      topicId: args.topicId,
-      projectId: args.projectId
-    });
+    const topicRef = readTopicNodeRef(args);
+    if (!topicRef) {
+      throwStructuredMutationError({
+        message: "Belief creation requires an explicit topic epistemic node.",
+        status: 400,
+        code: "INVALID_ARGUMENT",
+        invariantCode: "belief.topic_node_required",
+        suggestion: "Pass topicGlobalId or topicNodeId for a topic in epistemicNodes before creating a belief.",
+        details: {
+          topicId: args.topicId,
+          topicNodeId: args.topicNodeId,
+          topicGlobalId: args.topicGlobalId
+        }
+      });
+    }
+    const topicNode = await resolveRequiredTopicAnchor(ctx, topicRef);
+    const scope = scopeFromTopicAnchor(topicNode);
     assertWorkspaceScopedEpistemicNodeScope({
       scope,
       nodeType: "belief",
       mutationName: "epistemicBeliefs.create"
     });
-    const topic = await ctx.db.get(scope.topicId);
     const normalizedBeliefType = await assertSchemaEnumValue(ctx, {
       category: "belief_type",
       value: args.beliefType,
-      tenantId: topic?.tenantId,
+      tenantId: scope.tenantId,
       context: "epistemicBeliefs.create"
     });
     if (scope.projectId) {
@@ -2498,7 +2756,7 @@ var create = mutation({
       title: args.formulation.slice(0, 100) + (args.formulation.length > 100 ? "..." : ""),
       metadata: {
         pillar,
-        // No confidenceLevel — only set after worktree completion via modulateConfidence()
+        // No confidenceLevel — only set after evidence-backed SL scoring.
         status: "active",
         worktreeId: args.worktreeId,
         beliefStatus: initialBeliefStatus,
@@ -2542,9 +2800,15 @@ var create = mutation({
         rationale: "LKC-2 mandatory prior: seeded vacuous opinion at belief creation.",
         assessedBy: authenticatedUserId,
         assessedAt: now,
-        slOperator: "manual_assessment"
+        slOperator: "prior_seed"
       })
     );
+    await createRequiredBeliefTopicEdge(ctx, {
+      beliefNodeId: nodeId,
+      beliefGlobalId,
+      topicNode,
+      createdBy: authenticatedUserId
+    });
     await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
       nodeId,
       operation: "upsert"
@@ -2881,9 +3145,10 @@ var forkBelief = mutation({
       v.literal("refinement"),
       v.literal("contradiction_response"),
       v.literal("scope_change"),
-      v.literal("confidence_collapse"),
-      v.literal("manual")
+      v.literal("confidence_collapse")
     ),
+    forkMode: v.optional(v.union(v.literal("supersede"), v.literal("branch"))),
+    triggeringEvidenceId: v.id("epistemicNodes"),
     rationale: v.optional(v.string()),
     userId: v.string()
   },
@@ -2926,6 +3191,33 @@ var forkBelief = mutation({
     await requireProjectWriteAccess(ctx, parent.projectId, authenticatedUserId);
     const metadata = parent.metadata;
     const forkBeliefStatus = "hypothesis";
+    const forkMode = args.forkMode ?? "supersede";
+    const triggerEvidence = await resolveForkTriggerEvidence(ctx, {
+      parentNodeId: args.parentNodeId,
+      parent,
+      triggeringEvidenceId: args.triggeringEvidenceId,
+      forkMode
+    });
+    const parentLifecycleStatus = resolveBeliefLifecycleStatus({
+      beliefStatus: parent.beliefStatus,
+      confidence: parent.confidence,
+      predictionMeta: parent.predictionMeta,
+      metadata
+    });
+    if (forkMode === "supersede" && parentLifecycleStatus !== "active") {
+      throwStructuredMutationError({
+        message: "Superseding fork requires an active parent belief. Attach evidence first so the lifecycle can promote deterministically.",
+        status: 409,
+        code: "CONFLICT",
+        invariantCode: "belief.supersede_requires_active_parent",
+        suggestion: "Attach the contradicting evidence to the parent belief, let the evidence path promote it to active, then supersede.",
+        details: {
+          parentNodeId: args.parentNodeId,
+          parentLifecycleStatus,
+          triggeringEvidenceId: args.triggeringEvidenceId
+        }
+      });
+    }
     const newBeliefGlobalId = generateGlobalId();
     const newNodeId = await ctx.db.insert("epistemicNodes", {
       globalId: newBeliefGlobalId,
@@ -2939,6 +3231,9 @@ var forkBelief = mutation({
         ...metadata,
         forkedFrom: args.parentNodeId,
         forkReason: args.forkReason,
+        forkMode,
+        triggeringEvidenceId: args.triggeringEvidenceId,
+        triggeringEvidenceRelation: triggerEvidence.relation,
         forkTimestamp: now,
         forkedBy: authenticatedUserId,
         status: "active",
@@ -2957,6 +3252,27 @@ var forkBelief = mutation({
       createdAt: now,
       updatedAt: now
     });
+    if (forkMode === "supersede") {
+      await ctx.db.patch(args.parentNodeId, {
+        status: "superseded",
+        beliefStatus: "superseded",
+        epistemicStatus: "superseded",
+        supersededBy: newNodeId,
+        updatedAt: now,
+        metadata: {
+          ...metadata ?? {},
+          status: "superseded",
+          beliefStatus: "superseded",
+          epistemicStatus: "superseded",
+          supersededBy: String(newNodeId),
+          supersededByEvidenceId: String(triggerEvidence.evidenceNodeId)
+        }
+      });
+      await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+        nodeId: args.parentNodeId,
+        operation: "upsert"
+      });
+    }
     const inheritedContracts = await ctx.db.query("epistemicContracts").withIndex(
       "by_belief",
       (q) => q.eq("beliefNodeId", args.parentNodeId)
@@ -2983,12 +3299,17 @@ var forkBelief = mutation({
       globalId: generateGlobalId(),
       fromGlobalId: newBeliefGlobalId,
       toGlobalId: parent.globalId,
-      edgeType: "supersedes",
-      context: `Fork reason: ${args.forkReason}`,
+      edgeType: forkMode === "supersede" ? "supersedes" : "derived_from",
+      context: `Fork reason: ${args.forkReason}; triggering evidence: ${triggerEvidence.evidenceNodeId}`,
       createdBy: authenticatedUserId,
       topicId: parent.projectId ? String(parent.projectId) : void 0,
       fromNodeType: "belief",
-      toNodeType: "belief"
+      toNodeType: "belief",
+      metadata: {
+        forkMode,
+        triggeringEvidenceId: String(triggerEvidence.evidenceNodeId),
+        triggeringEvidenceRelation: triggerEvidence.relation
+      }
     });
     await scheduleEmbeddingGeneration({
       ctx,
@@ -3013,6 +3334,9 @@ var forkBelief = mutation({
       newState: {
         formulation: args.newFormulation,
         forkReason: args.forkReason,
+        forkMode,
+        triggeringEvidenceId: String(triggerEvidence.evidenceNodeId),
+        triggeringEvidenceRelation: triggerEvidence.relation,
         tupleContradicted: false
       },
       projectId: parent.projectId,
@@ -3047,10 +3371,17 @@ var forkBelief = mutation({
       projectId: parent.projectId,
       topicId: parent.topicId
     });
-    return { newNodeId, parentNodeId: args.parentNodeId };
+    return {
+      newNodeId,
+      parentNodeId: args.parentNodeId,
+      forkMode,
+      forkReason: args.forkReason,
+      triggeringEvidenceId: triggerEvidence.evidenceNodeId,
+      triggeringEvidenceRelation: triggerEvidence.relation
+    };
   }
 });
-var modulateConfidence = mutation({
+var appendSlScoring = mutation({
   args: {
     nodeId: v.id("epistemicNodes"),
     // SL opinion — the ONLY confidence input (EK-7)
@@ -3067,8 +3398,6 @@ var modulateConfidence = mutation({
       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"),
@@ -3080,7 +3409,7 @@ var modulateConfidence = mutation({
     ),
     rationale: v.optional(v.string()),
     userId: v.string(),
-    // SL operator provenance (optional — defaults to manual_assessment)
+    // SL operator provenance (optional — defaults inside the SL scorer)
     slOperator: v.optional(
       v.union(
         v.literal("cumulative_fusion"),
@@ -3090,7 +3419,8 @@ var modulateConfidence = mutation({
         v.literal("dependency_cascade"),
         v.literal("negation"),
         v.literal("constraint_fusion"),
-        v.literal("manual_assessment")
+        v.literal("no_op"),
+        v.literal("prior_seed")
       )
     ),
     triggeringEvidenceId: v.optional(v.id("epistemicNodes")),
@@ -3457,6 +3787,12 @@ async function getQuestionsAnsweredByEvidence(ctx, evidenceId) {
 }
 
 // src/epistemicBeliefs.links.ts
+function assertSignedImpactScore(value, context) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value === 0 || value < -1 || value > 1) {
+    throw new Error(`${context} requires explicit nonzero weight in [-1, 1]`);
+  }
+  return value;
+}
 var updatePillar = mutation({
   args: {
     nodeId: v.id("epistemicNodes"),
@@ -3636,6 +3972,7 @@ var linkEvidence = mutation({
     beliefNodeId: v.id("epistemicNodes"),
     insightId: insightIdUnion,
     type: v.union(v.literal("supporting"), v.literal("contradicting")),
+    weight: v.number(),
     rationale: v.optional(v.string()),
     userId: v.string()
   },
@@ -3659,16 +3996,54 @@ var linkEvidence = mutation({
     }
     const evidenceNodeId = insight._id;
     const evidenceGlobalId = insight.globalId;
+    const weight = assertSignedImpactScore(args.weight, "Evidence link");
+    if (args.type === "supporting" && weight < 0) {
+      throw new Error("Supporting evidence links require positive weight");
+    }
+    if (args.type === "contradicting" && weight > 0) {
+      throw new Error("Contradicting evidence links require negative weight");
+    }
+    const confidence = Math.abs(weight);
     const edgeType = "informs";
-    const weight = args.type === "supporting" ? 1 : -1;
     const logicalRole = evidenceNodeId ? await computeLogicalRole(ctx, evidenceNodeId, args.beliefNodeId) : "contributory";
     const edgeGlobalId = generateGlobalId();
+    await ctx.db.insert("epistemicEdges", {
+      globalId: edgeGlobalId,
+      fromNodeId: evidenceNodeId,
+      toNodeId: args.beliefNodeId,
+      sourceGlobalId: evidenceGlobalId,
+      targetGlobalId: belief.globalId,
+      edgeType,
+      weight,
+      confidence,
+      context: args.rationale || `${args.type} evidence`,
+      reasoningMethod: "testimonial",
+      logicalRole,
+      temporalClass: "structural",
+      derivationType: "evidence_sl_scoring",
+      metadata: {
+        relation: args.type,
+        confidence,
+        impactScore: weight,
+        invariant: "evidence.belief_impact_required"
+      },
+      createdBy: authenticatedUserId,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      topicId: belief.topicId ? String(belief.topicId) : void 0,
+      projectId: belief.projectId ? String(belief.projectId) : void 0,
+      fromNodeType: "evidence",
+      toNodeType: "belief",
+      fromLayer: "L2",
+      toLayer: "L3"
+    });
     await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
       globalId: edgeGlobalId,
       fromGlobalId: evidenceGlobalId,
       toGlobalId: belief.globalId,
       edgeType,
       weight,
+      confidence,
       context: args.rationale || `${args.type} evidence`,
       createdBy: authenticatedUserId,
       topicId: belief.projectId ? String(belief.projectId) : void 0,
@@ -4299,6 +4674,8 @@ var internalGetById = internalQuery({
 var internalCreate = internalMutation({
   args: {
     ...optionalBeliefScopeArgs,
+    topicNodeId: v.optional(v.string()),
+    topicGlobalId: v.optional(v.string()),
     formulation: v.string(),
     baseRate: v.optional(v.number()),
     confidence: v.optional(
@@ -4337,10 +4714,14 @@ var internalCreate = internalMutation({
   handler: async (ctx, args) => {
     const now = Date.now();
     const baseRate = assertBaseRateInRange(args.baseRate ?? 0.5);
-    const scope = await resolveTopicProjectScope(ctx, {
-      topicId: args.topicId,
-      projectId: args.projectId
-    });
+    const topicRef = readTopicNodeRef(args);
+    if (!topicRef) {
+      throw new Error(
+        "Belief creation requires topicGlobalId or topicNodeId for a topic node in epistemicNodes."
+      );
+    }
+    const topicNode = await resolveRequiredTopicAnchor(ctx, topicRef);
+    const scope = scopeFromTopicAnchor(topicNode);
     assertWorkspaceScopedEpistemicNodeScope({
       scope,
       nodeType: "belief",
@@ -4356,11 +4737,10 @@ var internalCreate = internalMutation({
       },
       mutationName: "epistemicBeliefs.internalCreate"
     });
-    const topic = await ctx.db.get(scope.topicId);
     const normalizedBeliefType = await assertSchemaEnumValue(ctx, {
       category: "belief_type",
       value: args.beliefType,
-      tenantId: topic?.tenantId,
+      tenantId: scope.tenantId,
       context: "epistemicBeliefs.internalCreate"
     });
     const globalId = generateGlobalId();
@@ -4424,9 +4804,15 @@ var internalCreate = internalMutation({
         rationale: "LKC-2 mandatory prior: seeded vacuous opinion at belief creation.",
         assessedBy: args.userId,
         assessedAt: now,
-        slOperator: "manual_assessment"
+        slOperator: "prior_seed"
       })
     );
+    await createRequiredBeliefTopicEdge(ctx, {
+      beliefNodeId: nodeId,
+      beliefGlobalId: globalId,
+      topicNode,
+      createdBy: args.userId
+    });
     await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
       nodeId,
       operation: "upsert"
@@ -4600,7 +4986,7 @@ var backfillSyntheticOpinionHistory = internalMutation({
           rationale: "LK-6 backfill: synthesized t0 from node-level opinion fields (no prior beliefConfidence row found).",
           assessedAt: readFiniteNumber(node.createdAt) ?? readFiniteNumber(node.updatedAt) ?? Date.now(),
           assessedBy: "system:lk-6-backfill",
-          slOperator: "manual_assessment"
+          slOperator: "prior_seed"
         })
       );
       beliefsWithHistory.add(String(node._id));
@@ -4706,7 +5092,7 @@ var backfillMandatoryPriors = internalMutation({
             rationale: "LKC-2 backfill: inserted missing initial vacuous opinion with neutral prior.",
             assessedAt: readFiniteNumber(node.createdAt) ?? readFiniteNumber(node.updatedAt) ?? Date.now(),
             assessedBy: "system:lkc-2-prior-backfill",
-            slOperator: "manual_assessment"
+            slOperator: "prior_seed"
           })
         );
         insertedInitialRows++;
@@ -4814,7 +5200,7 @@ var backfillScoredBeliefEdges = internalMutation({
     const scoredBeliefs = allBeliefs.filter((belief) => {
       const metadata = belief.metadata || {};
       const lifecycle = resolveBeliefStatus(belief, metadata);
-      return lifecycle === "belief" || lifecycle === "fact";
+      return lifecycle === "active" || lifecycle === "resolved_true";
     });
     const themeNodes = await ctx.db.query("epistemicNodes").withIndex(
       "by_topic",
@@ -6300,85 +6686,32 @@ async function resolveScopeSoft(ctx, args) {
     ...projectId ? { projectId } : {}
   };
 }
-var beliefIdUnion = v.id("epistemicNodes");
-var insightIdUnion2 = v.id("epistemicNodes");
-var suggestionStatusValidator = v.union(
-  v.literal("suggested"),
-  v.literal("approved"),
-  v.literal("dismissed")
-);
-var matcherMetadataValidator = v.object({
-  surface: v.string(),
-  matcherFamily: v.optional(v.string()),
-  matcherKey: v.optional(v.string()),
-  matcherVersion: v.optional(v.string()),
-  reviewStatus: v.optional(
-    v.union(
-      v.literal("pending"),
-      v.literal("accepted"),
-      v.literal("rejected"),
-      v.literal("auto_accepted"),
-      v.literal("superseded")
-    )
-  ),
-  configSnapshot: v.optional(v.any()),
-  signalSnapshot: v.optional(v.any()),
-  outcomeMetadata: v.optional(v.any())
-});
-async function markProjectGraphDirty(ctx, projectId) {
-  if (!projectId) {
-    return;
+
+// src/beliefEvidenceLinks.operational.ts
+function assertEvidenceImpact(args) {
+  if (!Number.isFinite(args.weight) || args.weight === 0 || args.weight < -1 || args.weight > 1) {
+    throw new Error("Belief evidence links require explicit nonzero weight in [-1, 1]");
   }
-  await ctx.scheduler.runAfter(
-    0,
-    internal.graphAnalysisCache.markCacheStaleInternal,
-    {
-      projectId
-    }
-  );
-  await resolveGraphPrimitivesAppResolvers().patchProject(ctx, projectId, {
-    lastActivityAt: Date.now()
-  });
-}
-async function recordMatcherDecision(ctx, args) {
-  if (!args.matcherMetadata) {
-    return;
+  if (args.relation === "supports" && args.weight < 0) {
+    throw new Error("Supporting evidence links require positive weight");
+  }
+  if (args.relation === "contradicts" && args.weight > 0) {
+    throw new Error("Contradicting evidence links require negative weight");
   }
-  await ctx.runMutation("matcherFeedback:recordDecision", {
-    projectId: args.beliefNode.projectId,
-    topicId: args.beliefNode.topicId,
-    surface: args.matcherMetadata.surface,
-    matcherFamily: args.matcherMetadata.matcherFamily,
-    matcherKey: args.matcherMetadata.matcherKey,
-    matcherVersion: args.matcherMetadata.matcherVersion,
-    sourceEntityId: String(args.insightId),
-    targetEntityId: String(args.beliefId),
-    suggestionTable: "beliefEvidenceLinks",
-    suggestionId: args.linkId,
-    reviewStatus: deriveMatcherReviewStatus({
-      explicitReviewStatus: args.matcherMetadata.reviewStatus,
-      linkStatus: args.linkStatus
-    }),
-    reviewedBy: args.reviewedBy,
-    decisionReason: args.decisionReason,
-    configSnapshot: args.matcherMetadata.configSnapshot,
-    signalSnapshot: args.matcherMetadata.signalSnapshot,
-    outcomeMetadata: args.matcherMetadata.outcomeMetadata
-  });
 }
 async function applyOperationalLinkEffects(ctx, args) {
+  assertEvidenceImpact({ relation: args.relation, weight: args.weight });
+  const confidence = Math.abs(args.weight);
   const currentSupporting = args.beliefNode.supportingInsightIds ?? [];
   const currentContradicting = args.beliefNode.contradictingInsightIds ?? [];
-  if (args.relation === "supports") {
-    if (!currentSupporting.includes(args.insightId)) {
-      await ctx.db.patch(args.beliefId, {
-        supportingInsightIds: [...currentSupporting, args.insightId],
-        contradictingInsightIds: currentContradicting.filter(
-          (id) => id !== args.insightId
-        )
-      });
-    }
-  } else if (!currentContradicting.includes(args.insightId)) {
+  if (args.relation === "supports" && !currentSupporting.includes(args.insightId)) {
+    await ctx.db.patch(args.beliefId, {
+      supportingInsightIds: [...currentSupporting, args.insightId],
+      contradictingInsightIds: currentContradicting.filter(
+        (id) => id !== args.insightId
+      )
+    });
+  } else if (args.relation === "contradicts" && !currentContradicting.includes(args.insightId)) {
     await ctx.db.patch(args.beliefId, {
       contradictingInsightIds: [...currentContradicting, args.insightId],
       supportingInsightIds: currentSupporting.filter(
@@ -6389,7 +6722,7 @@ async function applyOperationalLinkEffects(ctx, args) {
   try {
     const beliefSpineNode = await ctx.db.get(args.beliefId);
     const evidenceSpineNode = await ctx.db.get(args.insightId);
-    if (beliefSpineNode && beliefSpineNode.nodeType === "belief" && evidenceSpineNode && evidenceSpineNode.nodeType === "evidence") {
+    if (beliefSpineNode?.nodeType === "belief" && evidenceSpineNode?.nodeType === "evidence") {
       const existingEdges = await ctx.db.query("epistemicEdges").withIndex(
         "by_from_to",
         (q) => q.eq("fromNodeId", evidenceSpineNode._id).eq("toNodeId", beliefSpineNode._id)
@@ -6402,16 +6735,44 @@ async function applyOperationalLinkEffects(ctx, args) {
           await ctx.db.delete(edge._id);
         }
       }
-      const weight = args.relation === "supports" ? args.confidence ?? 0.7 : -(args.confidence ?? 0.7);
       const globalId = `edge-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+      const context = args.rationale || `Linked as ${args.relation}`;
+      await ctx.db.insert("epistemicEdges", {
+        globalId,
+        fromNodeId: evidenceSpineNode._id,
+        toNodeId: beliefSpineNode._id,
+        sourceGlobalId: evidenceSpineNode.globalId,
+        targetGlobalId: beliefSpineNode.globalId,
+        edgeType: "informs",
+        weight: args.weight,
+        confidence,
+        context,
+        reasoningMethod: "testimonial",
+        derivationType: "evidence_sl_scoring",
+        metadata: {
+          relation: args.relation,
+          confidence,
+          impactScore: args.weight,
+          invariant: "evidence.belief_impact_required"
+        },
+        createdBy: args.createdBy,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        projectId: args.beliefNode.projectId,
+        topicId: args.beliefNode.topicId ? String(args.beliefNode.topicId) : void 0,
+        fromNodeType: "evidence",
+        toNodeType: "belief",
+        fromLayer: "L2",
+        toLayer: "L3"
+      });
       await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
         globalId,
         fromGlobalId: evidenceSpineNode.globalId,
         toGlobalId: beliefSpineNode.globalId,
         edgeType: "informs",
-        weight,
-        confidence: args.confidence,
-        context: args.rationale || `Linked as ${args.relation}`,
+        weight: args.weight,
+        confidence,
+        context,
         projectId: args.beliefNode.projectId ? String(args.beliefNode.projectId) : void 0,
         createdBy: args.createdBy,
         fromNodeType: "evidence",
@@ -6424,17 +6785,13 @@ async function applyOperationalLinkEffects(ctx, args) {
     console.error("[EpistemicSpine] Failed to create informs edge:", e);
   }
   if (args.beliefNode.projectId) {
-    await ctx.scheduler.runAfter(
-      0,
-      "verificationActions:deepVerifyEvidence",
-      {
-        insightId: args.insightId,
-        targetType: "belief",
-        targetId: args.beliefId,
-        projectId: args.beliefNode.projectId,
-        userId: args.createdBy
-      }
-    );
+    await ctx.scheduler.runAfter(0, "verificationActions:deepVerifyEvidence", {
+      insightId: args.insightId,
+      targetType: "belief",
+      targetId: args.beliefId,
+      projectId: args.beliefNode.projectId,
+      userId: args.createdBy
+    });
   }
 }
 async function removeOperationalLinkEffects(ctx, args) {
@@ -6459,7 +6816,7 @@ async function removeOperationalLinkEffects(ctx, args) {
   try {
     const beliefSpineNode = await ctx.db.get(args.beliefId);
     const evidenceSpineNode = await ctx.db.get(args.insightId);
-    if (beliefSpineNode && beliefSpineNode.nodeType === "belief" && evidenceSpineNode && evidenceSpineNode.nodeType === "evidence") {
+    if (beliefSpineNode?.nodeType === "belief" && evidenceSpineNode?.nodeType === "evidence") {
       const edges2 = await ctx.db.query("epistemicEdges").withIndex(
         "by_from_to",
         (q) => q.eq("fromNodeId", evidenceSpineNode._id).eq("toNodeId", beliefSpineNode._id)
@@ -6477,11 +6834,80 @@ async function removeOperationalLinkEffects(ctx, args) {
     console.error("[EpistemicSpine] Failed to remove informs edge:", e);
   }
 }
+
+// src/beliefEvidenceLinks.ts
+var beliefIdUnion = v.id("epistemicNodes");
+var insightIdUnion2 = v.id("epistemicNodes");
+var suggestionStatusValidator = v.union(
+  v.literal("suggested"),
+  v.literal("approved"),
+  v.literal("dismissed")
+);
+var matcherMetadataValidator = v.object({
+  surface: v.string(),
+  matcherFamily: v.optional(v.string()),
+  matcherKey: v.optional(v.string()),
+  matcherVersion: v.optional(v.string()),
+  reviewStatus: v.optional(
+    v.union(
+      v.literal("pending"),
+      v.literal("accepted"),
+      v.literal("rejected"),
+      v.literal("auto_accepted"),
+      v.literal("superseded")
+    )
+  ),
+  configSnapshot: v.optional(v.any()),
+  signalSnapshot: v.optional(v.any()),
+  outcomeMetadata: v.optional(v.any())
+});
+async function markProjectGraphDirty(ctx, projectId) {
+  if (!projectId) {
+    return;
+  }
+  await ctx.scheduler.runAfter(
+    0,
+    internal.graphAnalysisCache.markCacheStaleInternal,
+    {
+      projectId
+    }
+  );
+  await resolveGraphPrimitivesAppResolvers().patchProject(ctx, projectId, {
+    lastActivityAt: Date.now()
+  });
+}
+async function recordMatcherDecision(ctx, args) {
+  if (!args.matcherMetadata) {
+    return;
+  }
+  await ctx.runMutation("matcherFeedback:recordDecision", {
+    projectId: args.beliefNode.projectId,
+    topicId: args.beliefNode.topicId,
+    surface: args.matcherMetadata.surface,
+    matcherFamily: args.matcherMetadata.matcherFamily,
+    matcherKey: args.matcherMetadata.matcherKey,
+    matcherVersion: args.matcherMetadata.matcherVersion,
+    sourceEntityId: String(args.insightId),
+    targetEntityId: String(args.beliefId),
+    suggestionTable: "beliefEvidenceLinks",
+    suggestionId: args.linkId,
+    reviewStatus: deriveMatcherReviewStatus({
+      explicitReviewStatus: args.matcherMetadata.reviewStatus,
+      linkStatus: args.linkStatus
+    }),
+    reviewedBy: args.reviewedBy,
+    decisionReason: args.decisionReason,
+    configSnapshot: args.matcherMetadata.configSnapshot,
+    signalSnapshot: args.matcherMetadata.signalSnapshot,
+    outcomeMetadata: args.matcherMetadata.outcomeMetadata
+  });
+}
 var create2 = mutation({
   args: {
     beliefId: beliefIdUnion,
     insightId: insightIdUnion2,
     relation: v.union(v.literal("supports"), v.literal("contradicts")),
+    weight: v.number(),
     confidence: v.optional(v.number()),
     rationale: v.optional(v.string()),
     status: v.optional(suggestionStatusValidator),
@@ -6500,6 +6926,16 @@ var create2 = mutation({
     if (!insightNode) {
       throw new Error("Evidence node not found");
     }
+    if (!Number.isFinite(args.weight) || args.weight === 0 || args.weight < -1 || args.weight > 1) {
+      throw new Error("Belief evidence links require explicit nonzero weight in [-1, 1]");
+    }
+    if (args.relation === "supports" && args.weight < 0) {
+      throw new Error("Supporting evidence links require positive weight");
+    }
+    if (args.relation === "contradicts" && args.weight > 0) {
+      throw new Error("Contradicting evidence links require negative weight");
+    }
+    const relationConfidence = Math.abs(args.weight);
     if (beliefNode.projectId) {
       const hasAccess = await checkProjectAccess(
         ctx,
@@ -6524,7 +6960,7 @@ var create2 = mutation({
       );
       await ctx.db.patch(duplicate._id, {
         relation: args.relation,
-        confidence: args.confidence,
+        confidence: relationConfidence,
         rationale: args.rationale,
         status: nextStatus
       });
@@ -6536,7 +6972,7 @@ var create2 = mutation({
           beliefId: resolvedBeliefId,
           insightId: resolvedInsightId,
           relation: args.relation,
-          confidence: args.confidence,
+          weight: args.weight,
           rationale: args.rationale,
           createdBy: args.createdBy
         });
@@ -6552,15 +6988,12 @@ var create2 = mutation({
       await markProjectGraphDirty(ctx, beliefNode.projectId);
       return duplicate._id;
     }
-    if (args.confidence !== void 0 && (args.confidence < 0 || args.confidence > 1)) {
-      throw new Error("Confidence must be between 0 and 1");
-    }
     const now = Date.now();
     const linkId = await ctx.db.insert("beliefEvidenceLinks", {
       beliefId: args.beliefId,
       insightId: args.insightId,
       relation: args.relation,
-      confidence: args.confidence,
+      confidence: relationConfidence,
       rationale: args.rationale,
       status: args.status,
       createdBy: args.createdBy,
@@ -6580,7 +7013,7 @@ var create2 = mutation({
         beliefId: resolvedBeliefId,
         insightId: resolvedInsightId,
         relation: args.relation,
-        confidence: args.confidence,
+        weight: args.weight,
         rationale: args.rationale,
         createdBy: args.createdBy
       });
@@ -6688,7 +7121,7 @@ var reviewSuggestion = mutation({
         beliefId: link.beliefId,
         insightId: link.insightId,
         relation: link.relation,
-        confidence: link.confidence,
+        weight: link.relation === "supports" ? Math.abs(link.confidence ?? 0) : -Math.abs(link.confidence ?? 0),
         rationale: link.rationale,
         createdBy: args.userId
       });
@@ -8937,7 +9370,7 @@ async function evaluateBuiltInEvidentialContract(args) {
       observedValue: snapshot.value,
       operator: config.operator,
       threshold: config.threshold,
-      action: config.action ?? "modulate_confidence",
+      action: config.action ?? "append_sl_scoring",
       actionParams: config.actionParams
     }
   };
@@ -11707,6 +12140,91 @@ function formatEvidenceNode(n) {
     updatedAt: n.updatedAt
   };
 }
+function assertSignedImpactScore2(value, context) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value === 0 || value < -1 || value > 1) {
+    throw new Error(`${context} requires explicit nonzero weight in [-1, 1]`);
+  }
+  return value;
+}
+function normalizeEvidenceRelation(relation, weight, context) {
+  if (relation === "supports" || relation === "contradicts") {
+    if (relation === "supports" && weight < 0) {
+      throw new Error(`${context} supports relation requires positive weight`);
+    }
+    if (relation === "contradicts" && weight > 0) {
+      throw new Error(`${context} contradicts relation requires negative weight`);
+    }
+    return relation;
+  }
+  return weight < 0 ? "contradicts" : "supports";
+}
+async function createEvidenceBeliefEdge(ctx, args) {
+  const edgeGlobalId = crypto.randomUUID();
+  const confidence = Math.abs(args.weight);
+  const existingEdges = await ctx.db.query("epistemicEdges").withIndex(
+    "by_from_to",
+    (q) => q.eq("fromNodeId", args.evidenceNodeId).eq("toNodeId", args.beliefNodeId)
+  ).collect();
+  const existing = existingEdges.find((edge) => edge.edgeType === "informs");
+  const edgeDoc = {
+    globalId: edgeGlobalId,
+    fromNodeId: args.evidenceNodeId,
+    toNodeId: args.beliefNodeId,
+    sourceGlobalId: args.evidenceGlobalId,
+    targetGlobalId: args.beliefGlobalId,
+    edgeType: "informs",
+    weight: args.weight,
+    confidence,
+    context: args.rationale,
+    reasoningMethod: "testimonial",
+    derivationType: "evidence_sl_scoring",
+    metadata: {
+      relation: args.relation,
+      confidence,
+      impactScore: args.weight,
+      invariant: "evidence.belief_impact_required"
+    },
+    createdBy: args.userId,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    topicId: args.topicId,
+    projectId: args.projectId,
+    fromNodeType: "evidence",
+    toNodeType: "belief",
+    fromLayer: "L2",
+    toLayer: "L3"
+  };
+  if (existing) {
+    await ctx.db.patch(existing._id, {
+      ...edgeDoc,
+      globalId: existing.globalId,
+      createdAt: existing.createdAt ?? edgeDoc.createdAt
+    });
+  } else {
+    await ctx.db.insert("epistemicEdges", edgeDoc);
+  }
+  await ctx.scheduler.runAfter(5e3, internal.neo4jEdgeAPI.createEdge, {
+    globalId: existing?.globalId ?? edgeGlobalId,
+    fromGlobalId: args.evidenceGlobalId,
+    toGlobalId: args.beliefGlobalId,
+    edgeType: "informs",
+    weight: args.weight,
+    confidence,
+    createdBy: args.userId,
+    topicId: args.projectId ?? args.topicId,
+    fromNodeType: "evidence",
+    toNodeType: "belief",
+    fromLayer: "L2",
+    toLayer: "L3",
+    metadata: {
+      relation: args.relation,
+      confidence,
+      impactScore: args.weight,
+      invariant: "evidence.belief_impact_required"
+    }
+  });
+  return existing?.globalId ?? edgeGlobalId;
+}
 var create6 = mutation({
   args: {
     ...optionalEvidenceScopeArgs,
@@ -11727,11 +12245,12 @@ var create6 = mutation({
     informationAsymmetry: v.optional(v.string()),
     sourceDescription: v.optional(v.string()),
     metadata: v.optional(v.any()),
-    // Optional linking to beliefs
-    linkedBeliefNodeId: v.optional(v.id("epistemicNodes")),
+    // Required belief impact link.
+    linkedBeliefNodeId: v.id("epistemicNodes"),
     evidenceRelation: v.optional(
       v.union(v.literal("supports"), v.literal("contradicts"))
     ),
+    weight: v.number(),
     confidence: v.optional(v.number())
   },
   returns: permissiveReturn,
@@ -11753,6 +12272,16 @@ var create6 = mutation({
     const contentHash = generateContentHash5(args.text);
     const kind = normalizeKind(args.kind);
     const sourceType = normalizeSourceType(args.sourceType);
+    const weight = assertSignedImpactScore2(args.weight, "Evidence creation");
+    const evidenceRelation = normalizeEvidenceRelation(
+      args.evidenceRelation,
+      weight,
+      "Evidence creation"
+    );
+    const linkedBeliefNode = await ctx.db.get(args.linkedBeliefNodeId);
+    if (!linkedBeliefNode || linkedBeliefNode.nodeType !== "belief") {
+      throw new Error("Evidence creation requires a linked belief node");
+    }
     const additionalMetadata = args.metadata && typeof args.metadata === "object" ? args.metadata : {};
     const nodeId = await ctx.db.insert("epistemicNodes", {
       globalId,
@@ -11780,8 +12309,10 @@ var create6 = mutation({
         sourceQuestionId: args.sourceQuestionId,
         rationale: args.rationale,
         linkedBeliefNodeId: args.linkedBeliefNodeId,
-        evidenceRelation: args.evidenceRelation,
-        confidence: args.confidence,
+        evidenceRelation,
+        confidence: Math.abs(weight),
+        weight,
+        impactScore: weight,
         methodology: args.methodology,
         informationAsymmetry: args.informationAsymmetry,
         sourceDescription: args.sourceDescription,
@@ -11801,29 +12332,18 @@ var create6 = mutation({
       nodeType: "evidence",
       text: args.text
     });
-    if (args.linkedBeliefNodeId && args.evidenceRelation) {
-      const beliefNode = await ctx.db.get(args.linkedBeliefNodeId);
-      if (beliefNode) {
-        const weight = args.evidenceRelation === "supports" ? 1 : -1;
-        await ctx.scheduler.runAfter(5e3, internal.neo4jEdgeAPI.createEdge, {
-          globalId: crypto.randomUUID(),
-          fromGlobalId: globalId,
-          toGlobalId: beliefNode.globalId,
-          edgeType: "informs",
-          weight: weight * (args.confidence || 0.7),
-          createdBy: args.userId,
-          topicId: scope.projectId ? String(scope.projectId) : void 0,
-          fromNodeType: "evidence",
-          toNodeType: "belief",
-          fromLayer: "L2",
-          toLayer: "L3",
-          metadata: {
-            relation: args.evidenceRelation,
-            confidence: args.confidence
-          }
-        });
-      }
-    }
+    await createEvidenceBeliefEdge(ctx, {
+      evidenceNodeId: nodeId,
+      evidenceGlobalId: globalId,
+      beliefNodeId: args.linkedBeliefNodeId,
+      beliefGlobalId: linkedBeliefNode.globalId,
+      relation: evidenceRelation,
+      weight,
+      userId: args.userId,
+      topicId: scope.topicId ? String(scope.topicId) : void 0,
+      projectId: scope.projectId ? String(scope.projectId) : void 0,
+      rationale: args.rationale
+    });
     await ctx.db.insert("epistemicAudit", {
       entityType: "evidence",
       entityId: nodeId,
@@ -11838,7 +12358,8 @@ var create6 = mutation({
         kind,
         sourceType,
         linkedBeliefNodeId: args.linkedBeliefNodeId,
-        evidenceRelation: args.evidenceRelation
+        evidenceRelation,
+        weight
       }
     });
     if (scope.projectId || scope.topicId) {
@@ -11881,6 +12402,7 @@ var createAndLink = mutation({
     userId: v.string(),
     beliefNodeId: v.id("epistemicNodes"),
     relation: v.union(v.literal("supports"), v.literal("contradicts")),
+    weight: v.number(),
     confidence: v.optional(v.number())
   },
   returns: permissiveReturn,
@@ -11895,7 +12417,17 @@ var createAndLink = mutation({
     const contentHash = generateContentHash5(args.text);
     const kind = normalizeKind(args.kind);
     const sourceType = normalizeSourceType(args.sourceType);
-    const confidence = args.confidence ?? 0.7;
+    const weight = assertSignedImpactScore2(args.weight, "Evidence createAndLink");
+    const relation = normalizeEvidenceRelation(
+      args.relation,
+      weight,
+      "Evidence createAndLink"
+    );
+    const confidence = Math.abs(weight);
+    const beliefNode = await ctx.db.get(args.beliefNodeId);
+    if (!beliefNode || beliefNode.nodeType !== "belief") {
+      throw new Error("Belief node not found for edge creation");
+    }
     const nodeId = await ctx.db.insert("epistemicNodes", {
       globalId,
       topicId: scope.topicId,
@@ -11915,36 +12447,26 @@ var createAndLink = mutation({
         kind,
         tags: args.tags || [],
         linkedBeliefNodeId: args.beliefNodeId,
-        evidenceRelation: args.relation,
-        confidence
+        evidenceRelation: relation,
+        confidence,
+        weight,
+        impactScore: weight
       }
     });
     await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
       nodeId,
       operation: "upsert"
     });
-    const beliefNode = await ctx.db.get(args.beliefNodeId);
-    if (!beliefNode) {
-      throw new Error("Belief node not found for edge creation");
-    }
-    const weight = args.relation === "supports" ? confidence : -confidence;
-    const edgeGlobalId = crypto.randomUUID();
-    await ctx.scheduler.runAfter(5e3, internal.neo4jEdgeAPI.createEdge, {
-      globalId: edgeGlobalId,
-      fromGlobalId: globalId,
-      toGlobalId: beliefNode.globalId,
-      edgeType: "informs",
+    const edgeGlobalId = await createEvidenceBeliefEdge(ctx, {
+      evidenceNodeId: nodeId,
+      evidenceGlobalId: globalId,
+      beliefNodeId: args.beliefNodeId,
+      beliefGlobalId: beliefNode.globalId,
+      relation,
       weight,
-      createdBy: args.userId,
-      topicId: scope.projectId,
-      fromNodeType: "evidence",
-      toNodeType: "belief",
-      fromLayer: "L2",
-      toLayer: "L3",
-      metadata: {
-        relation: args.relation,
-        confidence
-      }
+      userId: args.userId,
+      topicId: scope.topicId ? String(scope.topicId) : void 0,
+      projectId: scope.projectId ? String(scope.projectId) : void 0
     });
     await markProjectGraphDirty2(ctx, scope.projectId, String(scope.topicId));
     return { nodeId, edgeGlobalId };
@@ -12005,8 +12527,9 @@ var internalCreate2 = internalMutation({
     sourceQuestionId: v.optional(v.string()),
     userId: v.string(),
     rationale: v.string(),
-    linkedBeliefNodeId: v.optional(v.id("epistemicNodes")),
+    linkedBeliefNodeId: v.id("epistemicNodes"),
     evidenceRelation: v.optional(v.string()),
+    weight: v.number(),
     confidence: v.optional(v.number()),
     metadata: v.optional(v.any()),
     runtimeToolName: v.optional(v.string()),
@@ -12041,6 +12564,16 @@ var internalCreate2 = internalMutation({
     const contentHash = generateContentHash5(args.text);
     const kind = normalizeKind(args.kind);
     const sourceType = normalizeSourceType(args.sourceType);
+    const weight = assertSignedImpactScore2(args.weight, "Internal evidence creation");
+    const evidenceRelation = normalizeEvidenceRelation(
+      args.evidenceRelation,
+      weight,
+      "Internal evidence creation"
+    );
+    const linkedBeliefNode = await ctx.db.get(args.linkedBeliefNodeId);
+    if (!linkedBeliefNode || linkedBeliefNode.nodeType !== "belief") {
+      throw new Error("Internal evidence creation requires a linked belief node");
+    }
     const additionalMetadata = args.metadata && typeof args.metadata === "object" ? args.metadata : {};
     const nodeId = await ctx.db.insert("epistemicNodes", {
       globalId,
@@ -12068,8 +12601,10 @@ var internalCreate2 = internalMutation({
         sourceQuestionId: args.sourceQuestionId,
         rationale: args.rationale,
         linkedBeliefNodeId: args.linkedBeliefNodeId,
-        evidenceRelation: args.evidenceRelation,
-        confidence: args.confidence,
+        evidenceRelation,
+        confidence: Math.abs(weight),
+        weight,
+        impactScore: weight,
         ...additionalMetadata
       }
     });
@@ -12089,8 +12624,9 @@ var internalCreate2 = internalMutation({
         externalSourceType: args.externalSourceType,
         sourceUrl: args.sourceUrl,
         linkedBeliefNodeId: args.linkedBeliefNodeId,
-        evidenceRelation: args.evidenceRelation,
-        confidence: args.confidence
+        evidenceRelation,
+        confidence: Math.abs(weight),
+        weight
       },
       triggeringAction: "epistemicEvidence.internalCreate"
     });
@@ -12098,30 +12634,18 @@ var internalCreate2 = internalMutation({
       nodeId,
       operation: "upsert"
     });
-    if (args.linkedBeliefNodeId && args.evidenceRelation) {
-      const beliefNode = await ctx.db.get(args.linkedBeliefNodeId);
-      if (beliefNode) {
-        const confidence = args.confidence ?? 0.7;
-        const weight = args.evidenceRelation === "supports" ? confidence : -confidence;
-        await ctx.scheduler.runAfter(5e3, internal.neo4jEdgeAPI.createEdge, {
-          globalId: crypto.randomUUID(),
-          fromGlobalId: globalId,
-          toGlobalId: beliefNode.globalId,
-          edgeType: "informs",
-          weight,
-          createdBy: args.userId,
-          topicId: scope.projectId ? String(scope.projectId) : void 0,
-          fromNodeType: "evidence",
-          toNodeType: "belief",
-          fromLayer: "L2",
-          toLayer: "L3",
-          metadata: {
-            relation: args.evidenceRelation,
-            confidence
-          }
-        });
-      }
-    }
+    await createEvidenceBeliefEdge(ctx, {
+      evidenceNodeId: nodeId,
+      evidenceGlobalId: globalId,
+      beliefNodeId: args.linkedBeliefNodeId,
+      beliefGlobalId: linkedBeliefNode.globalId,
+      relation: evidenceRelation,
+      weight,
+      userId: args.userId,
+      topicId: scope.topicId ? String(scope.topicId) : void 0,
+      projectId: scope.projectId ? String(scope.projectId) : void 0,
+      rationale: args.rationale
+    });
     if (scope.projectId || scope.topicId) {
       await ctx.scheduler.runAfter(
         0,
@@ -13412,7 +13936,7 @@ function assertBeliefNodeGenericUpdateAllowed(args) {
     throwInvariantError({
       message: "Belief confidence is append-only. Generic node updates cannot set confidence directly.",
       invariantCode: "belief.confidence_append_only",
-      suggestion: "Use epistemicBeliefs.modulateConfidence() so the beliefConfidence ledger and audit trail are updated together.",
+      suggestion: "Use epistemicBeliefs.appendSlScoring() so the beliefConfidence ledger and audit trail are updated together.",
       details: { mutationName: args.mutationName, nodeId: args.node._id }
     });
   }
@@ -13464,7 +13988,7 @@ function assertBeliefNodeVerifyAllowed(args) {
   throwInvariantError({
     message: "Belief verification cannot set confidence directly. Confidence changes must stay append-only.",
     invariantCode: "belief.confidence_append_only",
-    suggestion: "Call epistemicBeliefs.modulateConfidence() after verification so the confidence history is preserved.",
+    suggestion: "Call epistemicBeliefs.appendSlScoring() after verification so the confidence history is preserved.",
     details: { mutationName: args.mutationName, nodeId: args.node._id }
   });
 }
@@ -18904,7 +19428,7 @@ var epistemicBeliefs = {
   internalGetByTopic,
   linkBeliefs,
   linkEvidence,
-  modulateConfidence,
+  appendSlScoring,
   propagateConfidenceChange,
   reassignBeliefsTopic,
   refineBelief,