@lucern/graph-primitives 1.0.29 → 1.0.31

package/dist/epistemicQuestions.conviction.js

@@ -1,12 +1,16 @@
-import { v } from 'convex/values';
 import { checkScopeAccess } from '@lucern/access-control/access';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { componentsGeneric, anyApi, mutationGeneric, queryGeneric } from 'convex/server';
+import { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, mutationGeneric, queryGeneric } from 'convex/server';
 
 // src/epistemicQuestions.conviction.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;
 
@@ -59,6 +63,10 @@ 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;
@@ -139,9 +147,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;
     }
@@ -161,8 +172,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,
@@ -231,90 +252,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;
   }
-  patch.updatedAt = Date.now();
-  patch.metadata = nextMetadata;
-  topicUpdateArgs.metadata = nextMetadata;
+  plan.nextMetadata = omitMetadataKey(plan.nextMetadata, "projectType");
+}
+function applyTopicMetadataPatch(plan, key, rawValue) {
+  if (rawValue === void 0) {
+    plan.nextMetadata = omitMetadataKey(plan.nextMetadata, key);
+    return;
+  }
+  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
@@ -342,7 +386,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(
@@ -409,13 +453,15 @@ function asMappedProjectId(topic) {
   if (!topic) {
     return;
   }
-  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD2]);
+  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 candidate ? candidate : void 0;
+  return typeof candidate === "string" ? normalizeScopeValue(candidate) : void 0;
 }
 function normalizeScopeValue(value) {
   if (typeof value !== "string") {
@@ -440,8 +486,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_FIELD2, scopeId)
     ).collect();
@@ -453,7 +500,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);
@@ -509,137 +556,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
+  };
+}
 ({
   projectId: v.optional(v.string()),
   topicId: v.optional(v.string())
@@ -649,9 +674,14 @@ async function resolveTopicProjectScope(ctx, args) {
 function generateContentHash(text) {
   const content = `question:${text.trim().toLowerCase().replace(/\s+/g, " ")}`;
   let hash = 5381;
+  const maxSigned32Bit = 2147483647;
+  const uint32Size = 4294967296;
   for (let i = 0; i < content.length; i++) {
-    hash = (hash << 5) + hash + content.charCodeAt(i);
-    hash &= hash;
+    hash = Math.imul(hash, 33) + content.charCodeAt(i);
+    hash %= uint32Size;
+    if (hash > maxSigned32Bit) {
+      hash -= uint32Size;
+    }
   }
   return Math.abs(hash).toString(16).padStart(8, "0");
 }
@@ -659,9 +689,10 @@ function buildTestsEdgeGlobalId(fromGlobalId, toGlobalId) {
   return `edge-${fromGlobalId}-tests-${toGlobalId}`;
 }
 async function markProjectGraphDirty(ctx, projectId, topicId) {
+  const markCacheStaleByTopic = internal.graphAnalysisCache.markCacheStaleByTopic;
   const normalizedProjectId = typeof projectId === "string" && projectId.trim().length > 0 ? projectId : void 0;
   const normalizedTopicId = typeof topicId === "string" && topicId.trim().length > 0 ? topicId : void 0;
-  if (!normalizedProjectId && !normalizedTopicId) {
+  if (!(normalizedProjectId || normalizedTopicId)) {
     return;
   }
   if (normalizedProjectId) {
@@ -674,17 +705,17 @@ async function markProjectGraphDirty(ctx, projectId, topicId) {
     );
   }
   if (normalizedTopicId) {
-    await ctx.scheduler.runAfter(
-      0,
-      internal.graphAnalysisCache.markCacheStaleByTopic,
-      {
-        topicId: normalizedTopicId
-      }
-    );
+    await ctx.scheduler.runAfter(0, markCacheStaleByTopic, {
+      topicId: normalizedTopicId
+    });
+  }
+  const resolvedProjectId = normalizedTopicId ?? normalizedProjectId;
+  if (!resolvedProjectId) {
+    return;
   }
   await resolveGraphPrimitivesAppResolvers().patchProject(
     ctx,
-    normalizedTopicId ?? normalizedProjectId,
+    resolvedProjectId,
     {
       lastActivityAt: Date.now()
     }
@@ -716,7 +747,7 @@ function logQuestionFallback(message, error, context) {
   });
 }
 async function resolveQuestionScopeOrNull(ctx, args) {
-  if (!args.projectId && !args.topicId) {
+  if (!(args.projectId || args.topicId)) {
     return null;
   }
   try {
@@ -758,6 +789,362 @@ function buildLinkedWorktreeMetadata(linkedWorktreeId) {
 }
 
 // src/epistemicQuestions.conviction.ts
+function readOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readConvexId(value) {
+  const normalized = readOptionalString(value);
+  return normalized ? normalized : null;
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readStringArray2(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
+}
+function readQuestionNodeRow(value) {
+  const record = readRecord(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId(record._id);
+  const nodeType = readOptionalString(record.nodeType);
+  if (!(id && nodeType)) {
+    return null;
+  }
+  const metadata = readRecord(record.metadata) ?? {};
+  const node = { _id: id, metadata, nodeType };
+  const canonicalText = readOptionalString(record.canonicalText);
+  if (canonicalText !== void 0) {
+    node.canonicalText = canonicalText;
+  }
+  const globalId = readOptionalString(record.globalId);
+  if (globalId !== void 0) {
+    node.globalId = globalId;
+  }
+  const projectId = readOptionalString(record.projectId);
+  if (projectId !== void 0) {
+    node.projectId = projectId;
+  }
+  const sourceType = readOptionalString(record.sourceType);
+  if (sourceType !== void 0) {
+    node.sourceType = sourceType;
+  }
+  const topicId = readOptionalString(record.topicId);
+  if (topicId !== void 0) {
+    node.topicId = topicId;
+  }
+  return node;
+}
+function requireQuestionNode(value) {
+  const node = readQuestionNodeRow(value);
+  if (node?.nodeType !== "question") {
+    throw new Error("Question not found");
+  }
+  return node;
+}
+function readBeliefNode(value) {
+  const node = readQuestionNodeRow(value);
+  return node?.nodeType === "belief" ? node : null;
+}
+function readEvidenceNode(value) {
+  const node = readQuestionNodeRow(value);
+  return node?.nodeType === "evidence" ? node : null;
+}
+function readQuestionEvidenceLinkRow(value) {
+  const record = readRecord(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId(record._id);
+  if (!id) {
+    return null;
+  }
+  const link = { _id: id };
+  const insightId = readConvexId(record.insightId) ?? readOptionalString(record.insightId);
+  if (insightId !== void 0 && insightId !== null) {
+    link.insightId = insightId;
+  }
+  return link;
+}
+function readQuestionEdgeRow(value) {
+  const record = readRecord(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId(record._id);
+  if (!id) {
+    return null;
+  }
+  const edge = { _id: id };
+  const edgeType = readOptionalString(record.edgeType);
+  if (edgeType !== void 0) {
+    edge.edgeType = edgeType;
+  }
+  const globalId = readOptionalString(record.globalId);
+  if (globalId !== void 0) {
+    edge.globalId = globalId;
+  }
+  return edge;
+}
+function resolveConvictionCompleteness(explicit, conviction) {
+  if (explicit !== void 0) {
+    return explicit;
+  }
+  if (conviction >= 0.8) {
+    return "comprehensive";
+  }
+  if (conviction >= 0.6) {
+    return "sufficient";
+  }
+  if (conviction >= 0.3) {
+    return "partial";
+  }
+  return "unanswered";
+}
+function buildFinalizedConvictionMetadata(args, meta, now, clampedConviction) {
+  return {
+    ...meta,
+    convictionStage: "scored",
+    conviction: clampedConviction,
+    convictionRationale: args.convictionRationale,
+    convictionUpdatedAt: now,
+    convictionUpdatedBy: args.userId,
+    answer: args.answer,
+    answerStatus: "final",
+    questionStatus: args.answerCompleteness === "unanswerable" ? "blocked" : "answered",
+    answeredAt: now,
+    answeredBy: args.userId,
+    answerCompleteness: args.answerCompleteness,
+    whatWeNeed: args.whatWeNeed
+  };
+}
+function resolveLinkedBeliefNodeIdFromMetadata(meta) {
+  return readOptionalString(meta.linkedBeliefNodeId) || readOptionalString(meta.linkedBeliefId) || readOptionalString(meta.beliefId);
+}
+async function scheduleEvidenceCreationFromScoredQuestion(ctx, options) {
+  if (!(options.projectId || options.topicId)) {
+    return;
+  }
+  const linkedBeliefId = resolveLinkedBeliefNodeIdFromMetadata(
+    options.questionMetadata
+  );
+  if (!linkedBeliefId) {
+    return;
+  }
+  try {
+    await ctx.scheduler.runAfter(
+      0,
+      internal.epistemicQuestions.createEvidenceFromScoredQuestion,
+      {
+        questionNodeId: options.questionNodeId,
+        questionText: options.questionText,
+        answerText: options.answerText,
+        beliefId: linkedBeliefId,
+        relatedBeliefIds: options.relatedBeliefIds,
+        conviction: options.conviction,
+        rationale: options.rationale || "",
+        projectId: options.projectId,
+        topicId: options.topicId ? String(options.topicId) : void 0,
+        userId: options.userId
+      }
+    );
+  } catch (error) {
+    logQuestionFallback(
+      "[epistemicQuestions] Failed to schedule evidence creation from scored question",
+      error,
+      {
+        questionId: options.questionNodeId,
+        beliefId: linkedBeliefId,
+        projectId: options.projectId
+      }
+    );
+    console.error(
+      "[finalizeConviction] Failed to schedule evidence creation:",
+      error
+    );
+  }
+}
+async function resolveBeliefNodeForBeliefLink(ctx, beliefId) {
+  try {
+    return readBeliefNode(await ctx.db.get(beliefId));
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[epistemicQuestions] Failed to resolve belief node directly",
+      {
+        error: formatGraphPrimitiveError(error),
+        beliefId
+      }
+    );
+    try {
+      return readBeliefNode(await ctx.db.get(beliefId));
+    } catch (legacyError) {
+      debugGraphPrimitiveFallback(
+        "[epistemicQuestions] Failed to resolve legacy belief node",
+        {
+          error: formatGraphPrimitiveError(legacyError),
+          beliefId
+        }
+      );
+      return null;
+    }
+  }
+}
+function buildBeliefLinkMetadata(questionMetadata, args) {
+  const currentBeliefs = readStringArray2(questionMetadata.relatedBeliefIds);
+  const beliefId = String(args.beliefId);
+  const relatedBeliefs = currentBeliefs.includes(beliefId) ? currentBeliefs : [...currentBeliefs, beliefId];
+  const metaUpdates = {
+    ...questionMetadata,
+    relatedBeliefIds: relatedBeliefs
+  };
+  if (args.isPrimaryBelief || args.testType) {
+    metaUpdates.linkedBeliefNodeId = args.beliefId;
+    metaUpdates.linkedBeliefId = args.beliefId;
+    metaUpdates.questionType = "belief_test";
+    if (args.testType) {
+      metaUpdates.testType = args.testType;
+    }
+    if (args.answerImpact) {
+      metaUpdates.answerImpact = args.answerImpact;
+    }
+  }
+  return metaUpdates;
+}
+async function syncBeliefTestEdge(ctx, questionNode, beliefNode, args) {
+  try {
+    const beliefGlobalId = beliefNode.globalId;
+    if (!(beliefGlobalId && questionNode.globalId)) {
+      return;
+    }
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: questionNode._id,
+      operation: "upsert"
+    });
+    await ctx.scheduler.runAfter(100, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: beliefNode._id,
+      operation: "upsert"
+    });
+    const edgeGlobalId = buildTestsEdgeGlobalId(
+      questionNode.globalId,
+      beliefGlobalId
+    );
+    await ctx.scheduler.runAfter(250, internal.neo4jEdgeAPI.createEdge, {
+      globalId: edgeGlobalId,
+      fromGlobalId: questionNode.globalId,
+      toGlobalId: beliefGlobalId,
+      edgeType: "tests",
+      context: args.testType || "tests",
+      topicId: normalizeQuestionTopicId(questionNode.topicId) ?? questionNode.projectId,
+      createdBy: args.userId,
+      fromNodeType: "question",
+      toNodeType: "belief",
+      fromLayer: "L3",
+      toLayer: "L3"
+    });
+  } catch (error) {
+    logQuestionFallback(
+      "[epistemicQuestions] Failed to create tests edge",
+      error,
+      {
+        questionId: questionNode._id,
+        beliefId: args.beliefId
+      }
+    );
+    console.error("[linkToBelief] Failed to create tests edge:", error);
+  }
+}
+async function assertQuestionScopeAccess(ctx, questionNode, userId) {
+  const questionScopeId = resolveQuestionScopeId({
+    projectId: questionNode.projectId,
+    topicId: normalizeQuestionTopicId(questionNode.topicId)
+  });
+  if (!questionScopeId) {
+    return;
+  }
+  const hasAccess = await checkScopeAccess(ctx, questionScopeId, userId);
+  if (!hasAccess) {
+    throw new Error("Access denied");
+  }
+}
+async function removeQuestionEvidenceLinks(ctx, args) {
+  try {
+    const links = await ctx.db.query("questionEvidenceLinks").withIndex("by_questionId", (q) => q.eq("questionId", args.questionId)).collect();
+    for (const rawLink of links) {
+      const link = readQuestionEvidenceLinkRow(rawLink);
+      if (link && String(link.insightId) === String(args.insightId)) {
+        await ctx.db.delete(link._id);
+      }
+    }
+  } catch (error) {
+    logQuestionFallback(
+      "[epistemicQuestions] Failed to remove questionEvidenceLink",
+      error,
+      {
+        questionId: args.questionId,
+        insightId: args.insightId
+      }
+    );
+    console.error(
+      "[unlinkInsight] Failed to remove questionEvidenceLink:",
+      error
+    );
+  }
+}
+function buildEvidenceQuestionEndpointPairs(evidenceNode, questionNode) {
+  return [String(evidenceNode._id), evidenceNode.globalId].filter(
+    (endpoint) => typeof endpoint === "string" && endpoint.length > 0
+  ).flatMap((fromNodeId) => [
+    { fromNodeId, toNodeId: String(questionNode._id) },
+    ...questionNode.globalId ? [{ fromNodeId, toNodeId: questionNode.globalId }] : []
+  ]);
+}
+async function collectEdgesForEndpointPairs(ctx, endpointPairs) {
+  const edgeGroups = await Promise.all(
+    endpointPairs.map(
+      (endpoint) => ctx.db.query("epistemicEdges").withIndex(
+        "by_from_to",
+        (q) => q.eq("fromNodeId", endpoint.fromNodeId).eq("toNodeId", endpoint.toNodeId)
+      ).collect()
+    )
+  );
+  return edgeGroups.flat();
+}
+async function removeDerivedEvidenceEdges(ctx, args) {
+  try {
+    const evidenceNode = readEvidenceNode(await ctx.db.get(args.insightId));
+    if (!evidenceNode) {
+      return;
+    }
+    const endpointPairs = buildEvidenceQuestionEndpointPairs(
+      evidenceNode,
+      args.questionNode
+    );
+    const rawEdges = await collectEdgesForEndpointPairs(ctx, endpointPairs);
+    for (const rawEdge of rawEdges) {
+      const edge = readQuestionEdgeRow(rawEdge);
+      if (!(edge && edge.edgeType === "derived_from")) {
+        continue;
+      }
+      if (edge.globalId) {
+        await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
+          globalId: edge.globalId
+        });
+      }
+      await ctx.db.delete(edge._id);
+    }
+  } catch (error) {
+    logQuestionFallback(
+      "[epistemicQuestions] Failed to remove derived edge",
+      error,
+      {
+        questionId: args.questionId,
+        insightId: args.insightId
+      }
+    );
+    console.error("[unlinkInsight] Failed to remove edge:", error);
+  }
+}
 var advanceToConviction = mutation({
   args: {
     questionId: v.id("epistemicNodes"),
@@ -767,11 +1154,8 @@ var advanceToConviction = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const node = await ctx.db.get(args.questionId);
-    if (!node || node.nodeType !== "question") {
-      throw new Error("Question not found");
-    }
-    const meta = node.metadata || {};
+    const node = requireQuestionNode(await ctx.db.get(args.questionId));
+    const meta = node.metadata;
     if (meta.convictionStage === "in_conviction" || meta.convictionStage === "scored") {
       throw new Error("Question is already in conviction stage");
     }
@@ -837,12 +1221,9 @@ var updateConviction = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const node = await ctx.db.get(args.questionId);
-    if (!node || node.nodeType !== "question") {
-      throw new Error("Question not found");
-    }
+    const node = requireQuestionNode(await ctx.db.get(args.questionId));
     const now = Date.now();
-    const meta = node.metadata || {};
+    const meta = node.metadata;
     const updates = { ...meta };
     if (args.conviction !== void 0) {
       updates.conviction = Math.max(0, Math.min(1, args.conviction));
@@ -887,35 +1268,28 @@ var finalizeConviction = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const node = await ctx.db.get(args.questionId);
-    if (!node || node.nodeType !== "question") {
-      throw new Error("Question not found");
-    }
+    const node = requireQuestionNode(await ctx.db.get(args.questionId));
     const now = Date.now();
     const clampedConviction = Math.max(0, Math.min(1, args.conviction));
-    const isUnanswerable = args.answerCompleteness === "unanswerable";
-    const meta = node.metadata || {};
-    let completeness = args.answerCompleteness;
-    if (!completeness) {
-      completeness = clampedConviction >= 0.8 ? "comprehensive" : clampedConviction >= 0.6 ? "sufficient" : clampedConviction >= 0.3 ? "partial" : "unanswered";
-    }
+    const completeness = resolveConvictionCompleteness(
+      args.answerCompleteness,
+      clampedConviction
+    );
+    const meta = node.metadata;
     await ctx.db.patch(args.questionId, {
       updatedAt: now,
-      metadata: {
-        ...meta,
-        convictionStage: "scored",
-        conviction: clampedConviction,
-        convictionRationale: args.convictionRationale,
-        convictionUpdatedAt: now,
-        convictionUpdatedBy: args.userId,
-        answer: args.answer,
-        answerStatus: "final",
-        questionStatus: isUnanswerable ? "blocked" : "answered",
-        answeredAt: now,
-        answeredBy: args.userId,
-        answerCompleteness: completeness,
-        whatWeNeed: args.whatWeNeed
-      }
+      metadata: buildFinalizedConvictionMetadata(
+        {
+          userId: args.userId,
+          answer: args.answer,
+          convictionRationale: args.convictionRationale,
+          answerCompleteness: completeness,
+          whatWeNeed: args.whatWeNeed
+        },
+        meta,
+        now,
+        clampedConviction
+      )
     });
     try {
       await ctx.db.insert("epistemicAudit", {
@@ -946,43 +1320,18 @@ var finalizeConviction = mutation({
       );
       console.error("[EpistemicAudit] Failed to log finalizeConviction:", e);
     }
-    if (node.projectId || node.topicId) {
-      const beliefId = meta.linkedBeliefNodeId || meta.linkedBeliefId || meta.beliefId;
-      if (beliefId) {
-        try {
-          await ctx.scheduler.runAfter(
-            0,
-            internal.epistemicQuestions.createEvidenceFromScoredQuestion,
-            {
-              questionNodeId: args.questionId,
-              questionText: node.canonicalText || "",
-              answerText: args.answer,
-              beliefId,
-              relatedBeliefIds: meta.relatedBeliefIds || [],
-              conviction: clampedConviction,
-              rationale: args.convictionRationale || "",
-              projectId: node.projectId,
-              topicId: normalizeQuestionTopicId(node.topicId),
-              userId: args.userId
-            }
-          );
-        } catch (e) {
-          logQuestionFallback(
-            "[epistemicQuestions] Failed to schedule evidence creation from scored question",
-            e,
-            {
-              questionId: args.questionId,
-              beliefId,
-              projectId: node.projectId
-            }
-          );
-          console.error(
-            "[finalizeConviction] Failed to schedule evidence creation:",
-            e
-          );
-        }
-      }
-    }
+    await scheduleEvidenceCreationFromScoredQuestion(ctx, {
+      questionNodeId: args.questionId,
+      questionText: node.canonicalText ?? "",
+      answerText: args.answer,
+      questionMetadata: meta,
+      conviction: clampedConviction,
+      rationale: args.convictionRationale || "",
+      projectId: node.projectId,
+      topicId: normalizeQuestionTopicId(node.topicId),
+      userId: args.userId,
+      relatedBeliefIds: readStringArray2(meta.relatedBeliefIds)
+    });
     await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
       nodeId: args.questionId,
       operation: "upsert"
@@ -1004,7 +1353,9 @@ var getByBeliefWithAccess = query({
   handler: async (ctx, args) => {
     let beliefNode = null;
     try {
-      beliefNode = await ctx.db.get(args.beliefId);
+      beliefNode = readBeliefNode(
+        await ctx.db.get(args.beliefId)
+      );
     } catch (error) {
       debugGraphPrimitiveFallback(
         "[epistemicQuestions] Failed to resolve belief node directly",
@@ -1014,7 +1365,9 @@ var getByBeliefWithAccess = query({
         }
       );
       try {
-        beliefNode = await ctx.db.get(args.beliefId);
+        beliefNode = readBeliefNode(
+          await ctx.db.get(args.beliefId)
+        );
       } catch (legacyError) {
         debugGraphPrimitiveFallback(
           "[epistemicQuestions] Failed to resolve legacy belief node",
@@ -1034,7 +1387,7 @@ var getByBeliefWithAccess = query({
       topicId: normalizeQuestionTopicId(beliefNode.topicId)
     });
     const scopeId = scope ? resolveQuestionScopeId(scope) : void 0;
-    if (!scope || !scopeId) {
+    if (!(scope && scopeId)) {
       return [];
     }
     const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
@@ -1044,7 +1397,7 @@ var getByBeliefWithAccess = query({
     const questionNodes = await getQuestionNodesForScope(ctx, scope);
     const beliefIdStr = String(args.beliefId);
     return questionNodes.filter((q) => {
-      const meta = q.metadata || {};
+      const meta = readRecord(q.metadata) ?? {};
       if (String(meta.linkedBeliefNodeId || "") === beliefIdStr) {
         return true;
       }
@@ -1054,7 +1407,7 @@ var getByBeliefWithAccess = query({
       if (String(meta.beliefId || "") === beliefIdStr) {
         return true;
       }
-      const relatedIds = meta.relatedBeliefIds || [];
+      const relatedIds = readStringArray2(meta.relatedBeliefIds);
       if (relatedIds.some((id) => String(id) === beliefIdStr)) {
         return true;
       }
@@ -1089,12 +1442,9 @@ var updateQuestion = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const node = await ctx.db.get(args.questionId);
-    if (!node || node.nodeType !== "question") {
-      throw new Error("Question not found");
-    }
+    const node = requireQuestionNode(await ctx.db.get(args.questionId));
     const now = Date.now();
-    const meta = node.metadata || {};
+    const meta = node.metadata;
     const metaUpdates = { ...meta };
     if (args.category) {
       const category = args.category === "financial" ? "financials" : args.category;
@@ -1145,115 +1495,27 @@ var linkToBelief = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const questionNode = await ctx.db.get(args.questionId);
-    if (!questionNode || questionNode.nodeType !== "question") {
-      throw new Error("Question not found");
-    }
-    const questionScopeId = resolveQuestionScopeId({
-      projectId: questionNode.projectId,
-      topicId: normalizeQuestionTopicId(questionNode.topicId)
-    });
-    if (questionScopeId) {
-      const hasAccess = await checkScopeAccess(
-        ctx,
-        questionScopeId,
-        args.userId
-      );
-      if (!hasAccess) {
-        throw new Error("Access denied");
-      }
-    }
-    let beliefNode = null;
-    try {
-      beliefNode = await ctx.db.get(args.beliefId);
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[epistemicQuestions] Failed to resolve belief node directly",
-        {
-          error: formatGraphPrimitiveError(error),
-          beliefId: args.beliefId
-        }
-      );
-      try {
-        beliefNode = await ctx.db.get(args.beliefId);
-      } catch (legacyError) {
-        debugGraphPrimitiveFallback(
-          "[epistemicQuestions] Failed to resolve legacy belief node",
-          {
-            error: formatGraphPrimitiveError(legacyError),
-            beliefId: args.beliefId
-          }
-        );
-        throw new Error("Belief not found");
-      }
-    }
+    const questionNode = requireQuestionNode(await ctx.db.get(args.questionId));
+    await assertQuestionScopeAccess(ctx, questionNode, args.userId);
+    const beliefNode = await resolveBeliefNodeForBeliefLink(ctx, args.beliefId);
     if (!beliefNode) {
       throw new Error("Belief not found");
     }
     const now = Date.now();
-    const meta = questionNode.metadata || {};
-    const currentBeliefs = meta.relatedBeliefIds || [];
-    const beliefIdStr = String(args.beliefId);
-    const newRelated = currentBeliefs.includes(beliefIdStr) ? currentBeliefs : [...currentBeliefs, beliefIdStr];
-    const metaUpdates = {
-      ...meta,
-      relatedBeliefIds: newRelated
+    const meta = questionNode.metadata;
+    const linkArgs = {
+      beliefId: args.beliefId,
+      userId: args.userId,
+      testType: args.testType,
+      answerImpact: args.answerImpact,
+      isPrimaryBelief: args.isPrimaryBelief
     };
-    if (args.isPrimaryBelief || args.testType) {
-      metaUpdates.linkedBeliefNodeId = args.beliefId;
-      metaUpdates.linkedBeliefId = args.beliefId;
-      metaUpdates.questionType = "belief_test";
-      if (args.testType) {
-        metaUpdates.testType = args.testType;
-      }
-      if (args.answerImpact) {
-        metaUpdates.answerImpact = args.answerImpact;
-      }
-    }
+    const metaUpdates = buildBeliefLinkMetadata(meta, linkArgs);
     await ctx.db.patch(args.questionId, {
       updatedAt: now,
       metadata: metaUpdates
     });
-    try {
-      const beliefGlobalId = beliefNode.globalId;
-      if (beliefGlobalId && questionNode.globalId) {
-        await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
-          nodeId: args.questionId,
-          operation: "upsert"
-        });
-        await ctx.scheduler.runAfter(100, internal.neo4jSync.syncNodeToNeo4j, {
-          nodeId: args.beliefId,
-          operation: "upsert"
-        });
-        const edgeGlobalId = buildTestsEdgeGlobalId(
-          questionNode.globalId,
-          beliefGlobalId
-        );
-        await ctx.scheduler.runAfter(250, internal.neo4jEdgeAPI.createEdge, {
-          globalId: edgeGlobalId,
-          fromGlobalId: questionNode.globalId,
-          toGlobalId: beliefGlobalId,
-          edgeType: "tests",
-          context: args.testType || "tests",
-          topicId: questionNode.projectId ? String(questionNode.projectId) : void 0,
-          createdBy: args.userId,
-          fromNodeType: "question",
-          toNodeType: "belief",
-          fromLayer: "L3",
-          toLayer: "L3"
-        });
-      }
-    } catch (e) {
-      logQuestionFallback(
-        "[epistemicQuestions] Failed to create tests edge",
-        e,
-        {
-          questionId: args.questionId,
-          beliefId: args.beliefId
-        }
-      );
-      console.error("[linkToBelief] Failed to create tests edge:", e);
-    }
+    await syncBeliefTestEdge(ctx, questionNode, beliefNode, linkArgs);
     await markProjectGraphDirty(
       ctx,
       questionNode.projectId,
@@ -1273,31 +1535,15 @@ var linkToInsight = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const questionNode = await ctx.db.get(args.questionId);
-    if (!questionNode || questionNode.nodeType !== "question") {
-      throw new Error("Question not found");
-    }
-    const insight = await ctx.db.get(args.insightId);
+    const questionNode = requireQuestionNode(await ctx.db.get(args.questionId));
+    const insight = readQuestionNodeRow(await ctx.db.get(args.insightId));
     if (!insight) {
       throw new Error("Insight not found");
     }
-    const questionScopeId = resolveQuestionScopeId({
-      projectId: questionNode.projectId,
-      topicId: normalizeQuestionTopicId(questionNode.topicId)
-    });
-    if (questionScopeId) {
-      const hasAccess = await checkScopeAccess(
-        ctx,
-        questionScopeId,
-        args.userId
-      );
-      if (!hasAccess) {
-        throw new Error("Access denied");
-      }
-    }
+    await assertQuestionScopeAccess(ctx, questionNode, args.userId);
     const now = Date.now();
-    const meta = questionNode.metadata || {};
-    const currentInsights = meta.relatedInsightIds || [];
+    const meta = questionNode.metadata;
+    const currentInsights = readStringArray2(meta.relatedInsightIds);
     const insightIdStr = String(args.insightId);
     if (!currentInsights.includes(insightIdStr)) {
       await ctx.db.patch(args.questionId, {
@@ -1312,8 +1558,8 @@ var linkToInsight = mutation({
           "by_questionId",
           (q) => q.eq("questionId", args.questionId)
         ).collect();
-        const duplicate = existingLinks.find(
-          (link) => String(link.insightId) === String(args.insightId)
+        const duplicate = existingLinks.map(readQuestionEvidenceLinkRow).find(
+          (link) => link && String(link.insightId) === String(args.insightId)
         );
         if (!duplicate) {
           await ctx.db.insert("questionEvidenceLinks", {
@@ -1348,27 +1594,11 @@ var unlinkInsight = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const questionNode = await ctx.db.get(args.questionId);
-    if (!questionNode || questionNode.nodeType !== "question") {
-      throw new Error("Question not found");
-    }
-    const questionScopeId = resolveQuestionScopeId({
-      projectId: questionNode.projectId,
-      topicId: normalizeQuestionTopicId(questionNode.topicId)
-    });
-    if (questionScopeId) {
-      const hasAccess = await checkScopeAccess(
-        ctx,
-        questionScopeId,
-        args.userId
-      );
-      if (!hasAccess) {
-        throw new Error("Access denied");
-      }
-    }
+    const questionNode = requireQuestionNode(await ctx.db.get(args.questionId));
+    await assertQuestionScopeAccess(ctx, questionNode, args.userId);
     const now = Date.now();
-    const meta = questionNode.metadata || {};
-    const currentInsights = meta.relatedInsightIds || [];
+    const meta = questionNode.metadata;
+    const currentInsights = readStringArray2(meta.relatedInsightIds);
     const newInsights = currentInsights.filter(
       (id) => String(id) !== String(args.insightId)
     );
@@ -1379,57 +1609,8 @@ var unlinkInsight = mutation({
         relatedInsightIds: newInsights
       }
     });
-    try {
-      const links = await ctx.db.query("questionEvidenceLinks").withIndex(
-        "by_questionId",
-        (q) => q.eq("questionId", args.questionId)
-      ).collect();
-      for (const link of links) {
-        if (String(link.insightId) === String(args.insightId)) {
-          await ctx.db.delete(link._id);
-        }
-      }
-    } catch (e) {
-      logQuestionFallback(
-        "[epistemicQuestions] Failed to remove questionEvidenceLink",
-        e,
-        {
-          questionId: args.questionId,
-          insightId: args.insightId
-        }
-      );
-      console.error(
-        "[unlinkInsight] Failed to remove questionEvidenceLink:",
-        e
-      );
-    }
-    try {
-      const evidenceNode = await ctx.db.get(args.insightId);
-      if (evidenceNode && evidenceNode.nodeType === "evidence") {
-        const edges = await ctx.db.query("epistemicEdges").withIndex(
-          "by_from_to",
-          (q) => q.eq("fromNodeId", evidenceNode._id).eq("toNodeId", args.questionId)
-        ).collect();
-        for (const edge of edges) {
-          if (edge.edgeType === "derived_from") {
-            await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
-              globalId: edge.globalId
-            });
-            await ctx.db.delete(edge._id);
-          }
-        }
-      }
-    } catch (e) {
-      logQuestionFallback(
-        "[epistemicQuestions] Failed to remove derived edge",
-        e,
-        {
-          questionId: args.questionId,
-          insightId: args.insightId
-        }
-      );
-      console.error("[unlinkInsight] Failed to remove edge:", e);
-    }
+    await removeQuestionEvidenceLinks(ctx, args);
+    await removeDerivedEvidenceEdges(ctx, { ...args, questionNode });
     await markProjectGraphDirty(
       ctx,
       questionNode.projectId,