@lucern/graph-primitives 1.0.22 → 1.0.24

package/dist/epistemicBeliefs.js

@@ -1,4 +1,4 @@
-import { v } from 'convex/values';
+import { v, ConvexError } from 'convex/values';
 import { normalizeTupleContradictionPolicy, mkOpinion, createInheritedContractRecord, confidenceFromSL, conditionalDeduction, project, dampedDependencyCascade, hasProjectedOpinionChanged, detectTupleContradiction, evaluateTupleContradictionTransition, readOpinionFromRecord, trustDiscount, applyNegativeSupport, cumulativeFusion, applyNegativeEvidence } from '@lucern/confidence';
 import { checkScopeAccess, checkProjectAccess } from '@lucern/access-control/access';
 import { canAudienceClassAccess, normalizeAudienceKey, classFromAudienceKey } from '@lucern/access-control/audience';
@@ -7,7 +7,8 @@ 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, generateUuidV7 } from '@lucern/contracts/ids';
+import { generateGlobalId, assertUuidV7Identity, generateUuidV7, assertStorageEdgeVocabulary, assertUuidShapedEdgeEndpoint } from '@lucern/contracts/ids';
+import { assertEdgePolicyAllowed, edgePolicyManifest } from '@lucern/contracts';
 import { listAudienceRegistryRows } from '@lucern/access-control/audienceRegistry';
 
 // src/epistemicBeliefs.helpers.ts
@@ -285,6 +286,9 @@ function materializeTopicProjectOverlay(topic, idMode = "legacy") {
     type: mapProjectType(topic, metadata),
     description: readNonEmptyString(topic.description),
     ownerId: readNonEmptyString(metadata.ownerId) || readNonEmptyString(topic.createdBy) || "system",
+    // FR.7 creator-grant: surface the principal-shaped owner field (column-first,
+    // metadata fallback for legacy rows that recorded it in metadata).
+    ownerPrincipalId: readNonEmptyString(topic.ownerPrincipalId) || readNonEmptyString(metadata.ownerPrincipalId),
     sharedWith: readStringArray(metadata.sharedWith),
     visibility,
     tenantId: readNonEmptyString(topic.tenantId) || readNonEmptyString(metadata.tenantId),
@@ -479,6 +483,35 @@ function resolveGraphPrimitivesAppResolvers(_ctx) {
   };
 }
 var LEGACY_SCOPE_FIELD2 = "graphScopeProjectId";
+async function resolveTopicNodeScopeOrNull(ctx, ref) {
+  if (!ctx?.db || typeof ctx.db.query !== "function") {
+    return null;
+  }
+  let node = null;
+  try {
+    const byGlobalId = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", ref)).first();
+    if (byGlobalId && byGlobalId.nodeType === "topic") {
+      node = byGlobalId;
+    }
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] topic-node scope lookup by globalId failed",
+      { error, ref }
+    );
+  }
+  if (!node) {
+    return null;
+  }
+  const scopeKey = normalizeScopeValue(node.topicId) ?? normalizeScopeValue(node.globalId);
+  if (!scopeKey) {
+    return null;
+  }
+  return {
+    topicId: scopeKey,
+    projectId: asMappedProjectId(node),
+    source: "topic_node"
+  };
+}
 function asMappedProjectId(topic) {
   if (!topic) {
     return;
@@ -619,6 +652,13 @@ async function resolveTopicProjectScope(ctx, args) {
       ) ?? null;
     }
     if (!topic) {
+      const nodeScope = await resolveTopicNodeScopeOrNull(
+        ctx,
+        String(args.topicId)
+      );
+      if (nodeScope) {
+        return nodeScope;
+      }
       throw new Error(`Topic not found: ${String(args.topicId)}`);
     }
     const inherited = await resolveInheritedWorkspaceScope(ctx, topic);
@@ -689,6 +729,16 @@ async function resolveTopicProjectScope(ctx, args) {
         source: "project_mapped_topic"
       };
     }
+    const nodeScope = await resolveTopicNodeScopeOrNull(
+      ctx,
+      String(args.projectId)
+    );
+    if (nodeScope) {
+      return {
+        ...nodeScope,
+        projectId: nodeScope.projectId ?? String(args.projectId)
+      };
+    }
     throw new Error(
       `Legacy project scope ${String(args.projectId)} has no mapped topic.`
     );
@@ -860,7 +910,18 @@ var DEFAULT_CONFIDENCE_POLICY = {
   tupleContradiction: normalizeTupleContradictionPolicy()
 };
 function throwStructuredMutationError(args) {
-  const error = new Error(args.message);
+  const data = {
+    structuredMutationError: true,
+    message: args.message,
+    status: args.status,
+    code: args.code,
+    invariantCode: args.invariantCode,
+    suggestion: args.suggestion,
+    details: args.details
+  };
+  const error = new ConvexError(
+    data
+  );
   error.status = args.status;
   error.code = args.code;
   error.invariantCode = args.invariantCode;
@@ -1209,12 +1270,12 @@ async function requireProjectWriteAccess(ctx, projectId, userId) {
   );
   if (!hasAccess) {
     throwStructuredMutationError({
-      message: "Project access required.",
+      message: `Project write access denied for topic ${projectId}.`,
       status: 403,
-      code: "FORBIDDEN",
+      code: "PROJECT_ACCESS_DENIED",
       invariantCode: "policy.scope_required",
-      suggestion: "Request write access for the project and retry.",
-      details: { projectId, userId }
+      suggestion: "The acting principal lacks project-write access to this topic. Request a topic grant (or, if the principal created this topic, run the creator-grant backfill) and retry.",
+      details: { topicId: projectId, principalId: userId }
     });
   }
 }
@@ -1870,14 +1931,14 @@ async function applyBeliefConfidenceChange(ctx, args) {
     beliefConfidenceId
   };
 }
-function propagationTriggerForEdge(edgeType, weight) {
+function propagationPressureLabel(edgeType, weight) {
   if (edgeType === "contradicts" || edgeType === "refutes") {
-    return "contradiction_detected";
+    return "contradictory";
   }
   if ((edgeType === "supports" || edgeType === "informs") && weight < 0) {
-    return "contradiction_detected";
+    return "contradictory";
   }
-  return "evidence_added";
+  return "supportive";
 }
 var propagateConfidenceChange = internalMutation({
   args: {
@@ -1914,14 +1975,15 @@ var propagateConfidenceChange = internalMutation({
       getNode: async (nodeId) => await ctx.db.get(nodeId)
     });
     for (const dispatch of dispatches) {
+      const pressureLabel = propagationPressureLabel(dispatch.edgeType, dispatch.weight);
       await applyBeliefConfidenceChange(ctx, {
         nodeId: dispatch.targetNodeId,
         belief: dispatch.opinion.b,
         disbelief: dispatch.opinion.d,
         uncertainty: dispatch.opinion.u,
         baseRate: dispatch.opinion.a,
-        trigger: propagationTriggerForEdge(dispatch.edgeType, dispatch.weight),
-        rationale: `SL propagation via ${dispatch.edgeType} edge: ${dispatch.rationale}`,
+        trigger: "propagation",
+        rationale: `SL propagation via ${dispatch.edgeType} edge (pressure: ${pressureLabel}): ${dispatch.rationale}`,
         authenticatedUserId: args.userId,
         slOperator: dispatch.operator
       });
@@ -2033,6 +2095,52 @@ async function resolveForkTriggerEvidence(ctx, args) {
   }
   return { evidenceNodeId: args.triggeringEvidenceId, relation };
 }
+async function insertEpistemicNode(ctx, doc) {
+  assertUuidV7Identity("epistemicNodes", doc.globalId);
+  return ctx.db.insert("epistemicNodes", doc);
+}
+async function assertExistingNodeEndpoint(ctx, endpointRole, endpoint) {
+  assertUuidShapedEdgeEndpoint(endpointRole, endpoint);
+  const node = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", endpoint)).first();
+  if (!node) {
+    throw new Error(
+      `edge_endpoint_not_canonical: epistemicEdges insert requires ${endpointRole} to be the globalId of an existing epistemicNodes row, received ${endpoint} (no node with that globalId)`
+    );
+  }
+}
+async function insertEpistemicEdge(ctx, doc) {
+  assertUuidV7Identity("epistemicEdges", doc.globalId);
+  assertStorageEdgeVocabulary(doc.edgeType);
+  if (!doc.fromNodeId || typeof doc.fromNodeId !== "string") {
+    throw new Error(
+      "edge_endpoint_missing: epistemicEdges insert requires a non-empty fromNodeId"
+    );
+  }
+  if (!doc.toNodeId || typeof doc.toNodeId !== "string") {
+    throw new Error(
+      "edge_endpoint_missing: epistemicEdges insert requires a non-empty toNodeId"
+    );
+  }
+  await assertExistingNodeEndpoint(ctx, "fromNodeId", doc.fromNodeId);
+  await assertExistingNodeEndpoint(ctx, "toNodeId", doc.toNodeId);
+  if (doc.fromNodeType && doc.toNodeType && doc.edgeType !== "extracted_from") {
+    assertEdgePolicyAllowed(
+      edgePolicyManifest,
+      doc.edgeType,
+      {
+        kind: "epistemic_node",
+        nodeId: doc.fromNodeId,
+        nodeType: doc.fromNodeType
+      },
+      {
+        kind: "epistemic_node",
+        nodeId: doc.toNodeId,
+        nodeType: doc.toNodeType
+      }
+    );
+  }
+  return ctx.db.insert("epistemicEdges", doc);
+}
 
 // src/epistemicBeliefs.topicAnchor.ts
 function cleanString(value) {
@@ -2084,18 +2192,15 @@ async function createRequiredBeliefTopicEdge(ctx, args) {
   const now = Date.now();
   const existingEdges = await ctx.db.query("epistemicEdges").withIndex(
     "by_from_to",
-    (q) => q.eq("fromNodeId", String(args.beliefNodeId)).eq(
-      "toNodeId",
-      String(args.topicNode._id)
-    )
+    (q) => q.eq("fromNodeId", args.beliefGlobalId).eq("toNodeId", topicGlobalId)
   ).collect();
   const existing = existingEdges.find((edge) => edge.edgeType === "belongs_to");
   const edgeGlobalId = cleanString(existing?.globalId) ?? generateUuidV7();
   if (!existing) {
-    await ctx.db.insert("epistemicEdges", {
+    await insertEpistemicEdge(ctx, {
       globalId: edgeGlobalId,
-      fromNodeId: String(args.beliefNodeId),
-      toNodeId: String(args.topicNode._id),
+      fromNodeId: args.beliefGlobalId,
+      toNodeId: topicGlobalId,
       sourceGlobalId: args.beliefGlobalId,
       targetGlobalId: topicGlobalId,
       edgeType: "belongs_to",
@@ -2274,7 +2379,7 @@ var create = mutation({
     const pillar = normalizePillar(args.pillar);
     const additionalMeta = args.metadata || {};
     const beliefGlobalId = generateGlobalId();
-    const nodeId = await ctx.db.insert("epistemicNodes", {
+    const nodeId = await insertEpistemicNode(ctx, {
       globalId: beliefGlobalId,
       nodeType: "belief",
       epistemicLayer: "L3",
@@ -2332,7 +2437,6 @@ var create = mutation({
       })
     );
     await createRequiredBeliefTopicEdge(ctx, {
-      beliefNodeId: nodeId,
       beliefGlobalId,
       topicNode,
       createdBy: authenticatedUserId
@@ -2747,7 +2851,7 @@ var forkBelief = mutation({
       });
     }
     const newBeliefGlobalId = generateGlobalId();
-    const newNodeId = await ctx.db.insert("epistemicNodes", {
+    const newNodeId = await insertEpistemicNode(ctx, {
       globalId: newBeliefGlobalId,
       nodeType: "belief",
       epistemicLayer: "L3",
@@ -3531,10 +3635,11 @@ var linkEvidence = mutation({
     const edgeType = "informs";
     const logicalRole = evidenceNodeId ? await computeLogicalRole(ctx, evidenceNodeId, args.beliefNodeId) : "contributory";
     const edgeGlobalId = generateGlobalId();
-    await ctx.db.insert("epistemicEdges", {
+    await insertEpistemicEdge(ctx, {
       globalId: edgeGlobalId,
-      fromNodeId: evidenceNodeId,
-      toNodeId: args.beliefNodeId,
+      // C2-RR.4 Defect E — canonical UUIDv7 endpoints, not Convex doc ids.
+      fromNodeId: evidenceGlobalId,
+      toNodeId: belief.globalId,
       sourceGlobalId: evidenceGlobalId,
       targetGlobalId: belief.globalId,
       edgeType,
@@ -4330,7 +4435,7 @@ var internalCreate = internalMutation({
       opinion_u: 1,
       opinion_a: baseRate
     };
-    const nodeId = await ctx.db.insert("epistemicNodes", {
+    const nodeId = await insertEpistemicNode(ctx, {
       globalId,
       topicId: scope.topicId,
       projectId: scope.projectId,
@@ -4386,7 +4491,6 @@ var internalCreate = internalMutation({
       })
     );
     await createRequiredBeliefTopicEdge(ctx, {
-      beliefNodeId: nodeId,
       beliefGlobalId: globalId,
       topicNode,
       createdBy: args.userId