@lucern/graph-primitives 1.0.28 → 1.0.30

package/dist/beliefEvidenceLinks.js

@@ -1,386 +1,327 @@
-import { v } from 'convex/values';
-import { componentsGeneric, anyApi, mutationGeneric, queryGeneric } from 'convex/server';
 import { checkProjectAccess } from '@lucern/access-control/access';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { generateGlobalId, assertUuidV7Identity, assertStorageEdgeVocabulary, assertUuidShapedEdgeEndpoint } from '@lucern/contracts/ids';
+import { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, mutationGeneric, queryGeneric } from 'convex/server';
 import { assertEdgePolicyAllowed, edgePolicyManifest } from '@lucern/contracts';
+import { generateGlobalId, assertUuidV7Identity, assertStorageEdgeVocabulary, assertUuidShapedEdgeEndpoint } from '@lucern/contracts/ids';
 
 // src/beliefEvidenceLinks.ts
-
-// src/matcherFeedbackUtils.ts
-function isOperationalLinkStatus(status) {
-  return status !== "suggested" && status !== "dismissed";
-}
-function mergeLinkSuggestionStatus(existing, requested) {
-  if (requested === void 0 || requested === null) {
-    return existing ?? void 0;
-  }
-  if (existing && isOperationalLinkStatus(existing) && !isOperationalLinkStatus(requested)) {
-    return existing;
+var unsafeApi = unsafeConvexAnyApi(
+  "graph-primitives top-level module bundle lacks a committed Convex _generated/api surface"
+);
+var api = unsafeApi;
+componentsGeneric();
+var internal = unsafeApi;
+var mutation = mutationGeneric;
+var query = queryGeneric;
+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)`
+    );
   }
-  return requested;
-}
-function resolveReviewedLinkStatus(requested) {
-  return requested;
 }
-function deriveMatcherReviewStatus(input) {
-  if (input.explicitReviewStatus) {
-    return input.explicitReviewStatus;
-  }
-  if (input.autoAccepted) {
-    return "auto_accepted";
+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 (input.linkStatus === "suggested") {
-    return "pending";
+  if (!doc.toNodeId || typeof doc.toNodeId !== "string") {
+    throw new Error(
+      "edge_endpoint_missing: epistemicEdges insert requires a non-empty toNodeId"
+    );
   }
-  if (input.linkStatus === "dismissed") {
-    return "rejected";
+  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 "accepted";
+  return ctx.db.insert("epistemicEdges", doc);
 }
-var api = anyApi;
-componentsGeneric();
-var internal = anyApi;
-var mutation = mutationGeneric;
-var query = queryGeneric;
 
-// src/debug.ts
-function isGraphPrimitiveDebugEnabled() {
-  const env = globalThis.process?.env;
-  return env?.LUCERN_COMPAT_FALLBACK_DEBUG === "1" || env?.LUCERN_GRAPH_DEBUG === "1";
+// src/beliefEvidenceLinks.operational.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
 }
-function debugGraphPrimitiveFallback(message, context) {
-  if (!isGraphPrimitiveDebugEnabled()) {
-    return;
-  }
-  console.debug(message, context ?? {});
+function readConvexId(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
 }
-
-// src/topicScope.ts
-var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
-async function resolveTopicNodeScopeOrNull(ctx, ref) {
-  if (!ctx?.db || typeof ctx.db.query !== "function") {
+function readEpistemicEdgeDoc(value) {
+  if (!isRecord(value)) {
     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) {
+  const id = readConvexId(value._id);
+  if (!id || typeof value.edgeType !== "string" || typeof value.globalId !== "string") {
     return null;
   }
   return {
-    topicId: scopeKey,
-    projectId: asMappedProjectId(node),
-    source: "topic_node"
+    _id: id,
+    edgeType: value.edgeType,
+    globalId: value.globalId
   };
 }
-function asMappedProjectId(topic) {
-  if (!topic) {
-    return;
-  }
-  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD]);
-  if (directLegacyProjectId) {
-    return directLegacyProjectId;
-  }
-  const metadata = topic.metadata || {};
-  const candidate = metadata[LEGACY_SCOPE_FIELD] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
-  return candidate ? candidate : void 0;
-}
-function normalizeScopeValue(value) {
-  if (typeof value !== "string") {
-    return;
+function readInsightIdArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
   }
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : void 0;
-}
-function pickPrimaryTopic(candidates) {
-  return [...candidates].sort((a, b) => {
-    const depthA = a.depth ?? 9999;
-    const depthB = b.depth ?? 9999;
-    if (depthA !== depthB) {
-      return depthA - depthB;
-    }
-    const createdA = a.createdAt ?? Number.MAX_SAFE_INTEGER;
-    const createdB = b.createdAt ?? Number.MAX_SAFE_INTEGER;
-    if (createdA !== createdB) {
-      return createdA - createdB;
-    }
-    return String(a.name || "").localeCompare(String(b.name || ""));
-  })[0];
+  return value.flatMap((entry) => {
+    const id = readConvexId(entry);
+    return id ? [id] : [];
+  });
 }
-async function findTopicsByScopeAlias(ctx, scopeId) {
-  try {
-    return await ctx.db.query("topics").withIndex(
-      "by_graph_scope_project",
-      (q) => q.eq(LEGACY_SCOPE_FIELD, scopeId)
-    ).collect();
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicScope] Failed to resolve scope alias via index",
-      {
-        error,
-        scopeId
-      }
-    );
-    const topics = await ctx.db.query("topics").collect();
-    return topics.filter((topic) => {
-      const normalizedGlobalId = normalizeScopeValue(topic.globalId);
-      const mappedProjectId = asMappedProjectId(topic);
-      return String(topic._id) === scopeId || normalizedGlobalId === scopeId || mappedProjectId === scopeId;
-    });
+function readInsightIdCollections(value) {
+  if (!isRecord(value)) {
+    return {
+      contradictingInsightIds: [],
+      supportingInsightIds: []
+    };
   }
+  return {
+    contradictingInsightIds: readInsightIdArray(value.contradictingInsightIds),
+    supportingInsightIds: readInsightIdArray(value.supportingInsightIds)
+  };
 }
-async function tryResolveHostTopicById(ctx, topicId) {
-  if (typeof ctx.runQuery !== "function") {
+function readSpineNodeDoc(value) {
+  if (!isRecord(value)) {
     return null;
   }
-  try {
-    return await ctx.runQuery(api.topics.get, {
-      id: topicId
-    }) ?? null;
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicScope] Failed to resolve topic by host query",
-      {
-        error,
-        topicId
-      }
-    );
+  const id = readConvexId(value._id);
+  if (!id || typeof value.globalId !== "string" || typeof value.nodeType !== "string") {
     return null;
   }
+  return {
+    _id: id,
+    globalId: value.globalId,
+    nodeType: value.nodeType
+  };
 }
-async function tryResolveHostTopicByLegacyScope(ctx, legacyScopeId) {
-  if (typeof ctx.runQuery !== "function") {
-    return null;
-  }
-  try {
-    return await ctx.runQuery(api.topics.getByLegacyScopeId, {
-      projectId: legacyScopeId
-    }) ?? null;
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicScope] Failed to resolve topic by legacy scope",
-      {
-        error,
-        legacyScopeId
-      }
+async function insertOperationalEpistemicEdge(ctx, doc) {
+  await insertEpistemicEdge(
+    ctx,
+    doc
+  );
+}
+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]"
     );
-    return null;
   }
-}
-async function resolveInheritedWorkspaceScope(ctx, topic) {
-  const MAX_DEPTH = 10;
-  let tenantId = normalizeScopeValue(topic.tenantId);
-  let workspaceId = normalizeScopeValue(topic.workspaceId);
-  if (tenantId && workspaceId) {
-    return { tenantId, workspaceId };
+  if (args.relation === "supports" && args.weight < 0) {
+    throw new Error("Supporting evidence links require positive weight");
   }
-  let current = topic;
-  for (let i = 0; i < MAX_DEPTH && current?.parentTopicId; i++) {
-    current = await ctx.db.get(current.parentTopicId);
-    if (!current) break;
-    if (!tenantId) {
-      tenantId = normalizeScopeValue(current.tenantId);
-    }
-    if (!workspaceId) {
-      workspaceId = normalizeScopeValue(current.workspaceId);
-    }
-    if (tenantId && workspaceId) break;
+  if (args.relation === "contradicts" && args.weight > 0) {
+    throw new Error("Contradicting evidence links require negative weight");
   }
-  return { tenantId, workspaceId };
 }
-async function resolveTopicProjectScope(ctx, args) {
-  if (args.topicId) {
-    let topic = null;
-    try {
-      topic = await ctx.db.get(
-        args.topicId
-      );
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[topicScope] Failed to load topic by direct id",
-        {
-          error,
-          topicId: args.topicId
+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" && !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(
+        (id) => id !== args.insightId
+      )
+    });
+  }
+  try {
+    const beliefSpineNode = readSpineNodeDoc(await ctx.db.get(args.beliefId));
+    const evidenceSpineNode = readSpineNodeDoc(
+      await ctx.db.get(args.insightId)
+    );
+    if (beliefSpineNode?.nodeType === "belief" && evidenceSpineNode?.nodeType === "evidence") {
+      const existingEdges = (await ctx.db.query("epistemicEdges").withIndex(
+        "by_from_to",
+        (q) => q.eq("fromNodeId", evidenceSpineNode.globalId).eq("toNodeId", beliefSpineNode.globalId)
+      ).collect()).map(readEpistemicEdgeDoc).filter((edge) => edge !== null);
+      for (const edge of existingEdges) {
+        if (edge.edgeType === "informs") {
+          await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
+            globalId: edge.globalId
+          });
+          await ctx.db.delete(edge._id);
         }
-      );
-    }
-    if (!topic) {
-      topic = await tryResolveHostTopicById(ctx, String(args.topicId));
-    }
-    if (!topic) {
-      topic = pickPrimaryTopic(
-        await findTopicsByScopeAlias(ctx, String(args.topicId))
-      ) ?? 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);
-    const mapped = asMappedProjectId(topic);
-    if (mapped) {
-      return {
-        topicId: topic._id,
-        projectId: mapped,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "topic"
-      };
+      const globalId = generateGlobalId();
+      const context = args.rationale || `Linked as ${args.relation}`;
+      await insertOperationalEpistemicEdge(ctx, {
+        globalId,
+        // C2-RR.4 Defect E — canonical UUIDv7 endpoints, not Convex doc ids.
+        fromNodeId: evidenceSpineNode.globalId,
+        toNodeId: beliefSpineNode.globalId,
+        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: args.weight,
+        confidence,
+        context,
+        projectId: args.beliefNode.projectId ? String(args.beliefNode.projectId) : void 0,
+        createdBy: args.createdBy,
+        fromNodeType: "evidence",
+        toNodeType: "belief",
+        fromLayer: "L2",
+        toLayer: "L3"
+      });
     }
-    return {
-      topicId: topic._id,
-      tenantId: inherited.tenantId,
-      workspaceId: inherited.workspaceId,
-      source: "topic"
-    };
+  } catch (e) {
+    console.error("[EpistemicSpine] Failed to create informs edge:", e);
   }
-  if (args.projectId) {
-    let directTopic = null;
-    try {
-      directTopic = await ctx.db.get(
-        args.projectId
-      );
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[topicScope] Failed to load direct project topic",
-        {
-          error,
-          projectId: args.projectId
-        }
-      );
-    }
-    if (directTopic) {
-      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
-      const mapped = asMappedProjectId(directTopic);
-      return {
-        topicId: directTopic._id,
-        projectId: mapped ?? args.projectId,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "topic_inferred"
-      };
-    }
-    directTopic = await tryResolveHostTopicByLegacyScope(ctx, args.projectId);
-    if (directTopic) {
-      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
-      const mapped = asMappedProjectId(directTopic);
-      return {
-        topicId: directTopic._id,
-        projectId: mapped ?? args.projectId,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "topic_inferred"
-      };
-    }
-    const topics = await findTopicsByScopeAlias(ctx, args.projectId);
-    const primary = pickPrimaryTopic(topics);
-    if (primary) {
-      const inherited = await resolveInheritedWorkspaceScope(ctx, primary);
-      return {
-        topicId: primary._id,
-        projectId: args.projectId,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "project_mapped_topic"
-      };
+  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
+    });
+  }
+}
+async function removeOperationalLinkEffects(ctx, args) {
+  const belief = await ctx.db.get(args.beliefId);
+  if (belief) {
+    const { contradictingInsightIds, supportingInsightIds } = readInsightIdCollections(belief);
+    if (args.relation === "supports") {
+      await ctx.db.patch(args.beliefId, {
+        supportingInsightIds: supportingInsightIds.filter(
+          (id) => id !== args.insightId
+        )
+      });
+    } else {
+      await ctx.db.patch(args.beliefId, {
+        contradictingInsightIds: contradictingInsightIds.filter(
+          (id) => id !== args.insightId
+        )
+      });
     }
-    const nodeScope = await resolveTopicNodeScopeOrNull(
-      ctx,
-      String(args.projectId)
+  }
+  try {
+    const beliefSpineNode = readSpineNodeDoc(await ctx.db.get(args.beliefId));
+    const evidenceSpineNode = readSpineNodeDoc(
+      await ctx.db.get(args.insightId)
     );
-    if (nodeScope) {
-      return {
-        ...nodeScope,
-        projectId: nodeScope.projectId ?? String(args.projectId)
-      };
+    if (beliefSpineNode?.nodeType === "belief" && evidenceSpineNode?.nodeType === "evidence") {
+      const edges = (await ctx.db.query("epistemicEdges").withIndex(
+        "by_from_to",
+        (q) => q.eq("fromNodeId", evidenceSpineNode._id).eq("toNodeId", beliefSpineNode._id)
+      ).collect()).map(readEpistemicEdgeDoc).filter((edge) => edge !== null);
+      for (const edge of edges) {
+        if (edge.edgeType === "informs") {
+          await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
+            globalId: edge.globalId
+          });
+          await ctx.db.delete(edge._id);
+        }
+      }
     }
-    throw new Error(
-      `Legacy project scope ${String(args.projectId)} has no mapped topic.`
-    );
+  } catch (e) {
+    console.error("[EpistemicSpine] Failed to remove informs edge:", e);
   }
-  throw new Error(
-    "Missing scope: provide topicId (preferred) or legacy projectId alias."
-  );
 }
-var optionalScopeArgs = {
-  projectId: v.optional(v.string()),
-  topicId: v.optional(v.string())
-};
 
-// src/scopeResolverCompat.ts
-var scopeArgs = optionalScopeArgs;
-function normalizeScopeValue2(value) {
-  if (typeof value !== "string") {
-    return;
+// src/matcherFeedbackUtils.ts
+function isOperationalLinkStatus(status) {
+  return status !== "suggested" && status !== "dismissed";
+}
+function mergeLinkSuggestionStatus(existing, requested) {
+  if (requested === void 0 || requested === null) {
+    return existing ?? void 0;
   }
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : void 0;
+  if (existing && isOperationalLinkStatus(existing) && !isOperationalLinkStatus(requested)) {
+    return existing;
+  }
+  return requested;
 }
-async function resolveScope(ctx, args) {
-  const topicId = normalizeScopeValue2(args.topicId);
-  const projectId = normalizeScopeValue2(args.projectId);
-  if (!topicId && !projectId) {
-    return null;
+function resolveReviewedLinkStatus(requested) {
+  return requested;
+}
+function deriveMatcherReviewStatus(input) {
+  if (input.explicitReviewStatus) {
+    return input.explicitReviewStatus;
   }
-  try {
-    return await resolveTopicProjectScope(ctx, {
-      topicId,
-      projectId
-    });
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[scopeResolverCompat] Failed to resolve scope",
-      {
-        error,
-        topicId,
-        projectId
-      }
-    );
-    return null;
+  if (input.autoAccepted) {
+    return "auto_accepted";
+  }
+  if (input.linkStatus === "suggested") {
+    return "pending";
+  }
+  if (input.linkStatus === "dismissed") {
+    return "rejected";
   }
+  return "accepted";
 }
-async function resolveScopeSoft(ctx, args) {
-  const resolved = await resolveScope(ctx, args);
-  if (resolved) {
-    const topicId2 = normalizeScopeValue2(resolved.topicId);
-    return {
-      ...topicId2 ? { topicId: topicId2 } : {},
-      ...resolved.projectId ? { projectId: resolved.projectId } : {},
-      ...resolved.tenantId ? { tenantId: resolved.tenantId } : {},
-      ...resolved.workspaceId ? { workspaceId: resolved.workspaceId } : {},
-      ...resolved.source ? { source: resolved.source } : {}
-    };
+
+// src/debug.ts
+function isGraphPrimitiveDebugEnabled() {
+  const env = globalThis.process?.env;
+  return env?.LUCERN_COMPAT_FALLBACK_DEBUG === "1" || env?.LUCERN_GRAPH_DEBUG === "1";
+}
+function debugGraphPrimitiveFallback(message, context) {
+  if (!isGraphPrimitiveDebugEnabled()) {
+    return;
   }
-  const topicId = normalizeScopeValue2(args.topicId);
-  const projectId = normalizeScopeValue2(args.projectId);
-  return {
-    ...topicId ? { topicId } : {},
-    ...projectId ? { projectId } : {}
-  };
+  console.debug(message, context ?? {});
 }
 
 // src/topicProjectOverlay.ts
-var LEGACY_SCOPE_FIELD2 = "graphScopeProjectId";
+var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
 function readNonEmptyString(value) {
   if (typeof value !== "string") {
     return;
@@ -397,11 +338,15 @@ function readStringArray(value) {
 function readMetadata(topic) {
   return topic.metadata && typeof topic.metadata === "object" ? topic.metadata : {};
 }
+function omitMetadataKey(metadata, key) {
+  const { [key]: _omitted, ...rest } = metadata;
+  return rest;
+}
 function readLegacyProjectId(value) {
   if (!value) {
     return;
   }
-  return readNonEmptyString(value[LEGACY_SCOPE_FIELD2]);
+  return readNonEmptyString(value[LEGACY_SCOPE_FIELD]);
 }
 function coerceVisibility(value) {
   return value === "private" || value === "team" || value === "firm" || value === "external" || value === "public" ? value : void 0;
@@ -477,9 +422,12 @@ async function resolveTopicDoc(ctx, scopeId) {
     );
   }
   try {
-    const topic = await ctx.runQuery(api.topics.getByLegacyScopeId, {
-      projectId: String(scopeId)
-    });
+    const topic = await ctx.runQuery(
+      api.topics.getByLegacyScopeId,
+      {
+        projectId: String(scopeId)
+      }
+    );
     if (topic?.name !== void 0 && topic?.type !== void 0) {
       return topic;
     }
@@ -499,8 +447,18 @@ function materializeTopicProjectOverlay(topic, idMode = "legacy") {
   const outwardId = idMode === "topic" ? topicId : storageProjectId;
   const visibility = coerceVisibility(topic.visibility) || coerceVisibility(metadata.visibility) || "private";
   const status = coerceStatus(topic.status) || coerceStatus(metadata.status) || "active";
-  const createdAt = typeof topic.createdAt === "number" ? topic.createdAt : typeof topic._creationTime === "number" ? topic._creationTime : 0;
-  const updatedAt = typeof topic.updatedAt === "number" ? topic.updatedAt : typeof metadata.updatedAt === "number" ? metadata.updatedAt : createdAt;
+  let createdAt = 0;
+  if (typeof topic.createdAt === "number") {
+    createdAt = topic.createdAt;
+  } else if (typeof topic._creationTime === "number") {
+    createdAt = topic._creationTime;
+  }
+  let updatedAt = createdAt;
+  if (typeof topic.updatedAt === "number") {
+    updatedAt = topic.updatedAt;
+  } else if (typeof metadata.updatedAt === "number") {
+    updatedAt = metadata.updatedAt;
+  }
   return {
     ...metadata,
     _id: outwardId,
@@ -569,90 +527,113 @@ async function patchTopicProjectOverlay(ctx, scopeId, value) {
   if (!topic) {
     return null;
   }
-  const nextMetadata = { ...readMetadata(topic) };
-  const patch = {};
-  const topicUpdateArgs = {
-    id: String(topic._id)
+  const plan = buildTopicProjectOverlayPatchPlan(topic, value);
+  await applyTopicProjectOverlayPatch(ctx, topic, plan);
+  return materializeTopicProjectOverlay({
+    ...topic,
+    ...plan.patch,
+    metadata: plan.nextMetadata
+  });
+}
+function buildTopicProjectOverlayPatchPlan(topic, value) {
+  const plan = {
+    nextMetadata: { ...readMetadata(topic) },
+    patch: {},
+    topicUpdateArgs: {
+      id: String(topic._id)
+    }
   };
   for (const [key, rawValue] of Object.entries(value)) {
-    switch (key) {
-      case "_id":
-      case "projectId":
-      case "topicId":
-      case "legacyProjectId":
-      case "storageProjectId":
-        break;
-      case "name":
-      case "description":
-        patch[key] = rawValue;
-        topicUpdateArgs[key] = rawValue;
-        break;
-      case "tenantId":
-      case "workspaceId":
-      case "ownerId":
-        throw new Error(
-          `patchTopicProjectOverlay cannot mutate ${key} via component-owned topics`
-        );
-      case "status": {
-        const status = coerceStatus(rawValue);
-        if (status) {
-          patch.status = status;
-          topicUpdateArgs.status = status;
-        }
-        break;
-      }
-      case "visibility": {
-        const visibility = coerceVisibility(rawValue);
-        if (visibility) {
-          patch.visibility = visibility;
-          topicUpdateArgs.visibility = visibility;
-        }
-        break;
-      }
-      case "type": {
-        const projectType = readNonEmptyString(rawValue);
-        if (projectType) {
-          nextMetadata.projectType = projectType;
-        } else {
-          delete nextMetadata.projectType;
-        }
-        break;
-      }
-      case "updatedAt":
-      case "createdAt":
-        break;
-      default:
-        if (rawValue === void 0) {
-          delete nextMetadata[key];
-        } else {
-          nextMetadata[key] = rawValue;
-        }
-    }
+    applyTopicProjectOverlayPatchEntry(plan, key, rawValue);
+  }
+  plan.patch.updatedAt = Date.now();
+  plan.patch.metadata = plan.nextMetadata;
+  plan.topicUpdateArgs.metadata = plan.nextMetadata;
+  return plan;
+}
+function applyTopicProjectOverlayPatchEntry(plan, key, rawValue) {
+  switch (key) {
+    case "_id":
+    case "projectId":
+    case "topicId":
+    case "legacyProjectId":
+    case "storageProjectId":
+    case "updatedAt":
+    case "createdAt":
+      return;
+    case "name":
+    case "description":
+      plan.patch[key] = rawValue;
+      plan.topicUpdateArgs[key] = rawValue;
+      return;
+    case "tenantId":
+    case "workspaceId":
+    case "ownerId":
+      throw new Error(
+        `patchTopicProjectOverlay cannot mutate ${key} via component-owned topics`
+      );
+    case "status":
+      applyTopicStatusPatch(plan, rawValue);
+      return;
+    case "visibility":
+      applyTopicVisibilityPatch(plan, rawValue);
+      return;
+    case "type":
+      applyTopicProjectTypePatch(plan, rawValue);
+      return;
+    default:
+      applyTopicMetadataPatch(plan, key, rawValue);
+  }
+}
+function applyTopicStatusPatch(plan, rawValue) {
+  const status = coerceStatus(rawValue);
+  if (status) {
+    plan.patch.status = status;
+    plan.topicUpdateArgs.status = status;
+  }
+}
+function applyTopicVisibilityPatch(plan, rawValue) {
+  const visibility = coerceVisibility(rawValue);
+  if (visibility) {
+    plan.patch.visibility = visibility;
+    plan.topicUpdateArgs.visibility = visibility;
+  }
+}
+function applyTopicProjectTypePatch(plan, rawValue) {
+  const projectType = readNonEmptyString(rawValue);
+  if (projectType) {
+    plan.nextMetadata.projectType = projectType;
+    return;
+  }
+  plan.nextMetadata = omitMetadataKey(plan.nextMetadata, "projectType");
+}
+function applyTopicMetadataPatch(plan, key, rawValue) {
+  if (rawValue === void 0) {
+    plan.nextMetadata = omitMetadataKey(plan.nextMetadata, key);
+    return;
   }
-  patch.updatedAt = Date.now();
-  patch.metadata = nextMetadata;
-  topicUpdateArgs.metadata = nextMetadata;
+  plan.nextMetadata[key] = rawValue;
+}
+async function applyTopicProjectOverlayPatch(ctx, topic, plan) {
   if (typeof ctx.runMutation === "function") {
     try {
-      await ctx.runMutation(api.topics.update, topicUpdateArgs);
+      await ctx.runMutation(api.topics.update, plan.topicUpdateArgs);
     } catch (error) {
-      if (!isMissingLucernChildComponentError(error) || !ctx?.db || typeof ctx.db.patch !== "function") {
+      if (!canPatchTopicViaLocalDb(ctx, error)) {
         throw error;
       }
-      await ctx.db.patch(String(topic._id), patch);
+      await ctx.db.patch(topic._id, plan.patch);
     }
   } else if (ctx?.db && typeof ctx.db.patch === "function") {
-    await ctx.db.patch(String(topic._id), patch);
+    await ctx.db.patch(topic._id, plan.patch);
   } else {
     throw new Error(
       "Cannot patch topic without component adapter (ctx.runMutation unavailable)"
     );
   }
-  return materializeTopicProjectOverlay({
-    ...topic,
-    ...patch,
-    metadata: nextMetadata
-  });
+}
+function canPatchTopicViaLocalDb(ctx, error) {
+  return isMissingLucernChildComponentError(error) && Boolean(ctx?.db) && typeof ctx.db?.patch === "function";
 }
 
 // src/resolvers.ts
@@ -680,7 +661,7 @@ async function patchProjectWithTolerance(ctx, projectId, value) {
   try {
     await patchTopicProjectOverlay(ctx, projectId, value);
   } catch (error) {
-    if (!isAdvisoryTopicPatch(value) || !isMissingLucernChildComponentError2(error)) {
+    if (!(isAdvisoryTopicPatch(value) && isMissingLucernChildComponentError2(error))) {
       throw error;
     }
     console.warn(
@@ -713,196 +694,307 @@ function resolveGraphPrimitivesAppResolvers(_ctx) {
     ...resolverOverrides
   };
 }
-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)`
+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"
+  };
 }
-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"
-    );
+function asMappedProjectId(topic) {
+  if (!topic) {
+    return;
   }
-  if (!doc.toNodeId || typeof doc.toNodeId !== "string") {
-    throw new Error(
-      "edge_endpoint_missing: epistemicEdges insert requires a non-empty toNodeId"
+  const directLegacyProjectId = normalizeScopeValue(
+    topic[LEGACY_SCOPE_FIELD2]
+  );
+  if (directLegacyProjectId) {
+    return directLegacyProjectId;
+  }
+  const metadata = topic.metadata || {};
+  const candidate = metadata[LEGACY_SCOPE_FIELD2] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
+  return typeof candidate === "string" ? normalizeScopeValue(candidate) : void 0;
+}
+function normalizeScopeValue(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function pickPrimaryTopic(candidates) {
+  return [...candidates].sort((a, b) => {
+    const depthA = a.depth ?? 9999;
+    const depthB = b.depth ?? 9999;
+    if (depthA !== depthB) {
+      return depthA - depthB;
+    }
+    const createdA = a.createdAt ?? Number.MAX_SAFE_INTEGER;
+    const createdB = b.createdAt ?? Number.MAX_SAFE_INTEGER;
+    if (createdA !== createdB) {
+      return createdA - createdB;
+    }
+    return String(a.name || "").localeCompare(String(b.name || ""));
+  })[0];
+}
+async function findTopicsByScopeAlias(ctx, scopeId) {
+  const query2 = ctx.db.query("topics");
+  try {
+    return await query2.withIndex(
+      "by_graph_scope_project",
+      (q) => q.eq(LEGACY_SCOPE_FIELD2, scopeId)
+    ).collect();
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve scope alias via index",
+      {
+        error,
+        scopeId
+      }
     );
+    const topics = await query2.collect();
+    return topics.filter((topic) => {
+      const normalizedGlobalId = normalizeScopeValue(topic.globalId);
+      const mappedProjectId = asMappedProjectId(topic);
+      return String(topic._id) === scopeId || normalizedGlobalId === scopeId || mappedProjectId === scopeId;
+    });
   }
-  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,
+}
+async function tryResolveHostTopicById(ctx, topicId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api.topics.get, {
+      id: topicId
+    }) ?? null;
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve topic by host query",
       {
-        kind: "epistemic_node",
-        nodeId: doc.fromNodeId,
-        nodeType: doc.fromNodeType
-      },
+        error,
+        topicId
+      }
+    );
+    return null;
+  }
+}
+async function tryResolveHostTopicByLegacyScope(ctx, legacyScopeId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api.topics.getByLegacyScopeId, {
+      projectId: legacyScopeId
+    }) ?? null;
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve topic by legacy scope",
       {
-        kind: "epistemic_node",
-        nodeId: doc.toNodeId,
-        nodeType: doc.toNodeType
+        error,
+        legacyScopeId
       }
     );
+    return null;
+  }
+}
+async function resolveInheritedWorkspaceScope(ctx, topic) {
+  const MAX_DEPTH = 10;
+  let tenantId = normalizeScopeValue(topic.tenantId);
+  let workspaceId = normalizeScopeValue(topic.workspaceId);
+  if (tenantId && workspaceId) {
+    return { tenantId, workspaceId };
+  }
+  let current = topic;
+  for (let i = 0; i < MAX_DEPTH && current?.parentTopicId; i++) {
+    current = await ctx.db.get(current.parentTopicId);
+    if (!current) {
+      break;
+    }
+    if (!tenantId) {
+      tenantId = normalizeScopeValue(current.tenantId);
+    }
+    if (!workspaceId) {
+      workspaceId = normalizeScopeValue(current.workspaceId);
+    }
+    if (tenantId && workspaceId) {
+      break;
+    }
   }
-  return ctx.db.insert("epistemicEdges", doc);
+  return { tenantId, workspaceId };
 }
-
-// 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]");
+async function resolveTopicProjectScope(ctx, args) {
+  if (args.topicId) {
+    return await resolveScopeFromTopicId(ctx, args.topicId);
   }
-  if (args.relation === "supports" && args.weight < 0) {
-    throw new Error("Supporting evidence links require positive weight");
+  if (args.projectId) {
+    return await resolveScopeFromLegacyProjectId(ctx, args.projectId);
   }
-  if (args.relation === "contradicts" && args.weight > 0) {
-    throw new Error("Contradicting evidence links require negative weight");
+  throw new Error(
+    "Missing scope: provide topicId (preferred) or legacy projectId alias."
+  );
+}
+async function resolveScopeFromTopicId(ctx, topicId) {
+  const topic = await resolveTopicDocFromTopicId(ctx, topicId);
+  if (topic) {
+    return await buildTopicScope(ctx, topic, "topic");
   }
+  const nodeScope = await resolveTopicNodeScopeOrNull(ctx, String(topicId));
+  if (nodeScope) {
+    return nodeScope;
+  }
+  throw new Error(`Topic not found: ${String(topicId)}`);
 }
-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" && !currentSupporting.includes(args.insightId)) {
-    await ctx.db.patch(args.beliefId, {
-      supportingInsightIds: [...currentSupporting, args.insightId],
-      contradictingInsightIds: currentContradicting.filter(
-        (id) => id !== args.insightId
-      )
+async function resolveTopicDocFromTopicId(ctx, topicId) {
+  const direct = await tryReadTopicDoc(ctx, topicId, {
+    failureLog: "[topicScope] Failed to load topic by direct id",
+    idLogKey: "topicId"
+  });
+  if (direct) {
+    return direct;
+  }
+  const hostTopic = await tryResolveHostTopicById(ctx, String(topicId));
+  if (hostTopic) {
+    return hostTopic;
+  }
+  return pickPrimaryTopic(await findTopicsByScopeAlias(ctx, String(topicId))) ?? null;
+}
+async function resolveScopeFromLegacyProjectId(ctx, legacyProjectId) {
+  const directTopic = await resolveDirectLegacyProjectTopic(
+    ctx,
+    legacyProjectId
+  );
+  if (directTopic) {
+    return await buildTopicScope(ctx, directTopic, "topic_inferred", {
+      fallbackProjectId: legacyProjectId
     });
-  } else if (args.relation === "contradicts" && !currentContradicting.includes(args.insightId)) {
-    await ctx.db.patch(args.beliefId, {
-      contradictingInsightIds: [...currentContradicting, args.insightId],
-      supportingInsightIds: currentSupporting.filter(
-        (id) => id !== args.insightId
-      )
+  }
+  const primary = pickPrimaryTopic(
+    await findTopicsByScopeAlias(ctx, legacyProjectId)
+  );
+  if (primary) {
+    return await buildTopicScope(ctx, primary, "project_mapped_topic", {
+      fallbackProjectId: legacyProjectId
     });
   }
-  try {
-    const beliefSpineNode = await ctx.db.get(args.beliefId);
-    const evidenceSpineNode = await ctx.db.get(args.insightId);
-    if (beliefSpineNode?.nodeType === "belief" && evidenceSpineNode?.nodeType === "evidence") {
-      const existingEdges = await ctx.db.query("epistemicEdges").withIndex(
-        "by_from_to",
-        (q) => q.eq("fromNodeId", evidenceSpineNode.globalId).eq("toNodeId", beliefSpineNode.globalId)
-      ).collect();
-      for (const edge of existingEdges) {
-        if (edge.edgeType === "informs") {
-          await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
-            globalId: edge.globalId
-          });
-          await ctx.db.delete(edge._id);
-        }
-      }
-      const globalId = generateGlobalId();
-      const context = args.rationale || `Linked as ${args.relation}`;
-      await insertEpistemicEdge(ctx, {
-        globalId,
-        // C2-RR.4 Defect E — canonical UUIDv7 endpoints, not Convex doc ids.
-        fromNodeId: evidenceSpineNode.globalId,
-        toNodeId: beliefSpineNode.globalId,
-        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: args.weight,
-        confidence,
-        context,
-        projectId: args.beliefNode.projectId ? String(args.beliefNode.projectId) : void 0,
-        createdBy: args.createdBy,
-        fromNodeType: "evidence",
-        toNodeType: "belief",
-        fromLayer: "L2",
-        toLayer: "L3"
-      });
-    }
-  } catch (e) {
-    console.error("[EpistemicSpine] Failed to create informs edge:", e);
+  const nodeScope = await resolveTopicNodeScopeOrNull(ctx, legacyProjectId);
+  if (nodeScope) {
+    return {
+      ...nodeScope,
+      projectId: nodeScope.projectId ?? legacyProjectId
+    };
   }
-  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
+  throw new Error(
+    `Legacy project scope ${legacyProjectId} has no mapped topic.`
+  );
+}
+async function resolveDirectLegacyProjectTopic(ctx, legacyProjectId) {
+  const directTopic = await tryReadTopicDoc(ctx, legacyProjectId, {
+    failureLog: "[topicScope] Failed to load direct project topic",
+    idLogKey: "projectId"
+  });
+  return directTopic ?? tryResolveHostTopicByLegacyScope(ctx, legacyProjectId);
+}
+async function tryReadTopicDoc(ctx, id, log) {
+  try {
+    return await ctx.db.get(id);
+  } catch (error) {
+    debugGraphPrimitiveFallback(log.failureLog, {
+      error,
+      [log.idLogKey]: id
     });
+    return null;
   }
 }
-async function removeOperationalLinkEffects(ctx, args) {
-  const belief = await ctx.db.get(args.beliefId);
-  if (belief) {
-    const currentSupporting = belief.supportingInsightIds ?? [];
-    const currentContradicting = belief.contradictingInsightIds ?? [];
-    if (args.relation === "supports") {
-      await ctx.db.patch(args.beliefId, {
-        supportingInsightIds: currentSupporting.filter(
-          (id) => id !== args.insightId
-        )
-      });
-    } else {
-      await ctx.db.patch(args.beliefId, {
-        contradictingInsightIds: currentContradicting.filter(
-          (id) => id !== args.insightId
-        )
-      });
-    }
+async function buildTopicScope(ctx, topic, source, options = {}) {
+  const inherited = await resolveInheritedWorkspaceScope(ctx, topic);
+  const mapped = asMappedProjectId(topic);
+  return {
+    topicId: topic._id,
+    ...mapped || options.fallbackProjectId ? { projectId: mapped ?? options.fallbackProjectId } : {},
+    tenantId: inherited.tenantId,
+    workspaceId: inherited.workspaceId,
+    source
+  };
+}
+var optionalScopeArgs = {
+  projectId: v.optional(v.string()),
+  topicId: v.optional(v.string())
+};
+
+// src/scopeResolverCompat.ts
+var scopeArgs = optionalScopeArgs;
+function normalizeScopeValue2(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+async function resolveScope(ctx, args) {
+  const topicId = normalizeScopeValue2(args.topicId);
+  const projectId = normalizeScopeValue2(args.projectId);
+  if (!(topicId || projectId)) {
+    return null;
   }
   try {
-    const beliefSpineNode = await ctx.db.get(args.beliefId);
-    const evidenceSpineNode = await ctx.db.get(args.insightId);
-    if (beliefSpineNode?.nodeType === "belief" && evidenceSpineNode?.nodeType === "evidence") {
-      const edges = await ctx.db.query("epistemicEdges").withIndex(
-        "by_from_to",
-        (q) => q.eq("fromNodeId", evidenceSpineNode._id).eq("toNodeId", beliefSpineNode._id)
-      ).collect();
-      for (const edge of edges) {
-        if (edge.edgeType === "informs") {
-          await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
-            globalId: edge.globalId
-          });
-          await ctx.db.delete(edge._id);
-        }
+    return await resolveTopicProjectScope(ctx, {
+      topicId,
+      projectId
+    });
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[scopeResolverCompat] Failed to resolve scope",
+      {
+        error,
+        topicId,
+        projectId
       }
-    }
-  } catch (e) {
-    console.error("[EpistemicSpine] Failed to remove informs edge:", e);
+    );
+    return null;
+  }
+}
+async function resolveScopeSoft(ctx, args) {
+  const resolved = await resolveScope(ctx, args);
+  if (resolved) {
+    const topicId2 = normalizeScopeValue2(resolved.topicId);
+    return {
+      ...topicId2 ? { topicId: topicId2 } : {},
+      ...resolved.projectId ? { projectId: resolved.projectId } : {},
+      ...resolved.tenantId ? { tenantId: resolved.tenantId } : {},
+      ...resolved.workspaceId ? { workspaceId: resolved.workspaceId } : {},
+      ...resolved.source ? { source: resolved.source } : {}
+    };
   }
+  const topicId = normalizeScopeValue2(args.topicId);
+  const projectId = normalizeScopeValue2(args.projectId);
+  return {
+    ...topicId ? { topicId } : {},
+    ...projectId ? { projectId } : {}
+  };
 }
 
 // src/beliefEvidenceLinks.ts
@@ -931,6 +1023,101 @@ var matcherMetadataValidator = v.object({
   signalSnapshot: v.optional(v.any()),
   outcomeMetadata: v.optional(v.any())
 });
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function readConvexId2(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readOptionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readLinkSuggestionStatus(value) {
+  return value === "suggested" || value === "approved" || value === "dismissed" ? value : void 0;
+}
+function readRelation(value) {
+  return value === "supports" || value === "contradicts" ? value : null;
+}
+function readNodeIdArray(value) {
+  if (!Array.isArray(value)) {
+    return;
+  }
+  return value.flatMap((entry) => {
+    const id = readConvexId2(entry);
+    return id ? [id] : [];
+  });
+}
+function readEpistemicNode(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const id = readConvexId2(value._id);
+  if (!id) {
+    return null;
+  }
+  const confidence = readOptionalNumber(value.confidence) ?? readOptionalString(value.confidence);
+  return {
+    _id: id,
+    belief: readOptionalString(value.belief),
+    canonicalText: readOptionalString(value.canonicalText),
+    confidence,
+    contradictingInsightIds: readNodeIdArray(value.contradictingInsightIds),
+    globalId: readOptionalString(value.globalId),
+    nodeType: readOptionalString(value.nodeType),
+    projectId: readOptionalString(value.projectId),
+    status: readOptionalString(value.status),
+    supportingInsightIds: readNodeIdArray(value.supportingInsightIds),
+    topicId: readOptionalString(value.topicId)
+  };
+}
+function readBeliefEvidenceLink(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const id = readConvexId2(value._id);
+  const beliefId = readConvexId2(value.beliefId);
+  const insightId = readConvexId2(value.insightId);
+  const relation = readRelation(value.relation);
+  const createdBy = readOptionalString(value.createdBy);
+  if (!(id && beliefId && insightId && relation && createdBy)) {
+    return null;
+  }
+  return {
+    _id: id,
+    beliefId,
+    confidence: readOptionalNumber(value.confidence),
+    createdAt: readOptionalNumber(value.createdAt),
+    createdBy,
+    insightId,
+    rationale: readOptionalString(value.rationale),
+    relation,
+    status: readLinkSuggestionStatus(value.status)
+  };
+}
+function readProjectBeliefSummary(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const id = readConvexId2(value._id);
+  if (!id || typeof value.belief !== "string" || typeof value.confidence !== "string" || typeof value.status !== "string") {
+    return null;
+  }
+  return {
+    _id: id,
+    belief: value.belief,
+    confidence: value.confidence,
+    status: value.status
+  };
+}
+function readRowList(values, reader) {
+  return values.flatMap((value) => {
+    const row = reader(value);
+    return row ? [row] : [];
+  });
+}
 async function markProjectGraphDirty(ctx, projectId) {
   if (!projectId) {
     return;
@@ -988,16 +1175,18 @@ var create = mutation({
   handler: async (ctx, args) => {
     const resolvedBeliefId = args.beliefId;
     const resolvedInsightId = args.insightId;
-    const beliefNode = await ctx.db.get(resolvedBeliefId);
+    const beliefNode = readEpistemicNode(await ctx.db.get(resolvedBeliefId));
     if (!beliefNode) {
       throw new Error("Belief node not found");
     }
-    const insightNode = await ctx.db.get(resolvedInsightId);
+    const insightNode = readEpistemicNode(await ctx.db.get(resolvedInsightId));
     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]");
+      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");
@@ -1016,10 +1205,13 @@ var create = mutation({
         throw new Error("No permission to link evidence to this belief");
       }
     }
-    const existingLinks = await ctx.db.query("beliefEvidenceLinks").withIndex(
-      "by_beliefId",
-      (q) => q.eq("beliefId", args.beliefId)
-    ).collect();
+    const existingLinks = readRowList(
+      await ctx.db.query("beliefEvidenceLinks").withIndex(
+        "by_beliefId",
+        (q) => q.eq("beliefId", args.beliefId)
+      ).collect(),
+      readBeliefEvidenceLink
+    );
     const duplicate = existingLinks.find(
       (link) => link.insightId === args.insightId
     );
@@ -1099,14 +1291,14 @@ var remove = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const link = await ctx.db.get(args.linkId);
+    const link = readBeliefEvidenceLink(await ctx.db.get(args.linkId));
     if (!link) {
       throw new Error("Link not found");
     }
     if (link.createdBy !== args.userId) {
       throw new Error("Only the creator can remove this link");
     }
-    const belief = await ctx.db.get(link.beliefId);
+    const belief = readEpistemicNode(await ctx.db.get(link.beliefId));
     if (isOperationalLinkStatus(link.status)) {
       await removeOperationalLinkEffects(ctx, {
         beliefId: link.beliefId,
@@ -1127,11 +1319,11 @@ var update = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const link = await ctx.db.get(args.linkId);
+    const link = readBeliefEvidenceLink(await ctx.db.get(args.linkId));
     if (!link) {
       throw new Error("Link not found");
     }
-    const belief = await ctx.db.get(link.beliefId);
+    const belief = readEpistemicNode(await ctx.db.get(link.beliefId));
     if (!belief) {
       throw new Error("Belief not found");
     }
@@ -1167,11 +1359,11 @@ var reviewSuggestion = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const link = await ctx.db.get(args.linkId);
+    const link = readBeliefEvidenceLink(await ctx.db.get(args.linkId));
     if (!link) {
       throw new Error("Link not found");
     }
-    const belief = await ctx.db.get(link.beliefId);
+    const belief = readEpistemicNode(await ctx.db.get(link.beliefId));
     if (!belief) {
       throw new Error("Belief not found");
     }
@@ -1225,10 +1417,13 @@ var getByBelief = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const links = await ctx.db.query("beliefEvidenceLinks").withIndex(
-      "by_beliefId",
-      (q) => q.eq("beliefId", args.beliefId)
-    ).collect();
+    const links = readRowList(
+      await ctx.db.query("beliefEvidenceLinks").withIndex(
+        "by_beliefId",
+        (q) => q.eq("beliefId", args.beliefId)
+      ).collect(),
+      readBeliefEvidenceLink
+    );
     return links.filter(
       (link) => isOperationalLinkStatus(link.status)
     );
@@ -1240,10 +1435,13 @@ var getPendingSuggestions = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const links = await ctx.db.query("beliefEvidenceLinks").withIndex(
-      "by_beliefId",
-      (q) => q.eq("beliefId", args.beliefId)
-    ).collect();
+    const links = readRowList(
+      await ctx.db.query("beliefEvidenceLinks").withIndex(
+        "by_beliefId",
+        (q) => q.eq("beliefId", args.beliefId)
+      ).collect(),
+      readBeliefEvidenceLink
+    );
     return links.filter((link) => link.status === "suggested");
   }
 });
@@ -1253,10 +1451,13 @@ var getSupportingLinks = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const links = await ctx.db.query("beliefEvidenceLinks").withIndex(
-      "by_relation",
-      (q) => q.eq("beliefId", args.beliefId).eq("relation", "supports")
-    ).collect();
+    const links = readRowList(
+      await ctx.db.query("beliefEvidenceLinks").withIndex(
+        "by_relation",
+        (q) => q.eq("beliefId", args.beliefId).eq("relation", "supports")
+      ).collect(),
+      readBeliefEvidenceLink
+    );
     return links.filter(
       (link) => isOperationalLinkStatus(link.status)
     );
@@ -1268,10 +1469,13 @@ var getContradictingLinks = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const links = await ctx.db.query("beliefEvidenceLinks").withIndex(
-      "by_relation",
-      (q) => q.eq("beliefId", args.beliefId).eq("relation", "contradicts")
-    ).collect();
+    const links = readRowList(
+      await ctx.db.query("beliefEvidenceLinks").withIndex(
+        "by_relation",
+        (q) => q.eq("beliefId", args.beliefId).eq("relation", "contradicts")
+      ).collect(),
+      readBeliefEvidenceLink
+    );
     return links.filter(
       (link) => isOperationalLinkStatus(link.status)
     );
@@ -1283,10 +1487,13 @@ var getByInsight = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const links = await ctx.db.query("beliefEvidenceLinks").withIndex(
-      "by_insightId",
-      (q) => q.eq("insightId", args.insightId)
-    ).collect();
+    const links = readRowList(
+      await ctx.db.query("beliefEvidenceLinks").withIndex(
+        "by_insightId",
+        (q) => q.eq("insightId", args.insightId)
+      ).collect(),
+      readBeliefEvidenceLink
+    );
     return links.filter(
       (link) => isOperationalLinkStatus(link.status)
     );
@@ -1298,10 +1505,13 @@ var getCounts = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const links = await ctx.db.query("beliefEvidenceLinks").withIndex(
-      "by_beliefId",
-      (q) => q.eq("beliefId", args.beliefId)
-    ).collect();
+    const links = readRowList(
+      await ctx.db.query("beliefEvidenceLinks").withIndex(
+        "by_beliefId",
+        (q) => q.eq("beliefId", args.beliefId)
+      ).collect(),
+      readBeliefEvidenceLink
+    );
     const activeLinks = links.filter(
       (link) => isOperationalLinkStatus(link.status)
     );
@@ -1326,7 +1536,7 @@ var getEvidenceWithDetails = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const belief = await ctx.db.get(args.beliefId);
+    const belief = readEpistemicNode(await ctx.db.get(args.beliefId));
     if (!belief) {
       return null;
     }
@@ -1340,17 +1550,20 @@ var getEvidenceWithDetails = query({
         return null;
       }
     }
-    const links = await ctx.db.query("beliefEvidenceLinks").withIndex(
-      "by_beliefId",
-      (q) => q.eq("beliefId", args.beliefId)
-    ).collect();
+    const links = readRowList(
+      await ctx.db.query("beliefEvidenceLinks").withIndex(
+        "by_beliefId",
+        (q) => q.eq("beliefId", args.beliefId)
+      ).collect(),
+      readBeliefEvidenceLink
+    );
     const linksWithDetails = await Promise.all(
       links.filter(
         (link) => isOperationalLinkStatus(
           link.status
         )
       ).map(async (link) => {
-        const insight = await ctx.db.get(link.insightId);
+        const insight = readEpistemicNode(await ctx.db.get(link.insightId));
         return {
           ...link,
           insight
@@ -1392,20 +1605,23 @@ var getByProject = query({
       return { links: [], beliefDetails: {} };
     }
     const pageSize = Math.max(1, Math.min(Math.floor(args.limit ?? 300), 1e3));
-    const beliefs = await ctx.runQuery(
-      internal.epistemicBeliefs.internalGetByProject,
-      {
+    const beliefs = readRowList(
+      await ctx.runQuery(internal.epistemicBeliefs.internalGetByProject, {
         projectId,
         limit: pageSize
-      }
+      }),
+      readProjectBeliefSummary
     );
     const beliefIds = beliefs.map((b) => b._id);
     const allLinks = await Promise.all(
       beliefIds.map(async (beliefId) => {
-        const links = await ctx.db.query("beliefEvidenceLinks").withIndex(
-          "by_beliefId",
-          (q) => q.eq("beliefId", beliefId)
-        ).take(200);
+        const links = readRowList(
+          await ctx.db.query("beliefEvidenceLinks").withIndex(
+            "by_beliefId",
+            (q) => q.eq("beliefId", beliefId)
+          ).take(200),
+          readBeliefEvidenceLink
+        );
         return links;
       })
     );
@@ -1431,13 +1647,16 @@ var getLinkedBeliefsForInsight = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const links = await ctx.db.query("beliefEvidenceLinks").withIndex(
-      "by_insightId",
-      (q) => q.eq("insightId", args.insightId)
-    ).collect();
+    const links = readRowList(
+      await ctx.db.query("beliefEvidenceLinks").withIndex(
+        "by_insightId",
+        (q) => q.eq("insightId", args.insightId)
+      ).collect(),
+      readBeliefEvidenceLink
+    );
     const linkedBeliefs = await Promise.all(
       links.map(async (link) => {
-        const belief = await ctx.db.get(link.beliefId);
+        const belief = readEpistemicNode(await ctx.db.get(link.beliefId));
         return {
           linkId: link._id,
           beliefId: link.beliefId,