@lucern/graph-primitives 1.0.29 → 1.0.30

package/dist/epistemicQuestions.sprint.js

@@ -1,10 +1,14 @@
-import { v } from 'convex/values';
 import { checkScopeAccess } from '@lucern/access-control/access';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { componentsGeneric, queryGeneric, anyApi } from 'convex/server';
+import { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, queryGeneric } from 'convex/server';
 
 // src/epistemicQuestions.sprint.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 query = queryGeneric;
 
@@ -72,13 +76,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") {
@@ -103,8 +109,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();
@@ -116,7 +123,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);
@@ -172,152 +179,211 @@ 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())
 });
 
+// src/epistemicQuestions.helpers.ts
+function dedupeQuestionNodes(nodes) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const node of nodes) {
+    const id = String(node._id);
+    if (seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    deduped.push(node);
+  }
+  return deduped;
+}
+function normalizeQuestionTopicId(topicId) {
+  return typeof topicId === "string" && topicId.trim().length > 0 ? topicId : void 0;
+}
+function resolveQuestionScopeId(scope) {
+  return normalizeQuestionTopicId(scope.topicId) ?? scope.projectId ?? void 0;
+}
+async function resolveQuestionScopeOrNull(ctx, args) {
+  if (!(args.projectId || args.topicId)) {
+    return null;
+  }
+  try {
+    return await resolveTopicProjectScope(ctx, {
+      projectId: args.projectId ?? void 0,
+      topicId: args.topicId ?? void 0
+    });
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[epistemicQuestions] Failed to resolve question scope",
+      {
+        error: formatGraphPrimitiveError(error),
+        projectId: args.projectId,
+        topicId: args.topicId
+      }
+    );
+    return null;
+  }
+}
+async function getQuestionNodesForScope(ctx, scope, args) {
+  const fetchNodes = (query2) => query2.collect();
+  const topicNodes = await fetchNodes(
+    ctx.db.query("epistemicNodes").withIndex(
+      "by_topic_type",
+      (q) => q.eq("topicId", scope.topicId).eq("nodeType", "question")
+    )
+  );
+  return dedupeQuestionNodes(topicNodes).filter(
+    (node) => questionMatchesScope(node, scope)
+  );
+}
+async function getQuestionEdgesForScope(ctx, scope) {
+  const query2 = ctx.db.query("epistemicEdges").withIndex(
+    "by_topic",
+    (q) => q.eq("topicId", scope.topicId || scope.projectId)
+  );
+  return await query2.collect();
+}
+function questionMatchesScope(node, scope) {
+  return scope.topicId !== void 0 && node.topicId === scope.topicId || scope.projectId !== void 0 && node.projectId === scope.projectId;
+}
+function resolveLinkedWorktreeId(meta) {
+  const linkedWorktreeId = meta.linkedWorktreeId;
+  return typeof linkedWorktreeId === "string" && linkedWorktreeId.trim() ? linkedWorktreeId : null;
+}
+function questionMatchesWorkflowLink(meta, workflow) {
+  const linkedWorktreeId = resolveLinkedWorktreeId(meta);
+  return Boolean(
+    linkedWorktreeId && (linkedWorktreeId === workflow.worktreeId || linkedWorktreeId === workflow.sprintId)
+  );
+}
+
 // src/workflowBridge.ts
 function isLegacySprintDoc(doc) {
   if (!doc || typeof doc !== "object") {
     return false;
   }
-  if ("metadata" in doc && doc.metadata?.pairedSprintId) {
+  const metadata = typeof doc.metadata === "object" && doc.metadata !== null ? doc.metadata : void 0;
+  if (metadata?.pairedSprintId) {
     return false;
   }
   return "sprintScope" in doc || "targetPillar" in doc || "pillarThesis" in doc || "synthesisState" in doc || "projectId" in doc && !("worktreeScope" in doc);
 }
+function isWorktreeDoc(doc) {
+  if (!doc || typeof doc !== "object") {
+    return false;
+  }
+  return "worktreeScope" in doc || "targetBranch" in doc || "campaign" in doc || "executionBand" in doc || "proofArtifacts" in doc;
+}
 function getPairedSprintId(doc) {
   const pairedSprintId = doc?.metadata?.pairedSprintId;
   return typeof pairedSprintId === "string" && pairedSprintId.trim().length > 0 ? pairedSprintId : null;
@@ -348,7 +414,7 @@ async function findPairedWorktreeForSprint(ctx, sprint) {
   }
   const worktrees = await ctx.db.query("worktrees").withIndex("by_topicId", (q) => q.eq("topicId", topicId)).collect();
   return worktrees.find(
-    (worktree) => String(worktree?.metadata?.pairedSprintId || "") === sprintId
+    (worktree) => isWorktreeDoc(worktree) && String(worktree.metadata?.pairedSprintId || "") === sprintId
   ) ?? null;
 }
 async function resolveWorkflowBridgeDoc(ctx, workflowId) {
@@ -372,116 +438,393 @@ async function resolveWorkflowBridgeDoc(ctx, workflowId) {
     return empty;
   }
   if (isLegacySprintDoc(doc)) {
-    const worktree2 = await findPairedWorktreeForSprint(ctx, doc);
-    return {
-      ...empty,
-      sprint: doc,
-      worktree: worktree2,
-      sprintId: typeof doc._id === "string" && doc._id.length > 0 ? doc._id : workflowId,
-      worktreeId: worktree2 && typeof worktree2._id === "string" && worktree2._id.length > 0 ? worktree2._id : null,
-      topicId: getStringField(worktree2, "topicId") ?? getStringField(doc, "topicId"),
-      projectId: getStringField(doc, "projectId") ?? getStringField(worktree2, "projectId")
-    };
+    return await resolveLegacySprintBridge(ctx, empty, doc, workflowId);
   }
+  return await resolveWorktreeBridge(ctx, empty, doc, workflowId);
+}
+async function resolveLegacySprintBridge(ctx, empty, sprint, workflowId) {
+  const worktree = await findPairedWorktreeForSprint(ctx, sprint);
+  return {
+    ...empty,
+    sprint,
+    worktree,
+    sprintId: getDocumentIdOrFallback(sprint, workflowId),
+    worktreeId: getDocumentIdOrFallback(worktree, null),
+    topicId: getStringField(worktree, "topicId") ?? getStringField(sprint, "topicId"),
+    projectId: getStringField(sprint, "projectId") ?? getStringField(worktree, "projectId")
+  };
+}
+async function resolveWorktreeBridge(ctx, empty, doc, workflowId) {
   const worktree = doc;
   const pairedSprintId = getPairedSprintId(worktree);
-  let sprint = null;
-  if (pairedSprintId) {
-    try {
-      const paired = await ctx.db.get(pairedSprintId);
-      if (isLegacySprintDoc(paired)) {
-        sprint = paired;
-      }
-    } catch {
-      sprint = null;
-    }
-  }
+  const sprint = await readPairedSprint(ctx, pairedSprintId);
   return {
     ...empty,
     worktree,
     sprint,
-    worktreeId: typeof worktree._id === "string" && worktree._id.length > 0 ? worktree._id : workflowId,
-    sprintId: sprint && typeof sprint._id === "string" && sprint._id.length > 0 ? sprint._id : pairedSprintId,
+    worktreeId: getDocumentIdOrFallback(worktree, workflowId),
+    sprintId: getDocumentIdOrFallback(sprint, pairedSprintId),
     topicId: getStringField(worktree, "topicId") ?? getStringField(sprint, "topicId"),
     projectId: getStringField(sprint, "projectId") ?? getStringField(worktree, "projectId")
   };
 }
+async function readPairedSprint(ctx, pairedSprintId) {
+  if (!pairedSprintId) {
+    return null;
+  }
+  try {
+    const paired = await ctx.db.get(pairedSprintId);
+    return isLegacySprintDoc(paired) ? paired : null;
+  } catch {
+    return null;
+  }
+}
+function getDocumentIdOrFallback(doc, fallback) {
+  return typeof doc?._id === "string" && doc._id.length > 0 ? doc._id : fallback;
+}
 
-// src/epistemicQuestions.helpers.ts
-function dedupeQuestionNodes(nodes) {
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const node of nodes) {
-    const id = String(node._id);
-    if (seen.has(id)) {
-      continue;
+// src/epistemicQuestions.sprint.ts
+function collectLinkedBeliefNodeIds(questionNodeId, edges, currentMeta) {
+  const questionId = String(questionNodeId);
+  const beliefNodeIds = /* @__PURE__ */ new Set();
+  const primaryBeliefId = readOptionalString(currentMeta.linkedBeliefNodeId);
+  if (primaryBeliefId) {
+    beliefNodeIds.add(primaryBeliefId);
+  }
+  for (const edge of edges) {
+    const fromNodeId = edge.fromNodeId ?? "";
+    const toNodeId = edge.toNodeId ?? "";
+    if (fromNodeId === questionId && toNodeId) {
+      beliefNodeIds.add(toNodeId);
+    }
+    if (toNodeId === questionId && fromNodeId) {
+      beliefNodeIds.add(fromNodeId);
     }
-    seen.add(id);
-    deduped.push(node);
   }
-  return deduped;
+  beliefNodeIds.delete("");
+  return Array.from(beliefNodeIds);
 }
-function normalizeQuestionTopicId(topicId) {
-  return typeof topicId === "string" && topicId.trim().length > 0 ? topicId : void 0;
+async function collectClusterLinkedBeliefs(ctx, linkedBeliefNodeIds, clusterBeliefIds, hypothesisIds, rawBeliefIds) {
+  const linkedBeliefs = await Promise.all(
+    linkedBeliefNodeIds.map(async (beliefNodeId) => {
+      const nodeId = readConvexId(beliefNodeId);
+      const node = nodeId ? readQuestionNodeRow(await ctx.db.get(nodeId)) : null;
+      if (node?.nodeType !== "belief") {
+        return null;
+      }
+      return {
+        beliefId: node._id,
+        beliefText: node.canonicalText ?? "",
+        isHypothesis: hypothesisIds.has(beliefNodeId),
+        isConditional: !(hypothesisIds.has(beliefNodeId) || rawBeliefIds.has(beliefNodeId)) && clusterBeliefIds.has(beliefNodeId),
+        isRaw: rawBeliefIds.has(beliefNodeId),
+        isPrimaryTarget: hypothesisIds.has(beliefNodeId)
+      };
+    })
+  );
+  return linkedBeliefs.filter(
+    (belief) => belief !== null
+  );
 }
-function resolveQuestionScopeId(scope) {
-  return normalizeQuestionTopicId(scope.topicId) ?? scope.projectId ?? void 0;
+async function enrichSprintClusterQuestion(ctx, question, edges, hypothesisIds, rawBeliefIds, clusterBeliefIds) {
+  const meta = question.metadata;
+  const linkedBeliefNodeIds = collectLinkedBeliefNodeIds(
+    question._id,
+    edges,
+    meta
+  );
+  const linkedBeliefs = await collectClusterLinkedBeliefs(
+    ctx,
+    linkedBeliefNodeIds,
+    clusterBeliefIds,
+    hypothesisIds,
+    rawBeliefIds
+  );
+  const questionText = question.canonicalText;
+  const payload = {
+    _id: question._id,
+    _creationTime: question._creationTime,
+    questionType: question.questionType ?? readOptionalString(meta.questionType) ?? "general",
+    category: readOptionalString(meta.category) ?? "other",
+    priority: readOptionalString(meta.priority) ?? "medium",
+    isKeyQuestion: typeof meta.isKeyQuestion === "boolean" ? meta.isKeyQuestion : false,
+    testType: readOptionalString(meta.testType) ?? "validates",
+    status: question.status ?? "active",
+    testLogic: readOptionalString(meta.testType) ?? "validates",
+    testRationale: readOptionalString(meta.rationale) ?? null,
+    beliefId: readOptionalString(meta.linkedBeliefNodeId) ?? null,
+    relatedBeliefIds: linkedBeliefNodeIds,
+    // Conviction stage fields — needed by UI to show/hide action buttons
+    convictionStage: readOptionalString(meta.convictionStage) ?? null,
+    answer: readOptionalString(meta.answer) ?? null,
+    conviction: readFiniteNumber(meta.conviction) ?? null,
+    linkedWorktreeId: resolveLinkedWorktreeId(meta),
+    linkedBeliefs,
+    metadata: question.metadata
+  };
+  if (question.projectId) {
+    payload.projectId = question.projectId;
+  }
+  if (question.topicId) {
+    payload.topicId = question.topicId;
+  }
+  if (questionText) {
+    payload.canonicalText = questionText;
+    payload.question = questionText;
+  }
+  return payload;
 }
-async function resolveQuestionScopeOrNull(ctx, args) {
-  if (!args.projectId && !args.topicId) {
-    return null;
+function collectSprintBeliefIds(sprintSynthesis, workflow) {
+  return /* @__PURE__ */ new Set([
+    ...toStringList(sprintSynthesis.synthesizedBeliefIds),
+    ...(workflow.worktree?.targetBeliefIds || workflow.sprint?.targetBeliefIds || []).map(String)
+  ]);
+}
+function collectInConvictionQuestionBeliefIds(meta) {
+  const beliefIds = /* @__PURE__ */ new Set();
+  const relatedIds = toStringList(meta.relatedBeliefIds);
+  if (meta.linkedBeliefNodeId) {
+    beliefIds.add(String(meta.linkedBeliefNodeId));
   }
-  try {
-    return await resolveTopicProjectScope(ctx, {
-      projectId: args.projectId ?? void 0,
-      topicId: args.topicId ?? void 0
+  if (meta.linkedBeliefId) {
+    beliefIds.add(String(meta.linkedBeliefId));
+  }
+  if (meta.beliefId) {
+    beliefIds.add(String(meta.beliefId));
+  }
+  for (const beliefId of relatedIds) {
+    beliefIds.add(String(beliefId));
+  }
+  return Array.from(beliefIds);
+}
+async function collectQuestionEvidenceDetails(ctx, q) {
+  const evidenceLinks = await ctx.db.query("questionEvidenceLinks").withIndex("by_questionId", (qb) => qb.eq("questionId", q._id)).collect();
+  const evidenceDetails = [];
+  for (const rawLink of evidenceLinks) {
+    const link = readQuestionEvidenceLinkRow(rawLink);
+    if (!link) {
+      continue;
+    }
+    const insight = readQuestionNodeRow(await ctx.db.get(link.insightId));
+    evidenceDetails.push({
+      ...link,
+      insightText: getNodeText(insight),
+      insightSource: getInsightSource(insight)
     });
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[epistemicQuestions] Failed to resolve question scope",
-      {
-        error: formatGraphPrimitiveError(error),
-        projectId: args.projectId,
-        topicId: args.topicId
-      }
-    );
-    return null;
   }
+  return evidenceDetails;
 }
-async function getQuestionNodesForScope(ctx, scope, args) {
-  const fetchNodes = (query2) => query2.collect();
-  const topicNodes = await fetchNodes(
-    ctx.db.query("epistemicNodes").withIndex(
-      "by_topic_type",
-      (q) => q.eq("topicId", scope.topicId).eq("nodeType", "question")
-    )
-  );
-  return dedupeQuestionNodes(topicNodes).filter(
-    (node) => questionMatchesScope(node, scope)
+async function collectQuestionBeliefDetails(ctx, beliefIds) {
+  const beliefDetails = await Promise.all(
+    beliefIds.map(async (beliefId) => {
+      try {
+        const nodeId = readConvexId(beliefId);
+        const node = nodeId ? readQuestionNodeRow(await ctx.db.get(nodeId)) : null;
+        if (node && node.nodeType === "belief") {
+          return {
+            _id: node._id,
+            belief: node.canonicalText ?? "",
+            confidence: toRecord(node.metadata).confidence,
+            pillar: readStringValue(toRecord(node.metadata), "category"),
+            beliefType: node.status ?? "active",
+            dependsOnCount: 0,
+            cascadesToCount: 0,
+            exclusiveWithCount: 0
+          };
+        }
+      } catch (error) {
+        debugGraphPrimitiveFallback(
+          "[epistemicQuestions] Failed to hydrate linked belief",
+          {
+            error: formatGraphPrimitiveError(error),
+            beliefId
+          }
+        );
+      }
+      return null;
+    })
   );
+  return beliefDetails.filter(Boolean);
 }
-async function getQuestionEdgesForScope(ctx, scope) {
-  const query2 = ctx.db.query("epistemicEdges").withIndex(
-    "by_topic",
-    (q) => q.eq("topicId", scope.topicId || scope.projectId)
-  );
-  return await query2.collect();
+function buildInConvictionQuestionPayload(question, meta, evidenceWithDetails, testedBeliefs) {
+  const relatedBeliefIds = toStringList(meta.relatedBeliefIds);
+  const convictionStage = readOptionalString(meta.convictionStage) ?? "in_conviction";
+  const payload = {
+    _id: question._id,
+    _creationTime: question._creationTime,
+    category: readOptionalString(meta.category) ?? "other",
+    priority: readOptionalString(meta.priority) ?? "medium",
+    status: readOptionalString(meta.questionStatus) ?? question.status ?? "open",
+    questionType: question.questionType ?? readOptionalString(meta.questionType) ?? "general",
+    testType: readOptionalString(meta.testType),
+    importance: readFiniteNumber(meta.importance),
+    isKeyQuestion: typeof meta.isKeyQuestion === "boolean" ? meta.isKeyQuestion : false,
+    conviction: readFiniteNumber(meta.conviction),
+    convictionStage,
+    convictionRationale: readOptionalString(meta.convictionRationale),
+    convictionAdvancedAt: readFiniteNumber(meta.convictionAdvancedAt),
+    convictionAdvancedBy: readOptionalString(meta.convictionAdvancedBy),
+    convictionUpdatedAt: readFiniteNumber(meta.convictionUpdatedAt),
+    convictionUpdatedBy: readOptionalString(meta.convictionUpdatedBy),
+    answer: readOptionalString(meta.answer),
+    answerStatus: readOptionalString(meta.answerStatus),
+    answerCompleteness: readOptionalString(meta.answerCompleteness),
+    whatWeNeed: readOptionalString(meta.whatWeNeed),
+    linkedWorktreeId: resolveLinkedWorktreeId(meta) || void 0,
+    beliefId: readOptionalString(meta.linkedBeliefNodeId) ?? readOptionalString(meta.beliefId) ?? null,
+    linkedBeliefId: readOptionalString(meta.linkedBeliefNodeId) ?? readOptionalString(meta.linkedBeliefId),
+    relatedBeliefIds,
+    evidenceCount: evidenceWithDetails.length,
+    evidence: evidenceWithDetails,
+    testedBeliefs,
+    metadata: question.metadata
+  };
+  if (question.projectId) {
+    payload.projectId = question.projectId;
+  }
+  if (question.canonicalText) {
+    payload.question = question.canonicalText;
+    payload.canonicalText = question.canonicalText;
+  }
+  if (question.createdAt !== void 0) {
+    payload.createdAt = question.createdAt;
+  }
+  if (question.createdBy) {
+    payload.createdBy = question.createdBy;
+  }
+  if (question.updatedAt !== void 0) {
+    payload.updatedAt = question.updatedAt;
+  }
+  return payload;
 }
-function questionMatchesScope(node, scope) {
-  return scope.topicId !== void 0 && node.topicId === scope.topicId || scope.projectId !== void 0 && node.projectId === scope.projectId;
+function toRecord(value) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
 }
-function resolveLinkedWorktreeId(meta) {
-  const linkedWorktreeId = meta.linkedWorktreeId;
-  return typeof linkedWorktreeId === "string" && linkedWorktreeId.trim() ? linkedWorktreeId : null;
+function readOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
-function questionMatchesWorkflowLink(meta, workflow) {
-  const linkedWorktreeId = resolveLinkedWorktreeId(meta);
-  return Boolean(
-    linkedWorktreeId && (linkedWorktreeId === workflow.worktreeId || linkedWorktreeId === workflow.sprintId)
-  );
+function readConvexId(value) {
+  const normalized = readOptionalString(value);
+  return normalized ? normalized : null;
+}
+function readFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readStringValue(source, key) {
+  const value = source[key];
+  return typeof value === "string" ? value : void 0;
+}
+function toStringList(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => readOptionalString(entry)).filter((entry) => entry !== void 0);
+}
+function readQuestionNodeRow(value) {
+  const record = toRecord(value);
+  const id = readConvexId(record._id);
+  const creationTime = readFiniteNumber(record._creationTime);
+  if (!(id && creationTime !== void 0)) {
+    return null;
+  }
+  const row = {
+    _id: id,
+    _creationTime: creationTime,
+    metadata: toRecord(record.metadata)
+  };
+  const optionalStrings = [
+    "canonicalText",
+    "content",
+    "createdBy",
+    "nodeType",
+    "projectId",
+    "questionType",
+    "sourceType",
+    "status",
+    "text",
+    "title",
+    "topicId"
+  ];
+  for (const key of optionalStrings) {
+    const value2 = readOptionalString(record[key]);
+    if (value2 !== void 0) {
+      row[key] = value2;
+    }
+  }
+  const createdAt = readFiniteNumber(record.createdAt);
+  if (createdAt !== void 0) {
+    row.createdAt = createdAt;
+  }
+  const updatedAt = readFiniteNumber(record.updatedAt);
+  if (updatedAt !== void 0) {
+    row.updatedAt = updatedAt;
+  }
+  return row;
+}
+function readQuestionEvidenceLinkRow(value) {
+  const record = toRecord(value);
+  const id = readConvexId(record._id);
+  const questionId = readConvexId(record.questionId);
+  const insightId = readConvexId(record.insightId);
+  const creationTime = readFiniteNumber(record._creationTime);
+  if (!(id && questionId && insightId && creationTime !== void 0)) {
+    return null;
+  }
+  return {
+    _id: id,
+    _creationTime: creationTime,
+    createdAt: readFiniteNumber(record.createdAt) ?? creationTime,
+    createdBy: readOptionalString(record.createdBy) ?? "unknown",
+    helpsAnswer: typeof record.helpsAnswer === "boolean" ? record.helpsAnswer : true,
+    insightId,
+    questionId,
+    rationale: readOptionalString(record.rationale) ?? "",
+    relevance: readFiniteNumber(record.relevance) ?? 0
+  };
+}
+function readEdgeRef(value) {
+  const record = toRecord(value);
+  const fromNodeId = readOptionalString(record.fromNodeId);
+  const toNodeId = readOptionalString(record.toNodeId);
+  if (!(fromNodeId || toNodeId)) {
+    return null;
+  }
+  return { fromNodeId, toNodeId };
+}
+function getNodeText(insight) {
+  if (!insight) {
+    return "";
+  }
+  const metadata = toRecord(insight.metadata);
+  const canonicalText = insight.canonicalText;
+  const legacyText = insight.text;
+  const contentText = insight.content;
+  const titleText = insight.title;
+  const snippetText = metadata.snippet;
+  if (typeof canonicalText === "string" && canonicalText.trim()) {
+    return canonicalText.trim();
+  }
+  if (typeof legacyText === "string" && legacyText.trim()) {
+    return legacyText.trim();
+  }
+  if (typeof contentText === "string" && contentText.trim()) {
+    return contentText.trim();
+  }
+  if (typeof titleText === "string" && titleText.trim()) {
+    return titleText.trim();
+  }
+  return typeof snippetText === "string" ? snippetText.trim() : "";
+}
+function getInsightSource(insight) {
+  if (!insight) {
+    return "unknown";
+  }
+  const sourceType = insight.sourceType;
+  return typeof sourceType === "string" && sourceType.trim().length > 0 ? sourceType : "unknown";
 }
-
-// src/epistemicQuestions.sprint.ts
 var getForSprintCluster = query({
   args: {
     sprintId: v.optional(v.string()),
@@ -491,7 +834,9 @@ var getForSprintCluster = query({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const docId = args.sprintId || args.worktreeId;
-    if (!docId) return [];
+    if (!docId) {
+      return [];
+    }
     const workflow = await resolveWorkflowBridgeDoc(ctx, docId);
     const scopeDoc = workflow.worktree ?? workflow.sprint;
     if (!scopeDoc) {
@@ -502,26 +847,22 @@ var getForSprintCluster = query({
       topicId: workflow.topicId
     });
     const scopeId = scope ? resolveQuestionScopeId(scope) : void 0;
-    if (!scope || !scopeId) {
+    if (!(scope && scopeId)) {
       return [];
     }
     const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
     if (!hasAccess) {
       return [];
     }
-    const synthesisState = scopeDoc.synthesisState;
+    const synthesisState = toRecord(scopeDoc.synthesisState);
     const hypothesisIds = new Set(
-      (synthesisState?.synthesizedBeliefIds || []).map(
-        (id) => String(id)
-      )
+      toStringList(synthesisState.synthesizedBeliefIds)
     );
     const rawBeliefIds = new Set(
-      (synthesisState?.originalBeliefIds || []).map(
-        (id) => String(id)
-      )
+      toStringList(synthesisState.originalBeliefIds)
     );
     const clusterBeliefIds = new Set(hypothesisIds);
-    const edges = await getQuestionEdgesForScope(ctx, scope);
+    const edges = (await getQuestionEdgesForScope(ctx, scope)).map(readEdgeRef).filter((edge) => edge !== null);
     for (const edge of edges) {
       const fromStr = String(edge.fromNodeId || "");
       const toStr = String(edge.toNodeId || "");
@@ -532,86 +873,37 @@ var getForSprintCluster = query({
         clusterBeliefIds.add(fromStr);
       }
     }
-    const questionNodes = await getQuestionNodesForScope(ctx, scope);
-    const sprintQuestionIds = new Set(
-      (workflow.worktree?.targetQuestionIds || workflow.sprint?.targetQuestionIds || []).map((id) => String(id))
+    const questionNodes = (await getQuestionNodesForScope(ctx, scope)).map(readQuestionNodeRow).filter(
+      (question) => question?.nodeType === "question"
     );
+    const sprintQuestionIds = /* @__PURE__ */ new Set([
+      ...toStringList(workflow.worktree?.targetQuestionIds),
+      ...toStringList(workflow.sprint?.targetQuestionIds)
+    ]);
     const clusterQuestions = questionNodes.filter((q) => {
       if (sprintQuestionIds.has(String(q._id))) {
         return true;
       }
-      const meta = q.metadata || {};
-      const linkedId = String(meta.linkedBeliefNodeId || "");
+      const meta = q.metadata;
+      const linkedId = readOptionalString(meta.linkedBeliefNodeId);
       if (linkedId && clusterBeliefIds.has(linkedId)) {
         return true;
       }
       return edges.some(
-        (e) => String(e.fromNodeId) === String(q._id) && clusterBeliefIds.has(String(e.toNodeId || "")) || String(e.toNodeId) === String(q._id) && clusterBeliefIds.has(String(e.fromNodeId || ""))
+        (e) => String(e.fromNodeId) === String(q._id) && clusterBeliefIds.has(e.toNodeId ?? "") || String(e.toNodeId) === String(q._id) && clusterBeliefIds.has(e.fromNodeId ?? "")
       );
     });
     const enrichedQuestions = await Promise.all(
-      clusterQuestions.map(async (q) => {
-        const meta = q.metadata || {};
-        const linkedBeliefNodeIds = /* @__PURE__ */ new Set();
-        const primaryBeliefId = String(meta.linkedBeliefNodeId || "");
-        if (primaryBeliefId) {
-          linkedBeliefNodeIds.add(primaryBeliefId);
-        }
-        for (const edge of edges) {
-          if (String(edge.fromNodeId) === String(q._id)) {
-            linkedBeliefNodeIds.add(String(edge.toNodeId || ""));
-          }
-          if (String(edge.toNodeId) === String(q._id)) {
-            linkedBeliefNodeIds.add(String(edge.fromNodeId || ""));
-          }
-        }
-        linkedBeliefNodeIds.delete("");
-        const linkedBeliefs = (await Promise.all(
-          Array.from(linkedBeliefNodeIds).map(async (nodeId) => {
-            const node = await ctx.db.get(nodeId);
-            if (!node || node.nodeType !== "belief") {
-              return null;
-            }
-            const isHypothesis = hypothesisIds.has(nodeId);
-            const isRaw = rawBeliefIds.has(nodeId);
-            const isConditional = !isHypothesis && !isRaw && clusterBeliefIds.has(nodeId);
-            return {
-              beliefId: node._id,
-              beliefText: node.canonicalText || "",
-              isHypothesis,
-              isConditional,
-              isRaw,
-              isPrimaryTarget: isHypothesis
-            };
-          })
-        )).filter(Boolean);
-        return {
-          _id: q._id,
-          _creationTime: q._creationTime,
-          projectId: q.projectId,
-          topicId: q.topicId,
-          canonicalText: q.canonicalText,
-          question: q.canonicalText,
-          // legacy field name
-          questionType: q.questionType || meta.questionType || "general",
-          priority: meta.priority || "medium",
-          isKeyQuestion: meta.isKeyQuestion || false,
-          testType: meta.testType || "validates",
-          category: meta.category || "other",
-          status: q.status,
-          linkedBeliefs,
-          testLogic: meta.testType || "validates",
-          testRationale: meta.rationale || null,
-          beliefId: meta.linkedBeliefNodeId || null,
-          relatedBeliefIds: Array.from(linkedBeliefNodeIds),
-          // Conviction stage fields — needed by UI to show/hide action buttons
-          convictionStage: meta.convictionStage || null,
-          answer: meta.answer || null,
-          conviction: meta.conviction ?? null,
-          linkedWorktreeId: resolveLinkedWorktreeId(meta),
-          metadata: q.metadata
-        };
-      })
+      clusterQuestions.map(
+        (q) => enrichSprintClusterQuestion(
+          ctx,
+          q,
+          edges,
+          hypothesisIds,
+          rawBeliefIds,
+          clusterBeliefIds
+        )
+      )
     );
     const seen = /* @__PURE__ */ new Set();
     return enrichedQuestions.filter((q) => {
@@ -632,7 +924,9 @@ var getInConviction = query({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const docId = args.sprintId || args.worktreeId;
-    if (!docId) return [];
+    if (!docId) {
+      return [];
+    }
     const workflow = await resolveWorkflowBridgeDoc(ctx, docId);
     const scopeDoc = workflow.worktree ?? workflow.sprint;
     if (!scopeDoc) {
@@ -643,26 +937,24 @@ var getInConviction = query({
       topicId: workflow.topicId
     });
     const scopeId = scope ? resolveQuestionScopeId(scope) : void 0;
-    if (!scope || !scopeId) {
+    if (!(scope && scopeId)) {
       return [];
     }
     const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
     if (!hasAccess) {
       return [];
     }
-    const allQuestions = await getQuestionNodesForScope(ctx, scope);
+    const allQuestions = (await getQuestionNodesForScope(ctx, scope)).map(readQuestionNodeRow).filter(
+      (question) => question?.nodeType === "question"
+    );
     const convictionQuestions = allQuestions.filter((q) => {
-      const meta = q.metadata || {};
+      const meta = q.metadata;
       return meta.convictionStage === "in_conviction" || meta.convictionStage === "scored";
     });
-    const sprintBeliefIds = /* @__PURE__ */ new Set([
-      ...(scopeDoc.synthesisState?.synthesizedBeliefIds || []).map(
-        String
-      ),
-      ...(workflow.worktree?.targetBeliefIds || workflow.sprint?.targetBeliefIds || []).map(String)
-    ]);
+    const sprintSynthesis = toRecord(scopeDoc.synthesisState);
+    const sprintBeliefIds = collectSprintBeliefIds(sprintSynthesis, workflow);
     const sprintQuestions = convictionQuestions.filter((q) => {
-      const meta = q.metadata || {};
+      const meta = q.metadata;
       if (questionMatchesWorkflowLink(meta, workflow)) {
         return true;
       }
@@ -675,7 +967,7 @@ var getInConviction = query({
       if (meta.beliefId && sprintBeliefIds.has(String(meta.beliefId))) {
         return true;
       }
-      const relatedIds = meta.relatedBeliefIds || [];
+      const relatedIds = toStringList(meta.relatedBeliefIds);
       if (relatedIds.some((id) => sprintBeliefIds.has(String(id)))) {
         return true;
       }
@@ -683,107 +975,21 @@ var getInConviction = query({
     });
     const questionsWithDetails = await Promise.all(
       sprintQuestions.map(async (q) => {
-        const meta = q.metadata || {};
-        const evidenceLinks = await ctx.db.query("questionEvidenceLinks").withIndex(
-          "by_questionId",
-          (qb) => qb.eq("questionId", q._id)
-        ).collect();
-        const evidenceWithDetails = await Promise.all(
-          evidenceLinks.map(async (link) => {
-            const insight = await ctx.db.get(link.insightId);
-            const insightMeta = insight?.metadata || {};
-            const canonicalText = insight?.canonicalText;
-            const legacyText = insight?.text;
-            const contentText = insight?.content;
-            const titleText = insight?.title;
-            const snippetText = insightMeta.snippet;
-            return {
-              ...link,
-              insightText: typeof canonicalText === "string" && canonicalText.trim() || typeof legacyText === "string" && legacyText.trim() || typeof contentText === "string" && contentText.trim() || typeof titleText === "string" && titleText.trim() || typeof snippetText === "string" && snippetText.trim() || "",
-              insightSource: insight?.sourceType || "unknown"
-            };
-          })
+        const meta = q.metadata;
+        const [evidenceWithDetails, beliefIds] = await Promise.all([
+          collectQuestionEvidenceDetails(ctx, q),
+          Promise.resolve(collectInConvictionQuestionBeliefIds(meta))
+        ]);
+        const beliefsWithDetails = await collectQuestionBeliefDetails(
+          ctx,
+          beliefIds
         );
-        const beliefIds = [];
-        const relatedIds = meta.relatedBeliefIds || [];
-        if (meta.linkedBeliefNodeId) {
-          beliefIds.push(String(meta.linkedBeliefNodeId));
-        }
-        if (meta.linkedBeliefId) {
-          beliefIds.push(String(meta.linkedBeliefId));
-        }
-        if (meta.beliefId) {
-          beliefIds.push(String(meta.beliefId));
-        }
-        for (const id of relatedIds) {
-          if (!beliefIds.includes(String(id))) {
-            beliefIds.push(String(id));
-          }
-        }
-        const beliefsWithDetails = await Promise.all(
-          beliefIds.map(async (beliefId) => {
-            try {
-              const node = await ctx.db.get(beliefId);
-              if (node && node.nodeType === "belief") {
-                return {
-                  _id: node._id,
-                  belief: node.canonicalText || "",
-                  confidence: node.metadata?.confidence,
-                  pillar: node.metadata?.category,
-                  beliefType: node.status,
-                  dependsOnCount: 0,
-                  cascadesToCount: 0,
-                  exclusiveWithCount: 0
-                };
-              }
-            } catch (error) {
-              debugGraphPrimitiveFallback(
-                "[epistemicQuestions] Failed to hydrate linked belief",
-                {
-                  error: formatGraphPrimitiveError(error),
-                  beliefId
-                }
-              );
-            }
-            return null;
-          })
+        return buildInConvictionQuestionPayload(
+          q,
+          meta,
+          evidenceWithDetails,
+          beliefsWithDetails
         );
-        return {
-          _id: q._id,
-          _creationTime: q._creationTime,
-          projectId: q.projectId,
-          question: q.canonicalText,
-          canonicalText: q.canonicalText,
-          category: meta.category || "other",
-          priority: meta.priority || "medium",
-          status: meta.questionStatus || q.status,
-          questionType: q.questionType || meta.questionType || "general",
-          testType: meta.testType || void 0,
-          importance: meta.importance || void 0,
-          isKeyQuestion: meta.isKeyQuestion || false,
-          conviction: meta.conviction,
-          convictionStage: meta.convictionStage,
-          convictionRationale: meta.convictionRationale,
-          convictionAdvancedAt: meta.convictionAdvancedAt,
-          convictionAdvancedBy: meta.convictionAdvancedBy,
-          convictionUpdatedAt: meta.convictionUpdatedAt,
-          convictionUpdatedBy: meta.convictionUpdatedBy,
-          answer: meta.answer,
-          answerStatus: meta.answerStatus,
-          answerCompleteness: meta.answerCompleteness,
-          whatWeNeed: meta.whatWeNeed,
-          linkedWorktreeId: resolveLinkedWorktreeId(meta) || void 0,
-          beliefId: meta.linkedBeliefNodeId || meta.beliefId || null,
-          linkedBeliefId: meta.linkedBeliefNodeId || meta.linkedBeliefId,
-          relatedBeliefIds: relatedIds,
-          evidenceCount: evidenceWithDetails.length,
-          evidence: evidenceWithDetails,
-          testedBeliefs: beliefsWithDetails.filter(Boolean),
-          createdAt: q.createdAt,
-          createdBy: q.createdBy,
-          updatedAt: q.updatedAt,
-          metadata: q.metadata
-        };
       })
     );
     return questionsWithDetails.sort((a, b) => {