@lucern/graph-primitives 1.0.15 → 1.0.17

package/dist/epistemicBeliefs.internal.js

@@ -264,6 +264,102 @@ var optionalScopeArgs = {
   projectId: v.optional(v.string()),
   topicId: v.optional(v.string())
 };
+
+// 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" }
+  });
+}
 function normalizeScopeValue2(value) {
   if (typeof value !== "string") {
     return;
@@ -362,18 +458,32 @@ function assertTenantPackWorkspaceMutationAllowed(args) {
 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;
@@ -393,47 +503,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";
 }
@@ -811,7 +935,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,
@@ -1131,6 +1255,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(
@@ -1169,10 +1295,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",
@@ -1188,11 +1318,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();
@@ -1256,9 +1385,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"