@lucern/graph-primitives 1.0.29 → 1.0.31

package/dist/contradictions.js

@@ -1,12 +1,16 @@
-import { v } from 'convex/values';
-import { componentsGeneric, anyApi, queryGeneric, mutationGeneric } from 'convex/server';
 import { checkProjectAccess, requireScopeWriteAccess } from '@lucern/access-control/access';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
+import { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, queryGeneric, mutationGeneric } from 'convex/server';
 
 // src/contradictions.ts
-var api = anyApi;
+var unsafeApi = unsafeConvexAnyApi(
+  "graph-primitives top-level module bundle lacks a committed Convex _generated/api surface"
+);
+var api = unsafeApi;
 componentsGeneric();
-var internal = anyApi;
+var internal = unsafeApi;
 var mutation = mutationGeneric;
 var query = queryGeneric;
 
@@ -21,8 +25,6 @@ function debugGraphPrimitiveFallback(message, context) {
   }
   console.debug(message, context ?? {});
 }
-
-// src/topicScope.ts
 var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
 async function resolveTopicNodeScopeOrNull(ctx, ref) {
   if (!ctx?.db || typeof ctx.db.query !== "function") {
@@ -57,13 +59,15 @@ function asMappedProjectId(topic) {
   if (!topic) {
     return;
   }
-  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD]);
+  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;
+  return typeof candidate === "string" ? normalizeScopeValue(candidate) : void 0;
 }
 function normalizeScopeValue(value) {
   if (typeof value !== "string") {
@@ -88,8 +92,9 @@ function pickPrimaryTopic(candidates) {
   })[0];
 }
 async function findTopicsByScopeAlias(ctx, scopeId) {
+  const query2 = ctx.db.query("topics");
   try {
-    return await ctx.db.query("topics").withIndex(
+    return await query2.withIndex(
       "by_graph_scope_project",
       (q) => q.eq(LEGACY_SCOPE_FIELD, scopeId)
     ).collect();
@@ -101,7 +106,7 @@ async function findTopicsByScopeAlias(ctx, scopeId) {
         scopeId
       }
     );
-    const topics = await ctx.db.query("topics").collect();
+    const topics = await query2.collect();
     return topics.filter((topic) => {
       const normalizedGlobalId = normalizeScopeValue(topic.globalId);
       const mappedProjectId = asMappedProjectId(topic);
@@ -157,137 +162,115 @@ async function resolveInheritedWorkspaceScope(ctx, topic) {
   let current = topic;
   for (let i = 0; i < MAX_DEPTH && current?.parentTopicId; i++) {
     current = await ctx.db.get(current.parentTopicId);
-    if (!current) break;
+    if (!current) {
+      break;
+    }
     if (!tenantId) {
       tenantId = normalizeScopeValue(current.tenantId);
     }
     if (!workspaceId) {
       workspaceId = normalizeScopeValue(current.workspaceId);
     }
-    if (tenantId && workspaceId) break;
+    if (tenantId && workspaceId) {
+      break;
+    }
   }
   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
-        }
-      );
-    }
-    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"
-      };
-    }
-    return {
-      topicId: topic._id,
-      tenantId: inherited.tenantId,
-      workspaceId: inherited.workspaceId,
-      source: "topic"
-    };
+    return await resolveScopeFromTopicId(ctx, args.topicId);
   }
   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"
-      };
-    }
-    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.`
-    );
+    return await resolveScopeFromLegacyProjectId(ctx, args.projectId);
   }
   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 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
+    });
+  }
+  const primary = pickPrimaryTopic(
+    await findTopicsByScopeAlias(ctx, legacyProjectId)
+  );
+  if (primary) {
+    return await buildTopicScope(ctx, primary, "project_mapped_topic", {
+      fallbackProjectId: legacyProjectId
+    });
+  }
+  const nodeScope = await resolveTopicNodeScopeOrNull(ctx, legacyProjectId);
+  if (nodeScope) {
+    return {
+      ...nodeScope,
+      projectId: nodeScope.projectId ?? legacyProjectId
+    };
+  }
+  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 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())
@@ -305,7 +288,7 @@ function normalizeScopeValue2(value) {
 async function resolveScope(ctx, args) {
   const topicId = normalizeScopeValue2(args.topicId);
   const projectId = normalizeScopeValue2(args.projectId);
-  if (!topicId && !projectId) {
+  if (!(topicId || projectId)) {
     return null;
   }
   try {
@@ -344,10 +327,162 @@ async function resolveScopeSoft(ctx, args) {
     ...projectId ? { projectId } : {}
   };
 }
+
+// src/contradictions.ts
 v.id("epistemicNodes");
 v.id("epistemicNodes");
 var DEFAULT_CONTRADICTION_SOURCE = "evidence_links";
 var TUPLE_SPACE_CONTRADICTION_SOURCE = "tuple_space";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readConvexId(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 readIdArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    const id = readConvexId(entry);
+    return id ? [id] : [];
+  });
+}
+function readContradictionSource(value) {
+  if (value === DEFAULT_CONTRADICTION_SOURCE) {
+    return DEFAULT_CONTRADICTION_SOURCE;
+  }
+  if (value === TUPLE_SPACE_CONTRADICTION_SOURCE) {
+    return TUPLE_SPACE_CONTRADICTION_SOURCE;
+  }
+  return null;
+}
+function readContradictionStatus(value) {
+  return value === "unresolved" || value === "investigating" || value === "resolved_support" || value === "resolved_contra" || value === "belief_forked" ? value : null;
+}
+function readContradictionSeverity(value) {
+  return value === "critical" || value === "significant" || value === "minor" ? value : null;
+}
+function readAiAnalysis(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  if (typeof value.summary !== "string" || typeof value.likelyExplanation !== "string" || typeof value.suggestedResolution !== "string" || typeof value.confidenceInAnalysis !== "number" || typeof value.analyzedAt !== "number") {
+    return null;
+  }
+  return {
+    analyzedAt: value.analyzedAt,
+    confidenceInAnalysis: value.confidenceInAnalysis,
+    likelyExplanation: value.likelyExplanation,
+    suggestedResolution: value.suggestedResolution,
+    summary: value.summary
+  };
+}
+function readBeliefRecord(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const id = readConvexId(value._id);
+  const canonicalText = readOptionalString(value.canonicalText) ?? readOptionalString(value.belief);
+  const status = readOptionalString(value.status);
+  if (!(id && canonicalText && status)) {
+    return null;
+  }
+  return {
+    _id: id,
+    canonicalText,
+    criticality: readOptionalString(value.criticality) ?? null,
+    status
+  };
+}
+function readEvidenceLink(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const insightId = readConvexId(value.insightId);
+  if (!insightId || value.relation !== "supports" && value.relation !== "contradicts") {
+    return null;
+  }
+  return {
+    insightId,
+    relation: value.relation
+  };
+}
+function readContradictionRow(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const id = readConvexId(value._id);
+  const beliefId = readConvexId(value.beliefId);
+  const severity = readContradictionSeverity(value.severity);
+  const status = readContradictionStatus(value.status);
+  if (!(id && beliefId && severity && status)) {
+    return null;
+  }
+  return {
+    _id: id,
+    aiAnalysis: readAiAnalysis(value.aiAnalysis),
+    beliefBId: readConvexId(value.beliefBId),
+    beliefId,
+    contradictingInsightIds: readIdArray(
+      value.contradictingInsightIds
+    ),
+    createdBy: readOptionalString(value.createdBy),
+    description: readOptionalString(value.description) ?? null,
+    detectedAt: readOptionalNumber(value.detectedAt),
+    detectionMethod: readOptionalString(value.detectionMethod) ?? null,
+    projectId: readOptionalString(value.projectId) ?? null,
+    resolution: value.resolution,
+    resolutionSprintId: readOptionalString(value.resolutionSprintId) ?? null,
+    resolvedAt: readOptionalNumber(value.resolvedAt) ?? null,
+    severity,
+    source: readContradictionSource(value.source),
+    status,
+    supportingInsightIds: readIdArray(
+      value.supportingInsightIds
+    ),
+    topicId: readOptionalString(value.topicId) ?? readOptionalString(value.projectId) ?? ""
+  };
+}
+function readRowList(values, reader) {
+  return values.flatMap((value) => {
+    const row = reader(value);
+    return row ? [row] : [];
+  });
+}
+function getContradictionSeverity(criticality) {
+  if (criticality === "blocking") {
+    return "critical";
+  }
+  if (criticality === "supporting") {
+    return "minor";
+  }
+  return "significant";
+}
+function extractContradictionEvidence(evidenceLinks) {
+  const supportingInsightIds = [];
+  const contradictingInsightIds = [];
+  for (const link of evidenceLinks) {
+    if (link.relation === "supports") {
+      supportingInsightIds.push(link.insightId);
+      continue;
+    }
+    if (link.relation === "contradicts") {
+      contradictingInsightIds.push(link.insightId);
+    }
+  }
+  return { supportingInsightIds, contradictingInsightIds };
+}
+function getNewEvidenceIds(existingIds, latestIds) {
+  const existing = new Set(existingIds);
+  return latestIds.filter((id) => !existing.has(id));
+}
 function contradictionSourceOf(contradiction) {
   return contradiction?.source === TUPLE_SPACE_CONTRADICTION_SOURCE ? TUPLE_SPACE_CONTRADICTION_SOURCE : DEFAULT_CONTRADICTION_SOURCE;
 }
@@ -363,18 +498,24 @@ var detectContradictions = query({
     if (!projectId) {
       return [];
     }
-    const beliefs = await ctx.runQuery(
-      internal.epistemicBeliefs.internalGetByProject,
-      {
-        projectId
-      }
+    const beliefs = readRowList(
+      await ctx.runQuery(
+        internal.epistemicBeliefs.internalGetByProject,
+        {
+          projectId
+        }
+      ),
+      readBeliefRecord
     );
     const contradictionCandidates = [];
     for (const belief of beliefs) {
-      const evidenceLinks = await ctx.db.query("beliefEvidenceLinks").withIndex(
-        "by_beliefId",
-        (q) => q.eq("beliefId", belief._id)
-      ).collect();
+      const evidenceLinks = readRowList(
+        await ctx.db.query("beliefEvidenceLinks").withIndex(
+          "by_beliefId",
+          (q) => q.eq("beliefId", belief._id)
+        ).collect(),
+        readEvidenceLink
+      );
       const supportingLinks = evidenceLinks.filter(
         (l) => l.relation === "supports"
       );
@@ -388,10 +529,13 @@ var detectContradictions = query({
         const contradictingInsights = await Promise.all(
           contradictingLinks.map((l) => ctx.db.get(l.insightId))
         );
-        const existingContradictions = await ctx.db.query("contradictions").withIndex(
-          "by_beliefId",
-          (q) => q.eq("beliefId", belief._id)
-        ).collect();
+        const existingContradictions = readRowList(
+          await ctx.db.query("contradictions").withIndex(
+            "by_beliefId",
+            (q) => q.eq("beliefId", belief._id)
+          ).collect(),
+          readContradictionRow
+        );
         const existingContradiction = existingContradictions.find(
           (candidate) => contradictionSourceOf(candidate) === DEFAULT_CONTRADICTION_SOURCE
         );
@@ -401,11 +545,10 @@ var detectContradictions = query({
         contradictionCandidates.push({
           beliefId: belief._id,
           belief,
-          supportingInsights: supportingInsights.filter(
-            Boolean
-          ),
-          contradictingInsights: contradictingInsights.filter(
-            Boolean
+          supportingInsights: readRowList(supportingInsights, readBeliefRecord),
+          contradictingInsights: readRowList(
+            contradictingInsights,
+            readBeliefRecord
           ),
           existingContradiction: existingContradiction ?? void 0
         });
@@ -445,15 +588,21 @@ var getByProject = query({
     let contradictions;
     if (args.status) {
       const status = args.status;
-      contradictions = await ctx.db.query("contradictions").withIndex(
-        "by_topic_status",
-        (q) => q.eq("topicId", String(scope.topicId ?? projectId)).eq("status", status)
-      ).order("desc").take(scanLimit);
+      contradictions = readRowList(
+        await ctx.db.query("contradictions").withIndex(
+          "by_topic_status",
+          (q) => q.eq("topicId", String(scope.topicId ?? projectId)).eq("status", status)
+        ).order("desc").take(scanLimit),
+        readContradictionRow
+      );
     } else {
-      contradictions = await ctx.db.query("contradictions").withIndex(
-        "by_topicId",
-        (q) => q.eq("topicId", String(scope.topicId ?? projectId))
-      ).order("desc").take(scanLimit);
+      contradictions = readRowList(
+        await ctx.db.query("contradictions").withIndex(
+          "by_topicId",
+          (q) => q.eq("topicId", String(scope.topicId ?? projectId))
+        ).order("desc").take(scanLimit),
+        readContradictionRow
+      );
     }
     const enriched = await Promise.all(
       contradictions.slice(0, pageSize).map(async (c) => {
@@ -491,10 +640,13 @@ var getUnresolvedCount = query({
         minor: 0
       };
     }
-    const contradictions = await ctx.db.query("contradictions").withIndex(
-      "by_topic_status",
-      (q) => q.eq("topicId", String(scope.topicId ?? projectId)).eq("status", "unresolved")
-    ).collect();
+    const contradictions = readRowList(
+      await ctx.db.query("contradictions").withIndex(
+        "by_topic_status",
+        (q) => q.eq("topicId", String(scope.topicId ?? projectId)).eq("status", "unresolved")
+      ).collect(),
+      readContradictionRow
+    );
     const critical = contradictions.filter(
       (c) => c.severity === "critical"
     ).length;
@@ -514,7 +666,9 @@ var getById = query({
   args: { contradictionId: v.id("contradictions") },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const contradiction = await ctx.db.get(args.contradictionId);
+    const contradiction = readContradictionRow(
+      await ctx.db.get(args.contradictionId)
+    );
     if (!contradiction) {
       return null;
     }
@@ -547,10 +701,7 @@ var create = mutation({
       v.literal("minor")
     ),
     source: v.optional(
-      v.union(
-        v.literal("evidence_links"),
-        v.literal("tuple_space")
-      )
+      v.union(v.literal("evidence_links"), v.literal("tuple_space"))
     ),
     description: v.optional(v.string()),
     detectionMethod: v.optional(
@@ -584,7 +735,13 @@ var create = mutation({
     }
     const now = Date.now();
     const source = args.source ?? DEFAULT_CONTRADICTION_SOURCE;
-    const existingRows = await ctx.db.query("contradictions").withIndex("by_beliefId", (q) => q.eq("beliefId", args.beliefId)).collect();
+    const existingRows = readRowList(
+      await ctx.db.query("contradictions").withIndex(
+        "by_beliefId",
+        (q) => q.eq("beliefId", args.beliefId)
+      ).collect(),
+      readContradictionRow
+    );
     const existing = existingRows.find(
       (row) => contradictionSourceOf(row) === source && (args.beliefBId ? String(row.beliefBId ?? "") === String(args.beliefBId) : true)
     );
@@ -646,7 +803,9 @@ var updateStatus = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const existing = await ctx.db.get(args.contradictionId);
+    const existing = readContradictionRow(
+      await ctx.db.get(args.contradictionId)
+    );
     if (!existing) {
       throw new Error("Contradiction not found");
     }
@@ -697,7 +856,9 @@ var resolve = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const existing = await ctx.db.get(args.contradictionId);
+    const existing = readContradictionRow(
+      await ctx.db.get(args.contradictionId)
+    );
     if (!existing) {
       throw new Error("Contradiction not found");
     }
@@ -756,7 +917,9 @@ var updateSeverity = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const existing = await ctx.db.get(args.contradictionId);
+    const existing = readContradictionRow(
+      await ctx.db.get(args.contradictionId)
+    );
     if (!existing) {
       throw new Error("Contradiction not found");
     }
@@ -814,75 +977,82 @@ var scanAndCreateContradictions = mutation({
       return { created: 0, updated: 0 };
     }
     const now = Date.now();
-    const beliefs = await ctx.runQuery(
-      internal.epistemicBeliefs.internalGetByProject,
-      {
-        projectId
-      }
+    const beliefs = readRowList(
+      await ctx.runQuery(
+        internal.epistemicBeliefs.internalGetByProject,
+        {
+          projectId
+        }
+      ),
+      readBeliefRecord
     );
     let created = 0;
     let updated = 0;
     for (const belief of beliefs) {
-      const evidenceLinks = await ctx.db.query("beliefEvidenceLinks").withIndex(
-        "by_beliefId",
-        (q) => q.eq("beliefId", belief._id)
-      ).collect();
-      const supportingIds = evidenceLinks.filter((l) => l.relation === "supports").map((l) => l.insightId);
-      const contradictingIds = evidenceLinks.filter((l) => l.relation === "contradicts").map((l) => l.insightId);
-      if (supportingIds.length > 0 && contradictingIds.length > 0) {
-        const existingRows = await ctx.db.query("contradictions").withIndex(
+      const evidenceLinks = readRowList(
+        await ctx.db.query("beliefEvidenceLinks").withIndex(
           "by_beliefId",
           (q) => q.eq("beliefId", belief._id)
-        ).collect();
-        const existing = existingRows.find(
-          (candidate) => contradictionSourceOf(candidate) === DEFAULT_CONTRADICTION_SOURCE
-        );
-        let severity = "significant";
-        if (belief.criticality === "blocking") {
-          severity = "critical";
-        } else if (belief.criticality === "supporting") {
-          severity = "minor";
-        }
-        if (existing) {
-          const newSupporting = supportingIds.filter(
-            (id) => !existing.supportingInsightIds.includes(id)
-          );
-          const newContradicting = contradictingIds.filter(
-            (id) => !existing.contradictingInsightIds.includes(id)
-          );
-          if (newSupporting.length > 0 || newContradicting.length > 0) {
-            await ctx.db.patch(existing._id, {
-              supportingInsightIds: [
-                ...existing.supportingInsightIds,
-                ...newSupporting
-              ],
-              contradictingInsightIds: [
-                ...existing.contradictingInsightIds,
-                ...newContradicting
-              ],
-              severity
-            });
-            updated++;
-          }
-        } else {
-          await ctx.db.insert("contradictions", {
-            projectId,
-            topicId: String(scope.topicId ?? projectId),
-            beliefId: belief._id,
-            supportingInsightIds: supportingIds,
-            contradictingInsightIds: contradictingIds,
-            source: DEFAULT_CONTRADICTION_SOURCE,
-            resolutionStatus: "unresolved",
-            // Lucern: required field
-            status: "unresolved",
-            // Legacy: kept for backward compat
-            severity,
-            detectedAt: now,
-            createdBy: args.createdBy
-          });
-          created++;
-        }
+        ).collect(),
+        readEvidenceLink
+      );
+      const { supportingInsightIds, contradictingInsightIds } = extractContradictionEvidence(evidenceLinks);
+      if (supportingInsightIds.length === 0 || contradictingInsightIds.length === 0) {
+        continue;
       }
+      const existingRows = readRowList(
+        await ctx.db.query("contradictions").withIndex(
+          "by_beliefId",
+          (q) => q.eq("beliefId", belief._id)
+        ).collect(),
+        readContradictionRow
+      );
+      const existing = existingRows.find(
+        (candidate) => contradictionSourceOf(candidate) === DEFAULT_CONTRADICTION_SOURCE
+      );
+      const severity = getContradictionSeverity(belief.criticality);
+      if (!existing) {
+        await ctx.db.insert("contradictions", {
+          projectId,
+          topicId: String(scope.topicId ?? projectId),
+          beliefId: belief._id,
+          supportingInsightIds,
+          contradictingInsightIds,
+          source: DEFAULT_CONTRADICTION_SOURCE,
+          resolutionStatus: "unresolved",
+          // Lucern: required field
+          status: "unresolved",
+          // Legacy: kept for backward compat
+          severity,
+          detectedAt: now,
+          createdBy: args.createdBy
+        });
+        created++;
+        continue;
+      }
+      const newSupporting = getNewEvidenceIds(
+        existing.supportingInsightIds,
+        supportingInsightIds
+      );
+      const newContradicting = getNewEvidenceIds(
+        existing.contradictingInsightIds,
+        contradictingInsightIds
+      );
+      if (newSupporting.length === 0 && newContradicting.length === 0) {
+        continue;
+      }
+      await ctx.db.patch(existing._id, {
+        supportingInsightIds: [
+          ...existing.supportingInsightIds,
+          ...newSupporting
+        ],
+        contradictingInsightIds: [
+          ...existing.contradictingInsightIds,
+          ...newContradicting
+        ],
+        severity
+      });
+      updated++;
     }
     return { created, updated };
   }