@lucern/graph-primitives 0.3.0-alpha.9 → 1.0.1

package/dist/epistemicQuestions.sprint.js

@@ -0,0 +1,757 @@
+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';
+
+// src/epistemicQuestions.sprint.ts
+var api = anyApi;
+componentsGeneric();
+var query = queryGeneric;
+
+// src/debug.ts
+function isGraphPrimitiveDebugEnabled() {
+  const env = globalThis.process?.env;
+  return env?.LUCERN_COMPAT_FALLBACK_DEBUG === "1" || env?.LUCERN_GRAPH_DEBUG === "1";
+}
+function formatGraphPrimitiveError(error) {
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error === null) {
+    return "null";
+  }
+  if (error === void 0) {
+    return "undefined";
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return Object.prototype.toString.call(error);
+  }
+}
+function debugGraphPrimitiveFallback(message, context) {
+  if (!isGraphPrimitiveDebugEnabled()) {
+    return;
+  }
+  console.debug(message, context ?? {});
+}
+var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
+function asMappedProjectId(topic) {
+  if (!topic) {
+    return;
+  }
+  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD]);
+  if (directLegacyProjectId) {
+    return directLegacyProjectId;
+  }
+  const metadata = topic.metadata || {};
+  const candidate = metadata[LEGACY_SCOPE_FIELD] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
+  return candidate ? candidate : void 0;
+}
+function normalizeScopeValue(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function pickPrimaryTopic(candidates) {
+  return [...candidates].sort((a, b) => {
+    const depthA = a.depth ?? 9999;
+    const depthB = b.depth ?? 9999;
+    if (depthA !== depthB) {
+      return depthA - depthB;
+    }
+    const createdA = a.createdAt ?? Number.MAX_SAFE_INTEGER;
+    const createdB = b.createdAt ?? Number.MAX_SAFE_INTEGER;
+    if (createdA !== createdB) {
+      return createdA - createdB;
+    }
+    return String(a.name || "").localeCompare(String(b.name || ""));
+  })[0];
+}
+async function findTopicsByScopeAlias(ctx, scopeId) {
+  try {
+    return await ctx.db.query("topics").withIndex(
+      "by_graph_scope_project",
+      (q) => q.eq(LEGACY_SCOPE_FIELD, scopeId)
+    ).collect();
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve scope alias via index",
+      {
+        error,
+        scopeId
+      }
+    );
+    const topics = await ctx.db.query("topics").collect();
+    return topics.filter((topic) => {
+      const normalizedGlobalId = normalizeScopeValue(topic.globalId);
+      const mappedProjectId = asMappedProjectId(topic);
+      return String(topic._id) === scopeId || normalizedGlobalId === scopeId || mappedProjectId === scopeId;
+    });
+  }
+}
+async function tryResolveHostTopicById(ctx, topicId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api.topics.get, {
+      id: topicId
+    }) ?? null;
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve topic by host query",
+      {
+        error,
+        topicId
+      }
+    );
+    return null;
+  }
+}
+async function tryResolveHostTopicByLegacyScope(ctx, legacyScopeId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api.topics.getByLegacyScopeId, {
+      projectId: legacyScopeId
+    }) ?? null;
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve topic by legacy scope",
+      {
+        error,
+        legacyScopeId
+      }
+    );
+    return null;
+  }
+}
+async function resolveInheritedWorkspaceScope(ctx, topic) {
+  const MAX_DEPTH = 10;
+  let tenantId = normalizeScopeValue(topic.tenantId);
+  let workspaceId = normalizeScopeValue(topic.workspaceId);
+  if (tenantId && workspaceId) {
+    return { tenantId, workspaceId };
+  }
+  let current = topic;
+  for (let i = 0; i < MAX_DEPTH && current?.parentTopicId; i++) {
+    current = await ctx.db.get(current.parentTopicId);
+    if (!current) break;
+    if (!tenantId) {
+      tenantId = normalizeScopeValue(current.tenantId);
+    }
+    if (!workspaceId) {
+      workspaceId = normalizeScopeValue(current.workspaceId);
+    }
+    if (tenantId && workspaceId) break;
+  }
+  return { 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) {
+      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"
+    };
+  }
+  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"
+      };
+    }
+    throw new Error(
+      `Legacy project scope ${String(args.projectId)} has no mapped topic.`
+    );
+  }
+  throw new Error(
+    "Missing scope: provide topicId (preferred) or legacy projectId alias."
+  );
+}
+({
+  projectId: v.optional(v.string()),
+  topicId: v.optional(v.string())
+});
+
+// src/workflowBridge.ts
+function isLegacySprintDoc(doc) {
+  if (!doc || typeof doc !== "object") {
+    return false;
+  }
+  if ("metadata" in doc && doc.metadata?.pairedSprintId) {
+    return false;
+  }
+  return "sprintScope" in doc || "targetPillar" in doc || "pillarThesis" in doc || "synthesisState" in doc || "projectId" in doc && !("worktreeScope" in doc);
+}
+function getPairedSprintId(doc) {
+  const pairedSprintId = doc?.metadata?.pairedSprintId;
+  return typeof pairedSprintId === "string" && pairedSprintId.trim().length > 0 ? pairedSprintId : null;
+}
+function getStringField(doc, field) {
+  const value = doc?.[field];
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+async function findPairedWorktreeForSprint(ctx, sprint) {
+  const sprintId = typeof sprint._id === "string" && sprint._id.length > 0 ? sprint._id : null;
+  if (!sprintId || typeof ctx.db.query !== "function") {
+    return null;
+  }
+  let topicId = getStringField(sprint, "topicId");
+  if (!topicId) {
+    try {
+      const scope = await resolveTopicProjectScope(ctx, {
+        topicId: getStringField(sprint, "topicId"),
+        projectId: getStringField(sprint, "projectId")
+      });
+      topicId = scope.topicId;
+    } catch {
+      topicId = void 0;
+    }
+  }
+  if (!topicId) {
+    return null;
+  }
+  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
+  ) ?? null;
+}
+async function resolveWorkflowBridgeDoc(ctx, workflowId) {
+  const empty = {
+    inputId: workflowId ?? null,
+    sprint: null,
+    worktree: null,
+    sprintId: null,
+    worktreeId: null
+  };
+  if (!workflowId) {
+    return empty;
+  }
+  let doc;
+  try {
+    doc = await ctx.db.get(workflowId);
+  } catch {
+    return empty;
+  }
+  if (!doc || typeof doc !== "object") {
+    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")
+    };
+  }
+  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;
+    }
+  }
+  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,
+    topicId: getStringField(worktree, "topicId") ?? getStringField(sprint, "topicId"),
+    projectId: getStringField(sprint, "projectId") ?? getStringField(worktree, "projectId")
+  };
+}
+
+// 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/epistemicQuestions.sprint.ts
+var getForSprintCluster = query({
+  args: {
+    sprintId: v.optional(v.string()),
+    worktreeId: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const docId = args.sprintId || args.worktreeId;
+    if (!docId) return [];
+    const workflow = await resolveWorkflowBridgeDoc(ctx, docId);
+    const scopeDoc = workflow.worktree ?? workflow.sprint;
+    if (!scopeDoc) {
+      return [];
+    }
+    const scope = await resolveQuestionScopeOrNull(ctx, {
+      projectId: workflow.projectId,
+      topicId: workflow.topicId
+    });
+    const scopeId = scope ? resolveQuestionScopeId(scope) : void 0;
+    if (!scope || !scopeId) {
+      return [];
+    }
+    const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
+    if (!hasAccess) {
+      return [];
+    }
+    const synthesisState = scopeDoc.synthesisState;
+    const hypothesisIds = new Set(
+      (synthesisState?.synthesizedBeliefIds || []).map(
+        (id) => String(id)
+      )
+    );
+    const rawBeliefIds = new Set(
+      (synthesisState?.originalBeliefIds || []).map(
+        (id) => String(id)
+      )
+    );
+    const clusterBeliefIds = new Set(hypothesisIds);
+    const edges = await getQuestionEdgesForScope(ctx, scope);
+    for (const edge of edges) {
+      const fromStr = String(edge.fromNodeId || "");
+      const toStr = String(edge.toNodeId || "");
+      if (hypothesisIds.has(fromStr) && !rawBeliefIds.has(toStr)) {
+        clusterBeliefIds.add(toStr);
+      }
+      if (hypothesisIds.has(toStr) && !rawBeliefIds.has(fromStr)) {
+        clusterBeliefIds.add(fromStr);
+      }
+    }
+    const questionNodes = await getQuestionNodesForScope(ctx, scope);
+    const sprintQuestionIds = new Set(
+      (workflow.worktree?.targetQuestionIds || workflow.sprint?.targetQuestionIds || []).map((id) => String(id))
+    );
+    const clusterQuestions = questionNodes.filter((q) => {
+      if (sprintQuestionIds.has(String(q._id))) {
+        return true;
+      }
+      const meta = q.metadata || {};
+      const linkedId = String(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 || ""))
+      );
+    });
+    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
+        };
+      })
+    );
+    const seen = /* @__PURE__ */ new Set();
+    return enrichedQuestions.filter((q) => {
+      if (seen.has(String(q._id))) {
+        return false;
+      }
+      seen.add(String(q._id));
+      return true;
+    });
+  }
+});
+var getInConviction = query({
+  args: {
+    sprintId: v.optional(v.string()),
+    worktreeId: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const docId = args.sprintId || args.worktreeId;
+    if (!docId) return [];
+    const workflow = await resolveWorkflowBridgeDoc(ctx, docId);
+    const scopeDoc = workflow.worktree ?? workflow.sprint;
+    if (!scopeDoc) {
+      return [];
+    }
+    const scope = await resolveQuestionScopeOrNull(ctx, {
+      projectId: workflow.projectId,
+      topicId: workflow.topicId
+    });
+    const scopeId = scope ? resolveQuestionScopeId(scope) : void 0;
+    if (!scope || !scopeId) {
+      return [];
+    }
+    const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
+    if (!hasAccess) {
+      return [];
+    }
+    const allQuestions = await getQuestionNodesForScope(ctx, scope);
+    const convictionQuestions = allQuestions.filter((q) => {
+      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 sprintQuestions = convictionQuestions.filter((q) => {
+      const meta = q.metadata || {};
+      if (questionMatchesWorkflowLink(meta, workflow)) {
+        return true;
+      }
+      if (meta.linkedBeliefNodeId && sprintBeliefIds.has(String(meta.linkedBeliefNodeId))) {
+        return true;
+      }
+      if (meta.linkedBeliefId && sprintBeliefIds.has(String(meta.linkedBeliefId))) {
+        return true;
+      }
+      if (meta.beliefId && sprintBeliefIds.has(String(meta.beliefId))) {
+        return true;
+      }
+      const relatedIds = meta.relatedBeliefIds || [];
+      if (relatedIds.some((id) => sprintBeliefIds.has(String(id)))) {
+        return true;
+      }
+      return false;
+    });
+    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 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 {
+          _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) => {
+      if (a.convictionStage === "in_conviction" && b.convictionStage === "scored") {
+        return -1;
+      }
+      if (a.convictionStage === "scored" && b.convictionStage === "in_conviction") {
+        return 1;
+      }
+      return (a.importance || 5) - (b.importance || 5);
+    });
+  }
+});
+
+export { getForSprintCluster, getInConviction };
+//# sourceMappingURL=epistemicQuestions.sprint.js.map
+//# sourceMappingURL=epistemicQuestions.sprint.js.map