@lucern/graph-primitives 1.0.16 → 1.0.18

package/dist/epistemicBeliefs.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 } from '@lucern/contracts/ids';
 import { listAudienceRegistryRows } from '@lucern/access-control/audienceRegistry';
 
 // src/epistemicBeliefs.helpers.ts
@@ -15,18 +16,32 @@ import { listAudienceRegistryRows } from '@lucern/access-control/audienceRegistr
 var BELIEF_STATUS_VALUES = [
   "assumption",
   "hypothesis",
-  "belief",
-  "fact"
-];
-var RESOLVED_PREDICTION_OUTCOMES = [
-  "confirmed",
-  "disconfirmed",
-  "partial",
-  "expired"
+  "active",
+  "superseded",
+  "resolved_true",
+  "resolved_false"
 ];
 function isBeliefLifecycleStatus(value) {
   return typeof value === "string" && BELIEF_STATUS_VALUES.includes(value);
 }
+function normalizeLegacyBeliefStatus(value) {
+  if (isBeliefLifecycleStatus(value)) {
+    return value;
+  }
+  if (value === "belief" || value === "established" || value === "emerging") {
+    return "active";
+  }
+  if (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;
@@ -46,47 +61,61 @@ function isResolvedByConfidence(confidence) {
   }
   return normalized <= 0 || normalized >= 1;
 }
-function hasResolvedPredictionOutcome(predictionMeta) {
+function getPredictionMetaFromMetadata(metadata) {
+  return metadata?.predictionMeta;
+}
+function resolvedPredictionStatus(predictionMeta) {
   if (!predictionMeta || typeof predictionMeta !== "object") {
-    return false;
+    return null;
   }
   const outcome = predictionMeta.outcome;
-  return typeof outcome === "string" && RESOLVED_PREDICTION_OUTCOMES.includes(outcome);
-}
-function getPredictionMetaFromMetadata(metadata) {
-  return metadata?.predictionMeta;
+  if (outcome === "confirmed") {
+    return "resolved_true";
+  }
+  if (outcome === "disconfirmed" || outcome === "expired") {
+    return "resolved_false";
+  }
+  return null;
 }
-function shouldTreatBeliefAsFact(opts) {
+function shouldTreatBeliefAsResolved(opts) {
   if (isResolvedByConfidence(opts.confidence)) {
-    return true;
+    const normalized = normalizeBeliefConfidence(opts.confidence);
+    return normalized === 0 ? "resolved_false" : "resolved_true";
   }
-  if (hasResolvedPredictionOutcome(opts.predictionMeta)) {
-    return true;
+  const directPredictionStatus = resolvedPredictionStatus(opts.predictionMeta);
+  if (directPredictionStatus) {
+    return directPredictionStatus;
   }
-  if (hasResolvedPredictionOutcome(getPredictionMetaFromMetadata(opts.metadata))) {
-    return true;
+  const metadataPredictionStatus = resolvedPredictionStatus(
+    getPredictionMetaFromMetadata(opts.metadata)
+  );
+  if (metadataPredictionStatus) {
+    return metadataPredictionStatus;
   }
-  return false;
+  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";
 }
@@ -94,13 +123,14 @@ function isPreValidationBeliefStatus(status) {
   return status === "assumption" || status === "hypothesis";
 }
 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;
 }
 var api = anyApi;
 componentsGeneric();
@@ -870,7 +900,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,
@@ -1609,17 +1639,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 }
     });
   }
@@ -1629,7 +1659,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 }
     });
   }
@@ -1652,7 +1682,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 }
       });
     }
@@ -1907,6 +1937,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 {
@@ -1936,22 +2159,12 @@ async function scheduleEmbeddingGeneration(args) {
   }
 }
 
-// src/globalId.ts
-function generateGlobalId() {
-  const bytes = new Uint8Array(16);
-  crypto.getRandomValues(bytes);
-  bytes[6] = bytes[6] & 15 | 64;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(
-    ""
-  );
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-
 // src/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()),
@@ -1996,20 +2209,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) {
@@ -2042,7 +2267,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,
@@ -2086,9 +2311,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"
@@ -2425,9 +2656,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()
   },
@@ -2470,6 +2702,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,
@@ -2483,6 +2742,9 @@ var forkBelief = mutation({
         ...metadata,
         forkedFrom: args.parentNodeId,
         forkReason: args.forkReason,
+        forkMode,
+        triggeringEvidenceId: args.triggeringEvidenceId,
+        triggeringEvidenceRelation: triggerEvidence.relation,
         forkTimestamp: now,
         forkedBy: authenticatedUserId,
         status: "active",
@@ -2501,6 +2763,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)
@@ -2527,12 +2810,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,
@@ -2557,6 +2845,9 @@ var forkBelief = mutation({
       newState: {
         formulation: args.newFormulation,
         forkReason: args.forkReason,
+        forkMode,
+        triggeringEvidenceId: String(triggerEvidence.evidenceNodeId),
+        triggeringEvidenceRelation: triggerEvidence.relation,
         tupleContradicted: false
       },
       projectId: parent.projectId,
@@ -2591,10 +2882,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)
@@ -2611,8 +2909,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"),
@@ -2624,7 +2920,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"),
@@ -2634,7 +2930,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")),
@@ -2997,6 +3294,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"),
@@ -3176,6 +3479,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()
   },
@@ -3199,16 +3503,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,
@@ -3839,6 +4181,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(
@@ -3877,10 +4221,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",
@@ -3896,11 +4244,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();
@@ -3964,9 +4311,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"
@@ -4140,7 +4493,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));
@@ -4246,7 +4599,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++;
@@ -4354,7 +4707,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",
@@ -4540,6 +4893,6 @@ var reassignBeliefsTopic = mutation({
   }
 });
 
-export { applyBeliefConfidenceChange, archive, backfillBeliefSprintIds, backfillMandatoryPriors, backfillScoredBeliefEdges, backfillSyntheticOpinionHistory, backfillTwoAxisConfidence, batchUpdateCriticality, create, deleteRelationship, flattenBeliefNode, forkBelief, getBeliefClusterPositions, getByCriticality, getById, getByIds, getByPillar, getByProject, getByProjectSystem, getByTopic, getByWorktree, getConfidenceHistory, getCountByStatus, getLineage, getRecentConfidenceChanges, getRelationships, getUnanalyzed, getWithEvidence, getWorktreeCluster, internalCreate, internalGetActive, internalGetById, internalGetByProject, internalGetByTopic, linkBeliefs, linkEvidence, modulateConfidence, propagateConfidenceChange, reassignBeliefsTopic, refineBelief, resolveBeliefWorktreeId, unlinkEvidence, updateCriticality, updatePillar, updateRationale, updateStatus, updateStatusInternal };
+export { appendSlScoring, applyBeliefConfidenceChange, archive, backfillBeliefSprintIds, backfillMandatoryPriors, backfillScoredBeliefEdges, backfillSyntheticOpinionHistory, backfillTwoAxisConfidence, batchUpdateCriticality, create, deleteRelationship, flattenBeliefNode, forkBelief, getBeliefClusterPositions, getByCriticality, getById, getByIds, getByPillar, getByProject, getByProjectSystem, getByTopic, getByWorktree, getConfidenceHistory, getCountByStatus, getLineage, getRecentConfidenceChanges, getRelationships, getUnanalyzed, getWithEvidence, getWorktreeCluster, internalCreate, internalGetActive, internalGetById, internalGetByProject, internalGetByTopic, linkBeliefs, linkEvidence, propagateConfidenceChange, reassignBeliefsTopic, refineBelief, resolveBeliefWorktreeId, unlinkEvidence, updateCriticality, updatePillar, updateRationale, updateStatus, updateStatusInternal };
 //# sourceMappingURL=epistemicBeliefs.js.map
 //# sourceMappingURL=epistemicBeliefs.js.map