@lucern/graph-primitives 1.0.28 → 1.0.30

package/dist/beliefDecay.js

@@ -1,12 +1,16 @@
-import { v } from 'convex/values';
+import { getAccessibleProjectIds } from '@lucern/access-control/access';
 import { getRescoringSchedule } from '@lucern/confidence';
 export { DEADLINE_URGENCY, DECAY_TIERS, bayesianUpdate, computeBaseDecay, computeDeadlineUrgency, computeEffectiveDecay, getRescoringSchedule } from '@lucern/confidence';
-import { getAccessibleProjectIds } 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/beliefDecay.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;
 
@@ -40,6 +44,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;
@@ -120,9 +128,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;
     }
@@ -142,8 +153,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,
@@ -212,90 +233,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);
   }
-  patch.updatedAt = Date.now();
-  patch.metadata = nextMetadata;
-  topicUpdateArgs.metadata = nextMetadata;
+  plan.patch.updatedAt = Date.now();
+  plan.patch.metadata = plan.nextMetadata;
+  plan.topicUpdateArgs.metadata = plan.nextMetadata;
+  return plan;
+}
+function applyTopicProjectOverlayPatchEntry(plan, key, rawValue) {
+  switch (key) {
+    case "_id":
+    case "projectId":
+    case "topicId":
+    case "legacyProjectId":
+    case "storageProjectId":
+    case "updatedAt":
+    case "createdAt":
+      return;
+    case "name":
+    case "description":
+      plan.patch[key] = rawValue;
+      plan.topicUpdateArgs[key] = rawValue;
+      return;
+    case "tenantId":
+    case "workspaceId":
+    case "ownerId":
+      throw new Error(
+        `patchTopicProjectOverlay cannot mutate ${key} via component-owned topics`
+      );
+    case "status":
+      applyTopicStatusPatch(plan, rawValue);
+      return;
+    case "visibility":
+      applyTopicVisibilityPatch(plan, rawValue);
+      return;
+    case "type":
+      applyTopicProjectTypePatch(plan, rawValue);
+      return;
+    default:
+      applyTopicMetadataPatch(plan, key, rawValue);
+  }
+}
+function applyTopicStatusPatch(plan, rawValue) {
+  const status = coerceStatus(rawValue);
+  if (status) {
+    plan.patch.status = status;
+    plan.topicUpdateArgs.status = status;
+  }
+}
+function applyTopicVisibilityPatch(plan, rawValue) {
+  const visibility = coerceVisibility(rawValue);
+  if (visibility) {
+    plan.patch.visibility = visibility;
+    plan.topicUpdateArgs.visibility = visibility;
+  }
+}
+function applyTopicProjectTypePatch(plan, rawValue) {
+  const projectType = readNonEmptyString(rawValue);
+  if (projectType) {
+    plan.nextMetadata.projectType = projectType;
+    return;
+  }
+  plan.nextMetadata = omitMetadataKey(plan.nextMetadata, "projectType");
+}
+function applyTopicMetadataPatch(plan, key, rawValue) {
+  if (rawValue === void 0) {
+    plan.nextMetadata = omitMetadataKey(plan.nextMetadata, key);
+    return;
+  }
+  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
@@ -323,7 +367,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(
@@ -390,13 +434,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") {
@@ -421,8 +467,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();
@@ -434,7 +481,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);
@@ -490,143 +537,195 @@ async function resolveInheritedWorkspaceScope(ctx, topic) {
   let current = topic;
   for (let i = 0; i < MAX_DEPTH && current?.parentTopicId; i++) {
     current = await ctx.db.get(current.parentTopicId);
-    if (!current) break;
+    if (!current) {
+      break;
+    }
     if (!tenantId) {
       tenantId = normalizeScopeValue(current.tenantId);
     }
     if (!workspaceId) {
       workspaceId = normalizeScopeValue(current.workspaceId);
     }
-    if (tenantId && workspaceId) break;
+    if (tenantId && workspaceId) {
+      break;
+    }
   }
   return { tenantId, workspaceId };
 }
 async function resolveTopicProjectScope(ctx, args) {
   if (args.topicId) {
-    let topic = null;
-    try {
-      topic = await ctx.db.get(
-        args.topicId
-      );
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[topicScope] Failed to load topic by direct id",
-        {
-          error,
-          topicId: args.topicId
-        }
-      );
-    }
-    if (!topic) {
-      topic = await tryResolveHostTopicById(ctx, String(args.topicId));
-    }
-    if (!topic) {
-      topic = pickPrimaryTopic(
-        await findTopicsByScopeAlias(ctx, String(args.topicId))
-      ) ?? null;
-    }
-    if (!topic) {
-      const nodeScope = await resolveTopicNodeScopeOrNull(
-        ctx,
-        String(args.topicId)
-      );
-      if (nodeScope) {
-        return nodeScope;
-      }
-      throw new Error(`Topic not found: ${String(args.topicId)}`);
-    }
-    const inherited = await resolveInheritedWorkspaceScope(ctx, topic);
-    const mapped = asMappedProjectId(topic);
-    if (mapped) {
-      return {
-        topicId: topic._id,
-        projectId: mapped,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "topic"
-      };
-    }
-    return {
-      topicId: topic._id,
-      tenantId: inherited.tenantId,
-      workspaceId: inherited.workspaceId,
-      source: "topic"
-    };
+    return await resolveScopeFromTopicId(ctx, args.topicId);
   }
   if (args.projectId) {
-    let directTopic = null;
-    try {
-      directTopic = await ctx.db.get(
-        args.projectId
-      );
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[topicScope] Failed to load direct project topic",
-        {
-          error,
-          projectId: args.projectId
-        }
-      );
-    }
-    if (directTopic) {
-      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
-      const mapped = asMappedProjectId(directTopic);
-      return {
-        topicId: directTopic._id,
-        projectId: mapped ?? args.projectId,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "topic_inferred"
-      };
-    }
-    directTopic = await tryResolveHostTopicByLegacyScope(ctx, args.projectId);
-    if (directTopic) {
-      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
-      const mapped = asMappedProjectId(directTopic);
-      return {
-        topicId: directTopic._id,
-        projectId: mapped ?? args.projectId,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "topic_inferred"
-      };
-    }
-    const topics = await findTopicsByScopeAlias(ctx, args.projectId);
-    const primary = pickPrimaryTopic(topics);
-    if (primary) {
-      const inherited = await resolveInheritedWorkspaceScope(ctx, primary);
-      return {
-        topicId: primary._id,
-        projectId: args.projectId,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "project_mapped_topic"
-      };
-    }
-    const nodeScope = await resolveTopicNodeScopeOrNull(
-      ctx,
-      String(args.projectId)
-    );
-    if (nodeScope) {
-      return {
-        ...nodeScope,
-        projectId: nodeScope.projectId ?? String(args.projectId)
-      };
-    }
-    throw new Error(
-      `Legacy project scope ${String(args.projectId)} has no mapped topic.`
-    );
+    return await resolveScopeFromLegacyProjectId(ctx, args.projectId);
   }
   throw new Error(
     "Missing scope: provide topicId (preferred) or legacy projectId alias."
   );
 }
+async function resolveScopeFromTopicId(ctx, topicId) {
+  const topic = await resolveTopicDocFromTopicId(ctx, topicId);
+  if (topic) {
+    return await buildTopicScope(ctx, topic, "topic");
+  }
+  const nodeScope = await resolveTopicNodeScopeOrNull(ctx, String(topicId));
+  if (nodeScope) {
+    return nodeScope;
+  }
+  throw new Error(`Topic not found: ${String(topicId)}`);
+}
+async function resolveTopicDocFromTopicId(ctx, topicId) {
+  const direct = await tryReadTopicDoc(ctx, topicId, {
+    failureLog: "[topicScope] Failed to load topic by direct id",
+    idLogKey: "topicId"
+  });
+  if (direct) {
+    return direct;
+  }
+  const hostTopic = await tryResolveHostTopicById(ctx, String(topicId));
+  if (hostTopic) {
+    return hostTopic;
+  }
+  return pickPrimaryTopic(await findTopicsByScopeAlias(ctx, String(topicId))) ?? null;
+}
+async function resolveScopeFromLegacyProjectId(ctx, legacyProjectId) {
+  const directTopic = await resolveDirectLegacyProjectTopic(
+    ctx,
+    legacyProjectId
+  );
+  if (directTopic) {
+    return await buildTopicScope(ctx, directTopic, "topic_inferred", {
+      fallbackProjectId: legacyProjectId
+    });
+  }
+  const primary = pickPrimaryTopic(
+    await findTopicsByScopeAlias(ctx, legacyProjectId)
+  );
+  if (primary) {
+    return await buildTopicScope(ctx, primary, "project_mapped_topic", {
+      fallbackProjectId: legacyProjectId
+    });
+  }
+  const nodeScope = await resolveTopicNodeScopeOrNull(ctx, legacyProjectId);
+  if (nodeScope) {
+    return {
+      ...nodeScope,
+      projectId: nodeScope.projectId ?? legacyProjectId
+    };
+  }
+  throw new Error(
+    `Legacy project scope ${legacyProjectId} has no mapped topic.`
+  );
+}
+async function resolveDirectLegacyProjectTopic(ctx, legacyProjectId) {
+  const directTopic = await tryReadTopicDoc(ctx, legacyProjectId, {
+    failureLog: "[topicScope] Failed to load direct project topic",
+    idLogKey: "projectId"
+  });
+  return directTopic ?? tryResolveHostTopicByLegacyScope(ctx, legacyProjectId);
+}
+async function tryReadTopicDoc(ctx, id, log) {
+  try {
+    return await ctx.db.get(id);
+  } catch (error) {
+    debugGraphPrimitiveFallback(log.failureLog, {
+      error,
+      [log.idLogKey]: id
+    });
+    return null;
+  }
+}
+async function buildTopicScope(ctx, topic, source, options = {}) {
+  const inherited = await resolveInheritedWorkspaceScope(ctx, topic);
+  const mapped = asMappedProjectId(topic);
+  return {
+    topicId: topic._id,
+    ...mapped || options.fallbackProjectId ? { projectId: mapped ?? options.fallbackProjectId } : {},
+    tenantId: inherited.tenantId,
+    workspaceId: inherited.workspaceId,
+    source
+  };
+}
 var optionalScopeArgs = {
   projectId: v.optional(v.string()),
   topicId: v.optional(v.string())
 };
-
-// src/beliefDecay.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readConvexId(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readOptionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readBeliefMetadata(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  return {
+    beliefStatus: readOptionalString(value.beliefStatus),
+    confidence: readOptionalNumber(value.confidence)
+  };
+}
+function readPredictionMeta(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  return {
+    expectedBy: readOptionalNumber(value.expectedBy)
+  };
+}
+function readBeliefRecord(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const id = readConvexId(value._id);
+  if (!id || typeof value.canonicalText !== "string") {
+    return null;
+  }
+  return {
+    _creationTime: readOptionalNumber(value._creationTime),
+    _id: id,
+    beliefStatus: readOptionalString(value.beliefStatus) ?? null,
+    canonicalText: value.canonicalText,
+    confidence: readOptionalNumber(value.confidence),
+    createdAt: readOptionalNumber(value.createdAt),
+    metadata: readBeliefMetadata(value.metadata),
+    predictionMeta: readPredictionMeta(value.predictionMeta),
+    status: readOptionalString(value.status),
+    temporalNature: readOptionalString(value.temporalNature) ?? null,
+    updatedAt: readOptionalNumber(value.updatedAt)
+  };
+}
+function readConfidenceEntry(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const assessedAt = readOptionalNumber(value.assessedAt);
+  if (assessedAt === void 0) {
+    return null;
+  }
+  return {
+    assessedAt,
+    confidence: readOptionalNumber(value.confidence) ?? null
+  };
+}
+function readRowList(values, reader) {
+  return values.flatMap((value) => {
+    const row = reader(value);
+    return row ? [row] : [];
+  });
+}
+var PRIORITY_RANK = {
+  critical: 4,
+  high: 3,
+  medium: 2,
+  low: 1
+};
 var identifyBeliefsNeedingRescore = query({
   args: {
     ...optionalScopeArgs,
@@ -661,17 +760,14 @@ var identifyBeliefsNeedingRescore = query({
     if (!scope) {
       return [];
     }
-    const priorityRank = {
-      critical: 4,
-      high: 3,
-      medium: 2,
-      low: 1
-    };
-    const minRank = priorityRank[minPriority] ?? 2;
-    const beliefs = await ctx.db.query("epistemicNodes").withIndex(
-      "by_topic_type",
-      (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
-    ).collect();
+    const minRank = PRIORITY_RANK[minPriority] ?? 2;
+    const beliefs = readRowList(
+      await ctx.db.query("epistemicNodes").withIndex(
+        "by_topic_type",
+        (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
+      ).collect(),
+      readBeliefRecord
+    );
     const activeBeliefs = beliefs.filter((b) => b.status === "active");
     const results = [];
     for (const belief of activeBeliefs) {
@@ -679,10 +775,13 @@ var identifyBeliefsNeedingRescore = query({
       const predictionMeta = belief.predictionMeta ?? void 0;
       const temporalNature = belief.temporalNature === "forecast" || belief.temporalNature === "factual" ? belief.temporalNature : "unknown";
       const beliefStatus = belief.beliefStatus ?? metadata.beliefStatus ?? null;
-      const confidenceHistory = await ctx.db.query("beliefConfidence").withIndex(
-        "by_beliefId",
-        (q) => q.eq("beliefId", belief._id)
-      ).collect();
+      const confidenceHistory = readRowList(
+        await ctx.db.query("beliefConfidence").withIndex(
+          "by_beliefId",
+          (q) => q.eq("beliefId", belief._id)
+        ).collect(),
+        readConfidenceEntry
+      );
       const sorted = confidenceHistory.sort(
         (a, b) => b.assessedAt - a.assessedAt
       );
@@ -697,7 +796,7 @@ var identifyBeliefsNeedingRescore = query({
         confidence,
         beliefStatus
       });
-      if (priorityRank[schedule.priority] >= minRank) {
+      if (PRIORITY_RANK[schedule.priority] >= minRank) {
         results.push({
           beliefId: belief._id,
           beliefText: belief.canonicalText,
@@ -712,7 +811,7 @@ var identifyBeliefsNeedingRescore = query({
       }
     }
     results.sort((a, b) => {
-      const rankDiff = priorityRank[b.schedule.priority] - priorityRank[a.schedule.priority];
+      const rankDiff = PRIORITY_RANK[b.schedule.priority] - PRIORITY_RANK[a.schedule.priority];
       if (rankDiff !== 0) {
         return rankDiff;
       }
@@ -749,108 +848,137 @@ var getGlobalBeliefHealth = query({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const { clerkId, maxResults = 30, minPriority = "medium" } = args;
-    const priorityRank = {
-      critical: 4,
-      high: 3,
-      medium: 2,
-      low: 1
-    };
-    const minRank = priorityRank[minPriority] ?? 2;
-    const allProjects = await resolveGraphPrimitivesAppResolvers().listTopics(ctx);
+    const minRank = PRIORITY_RANK[minPriority] ?? 2;
+    const allProjects = await listGraphPrimitiveTopics(ctx);
     const accessibleProjectIds = await getAccessibleProjectIds(ctx, clerkId);
-    const accessibleProjects = allProjects.filter(
-      (project) => accessibleProjectIds.has(project._id)
+    const accessibleProjects = allProjects.filter((project) => accessibleProjectIds.has(project._id)).slice(0, 20);
+    const allResults = sortGlobalHealthResults(
+      await collectGlobalHealthResults(ctx, accessibleProjects, minRank)
     );
-    const allResults = [];
-    for (const project of accessibleProjects.slice(0, 20)) {
-      let scope;
-      try {
-        scope = await resolveTopicProjectScope(ctx, {
-          projectId: String(project._id)
-        });
-      } catch (error) {
-        debugGraphPrimitiveFallback(
-          "[beliefDecay] Failed to resolve project scope in health query",
-          {
-            error,
-            projectId: String(project._id)
-          }
-        );
-        continue;
-      }
-      if (!scope) {
-        continue;
-      }
-      const beliefs = await ctx.db.query("epistemicNodes").withIndex(
-        "by_topic_type",
-        (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
-      ).collect();
-      const activeBeliefs = beliefs.filter((b) => b.status === "active");
-      for (const belief of activeBeliefs) {
-        const metadata = belief.metadata ?? {};
-        const predictionMeta = belief.predictionMeta ?? void 0;
-        const temporalNature = belief.temporalNature === "forecast" || belief.temporalNature === "factual" ? belief.temporalNature : "unknown";
-        const confidence = belief.confidence ?? metadata.confidence ?? 0.5;
-        const lastScoredAt = belief.updatedAt ?? belief.createdAt ?? belief._creationTime ?? Date.now();
-        const schedule = getRescoringSchedule({
-          lastScoredAt,
-          temporalNature,
-          expectedBy: predictionMeta?.expectedBy ?? null,
-          predictionMeta: predictionMeta ?? null,
-          confidence,
-          beliefStatus: belief.beliefStatus ?? metadata.beliefStatus ?? null
-        });
-        if (priorityRank[schedule.priority] >= minRank) {
-          allResults.push({
-            projectId: project._id,
-            projectName: project.name,
-            beliefId: belief._id,
-            beliefText: belief.canonicalText,
-            confidence,
-            temporalNature,
-            expectedBy: predictionMeta?.expectedBy ?? null,
-            daysSinceScoring: Math.round(schedule.decay.ageDays),
-            priority: schedule.priority,
-            reason: schedule.reason,
-            deadlineUrgency: schedule.decay.urgency?.urgencyTier.label ?? null
-          });
-        }
-      }
-    }
-    allResults.sort((a, b) => {
-      const rankDiff = priorityRank[b.priority] - priorityRank[a.priority];
-      if (rankDiff !== 0) {
-        return rankDiff;
-      }
-      return b.daysSinceScoring - a.daysSinceScoring;
-    });
     const results = allResults.slice(0, maxResults);
-    const projectGroups = /* @__PURE__ */ new Map();
-    for (const r of allResults) {
-      projectGroups.set(
-        r.projectName,
-        (projectGroups.get(r.projectName) || 0) + 1
-      );
-    }
     return {
       beliefs: results,
-      summary: {
-        total: allResults.length,
-        critical: allResults.filter((r) => r.priority === "critical").length,
-        high: allResults.filter((r) => r.priority === "high").length,
-        medium: allResults.filter((r) => r.priority === "medium").length,
-        projectsAffected: projectGroups.size,
-        forecastsApproaching: allResults.filter(
-          (r) => r.temporalNature === "forecast" && r.deadlineUrgency && r.deadlineUrgency !== "distant"
-        ).length,
-        byProject: Array.from(projectGroups.entries()).map(([name, count]) => ({
-          projectName: name,
-          count
-        }))
-      }
+      summary: summarizeGlobalHealthResults(allResults)
     };
   }
 });
+async function listGraphPrimitiveTopics(ctx) {
+  return await resolveGraphPrimitivesAppResolvers().listTopics(ctx);
+}
+async function collectGlobalHealthResults(ctx, accessibleProjects, minRank) {
+  const results = [];
+  for (const project of accessibleProjects) {
+    results.push(...await collectProjectHealthResults(ctx, project, minRank));
+  }
+  return results;
+}
+async function collectProjectHealthResults(ctx, project, minRank) {
+  const scope = await resolveHealthProjectScope(ctx, project);
+  if (!scope) {
+    return [];
+  }
+  const beliefs = await readActiveTopicBeliefs(ctx, scope.topicId);
+  return beliefs.flatMap(
+    (belief) => buildGlobalHealthResult(project, belief, minRank)
+  );
+}
+async function resolveHealthProjectScope(ctx, project) {
+  try {
+    return await resolveTopicProjectScope(ctx, {
+      projectId: String(project._id)
+    });
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[beliefDecay] Failed to resolve project scope in health query",
+      {
+        error,
+        projectId: String(project._id)
+      }
+    );
+    return null;
+  }
+}
+async function readActiveTopicBeliefs(ctx, topicId) {
+  const beliefs = readRowList(
+    await ctx.db.query("epistemicNodes").withIndex(
+      "by_topic_type",
+      (q) => q.eq("topicId", topicId).eq("nodeType", "belief")
+    ).collect(),
+    readBeliefRecord
+  );
+  return beliefs.filter((belief) => belief.status === "active");
+}
+function buildGlobalHealthResult(project, belief, minRank) {
+  const metadata = belief.metadata ?? {};
+  const predictionMeta = belief.predictionMeta ?? void 0;
+  const temporalNature = normalizeTemporalNature(belief.temporalNature);
+  const confidence = belief.confidence ?? metadata.confidence ?? 0.5;
+  const lastScoredAt = belief.updatedAt ?? belief.createdAt ?? belief._creationTime ?? Date.now();
+  const schedule = getRescoringSchedule({
+    lastScoredAt,
+    temporalNature,
+    expectedBy: predictionMeta?.expectedBy ?? null,
+    predictionMeta: predictionMeta ?? null,
+    confidence,
+    beliefStatus: belief.beliefStatus ?? metadata.beliefStatus ?? null
+  });
+  if (PRIORITY_RANK[schedule.priority] < minRank) {
+    return [];
+  }
+  return [
+    {
+      projectId: project._id,
+      projectName: project.name,
+      beliefId: belief._id,
+      beliefText: belief.canonicalText,
+      confidence,
+      temporalNature,
+      expectedBy: predictionMeta?.expectedBy ?? null,
+      daysSinceScoring: Math.round(schedule.decay.ageDays),
+      priority: schedule.priority,
+      reason: schedule.reason,
+      deadlineUrgency: schedule.decay.urgency?.urgencyTier.label ?? null
+    }
+  ];
+}
+function normalizeTemporalNature(value) {
+  return value === "forecast" || value === "factual" ? value : "unknown";
+}
+function sortGlobalHealthResults(results) {
+  return [...results].sort((a, b) => {
+    const rankDiff = PRIORITY_RANK[b.priority] - PRIORITY_RANK[a.priority];
+    if (rankDiff !== 0) {
+      return rankDiff;
+    }
+    return b.daysSinceScoring - a.daysSinceScoring;
+  });
+}
+function summarizeGlobalHealthResults(allResults) {
+  const projectGroups = /* @__PURE__ */ new Map();
+  for (const result of allResults) {
+    projectGroups.set(
+      result.projectName,
+      (projectGroups.get(result.projectName) || 0) + 1
+    );
+  }
+  return {
+    total: allResults.length,
+    critical: allResults.filter((result) => result.priority === "critical").length,
+    high: allResults.filter((result) => result.priority === "high").length,
+    medium: allResults.filter((result) => result.priority === "medium").length,
+    projectsAffected: projectGroups.size,
+    forecastsApproaching: allResults.filter(isApproachingForecast).length,
+    byProject: Array.from(projectGroups.entries()).map(
+      ([projectName, count]) => ({
+        projectName,
+        count
+      })
+    )
+  };
+}
+function isApproachingForecast(result) {
+  return result.temporalNature === "forecast" && result.deadlineUrgency !== null && result.deadlineUrgency !== "distant";
+}
 var getBeliefDecayInfo = query({
   args: {
     beliefId: v.id("epistemicNodes")
@@ -861,14 +989,20 @@ var getBeliefDecayInfo = query({
     if (!belief) {
       return null;
     }
-    const beliefRecord = belief;
+    const beliefRecord = readBeliefRecord(belief);
+    if (!beliefRecord) {
+      return null;
+    }
     const metadata = beliefRecord.metadata ?? {};
     const predictionMeta = beliefRecord.predictionMeta ?? void 0;
     const temporalNature = beliefRecord.temporalNature === "forecast" || beliefRecord.temporalNature === "factual" ? beliefRecord.temporalNature : "unknown";
-    const confidenceHistory = await ctx.db.query("beliefConfidence").withIndex(
-      "by_beliefId",
-      (q) => q.eq("beliefId", args.beliefId)
-    ).collect();
+    const confidenceHistory = readRowList(
+      await ctx.db.query("beliefConfidence").withIndex(
+        "by_beliefId",
+        (q) => q.eq("beliefId", args.beliefId)
+      ).collect(),
+      readConfidenceEntry
+    );
     const sorted = confidenceHistory.sort(
       (a, b) => b.assessedAt - a.assessedAt
     );