@lucern/graph-primitives 1.0.0 → 1.0.1

package/dist/epistemicBeliefs.backfills.js

@@ -0,0 +1,1004 @@
+import { v } from 'convex/values';
+import { normalizeTupleContradictionPolicy, confidenceFromSL, readOpinionFromRecord, mkOpinion } from '@lucern/confidence';
+import { checkScopeAccess } from '@lucern/access-control/access';
+import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
+import { componentsGeneric, anyApi, queryGeneric, internalMutationGeneric, mutationGeneric } from 'convex/server';
+import '@lucern/access-control/audience';
+import '@lucern/access-control/auth';
+import '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
+
+// src/epistemicBeliefs.backfills.ts
+var api = anyApi;
+componentsGeneric();
+var internal = anyApi;
+var internalMutation = internalMutationGeneric;
+var mutation = mutationGeneric;
+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 debugGraphPrimitiveFallback(message, context) {
+  if (!isGraphPrimitiveDebugEnabled()) {
+    return;
+  }
+  console.debug(message, context ?? {});
+}
+
+// src/beliefLifecycle.ts
+var BELIEF_STATUS_VALUES = [
+  "assumption",
+  "hypothesis",
+  "belief",
+  "fact"
+];
+var RESOLVED_PREDICTION_OUTCOMES = [
+  "confirmed",
+  "disconfirmed",
+  "partial",
+  "expired"
+];
+function isBeliefLifecycleStatus(value) {
+  return typeof value === "string" && BELIEF_STATUS_VALUES.includes(value);
+}
+function normalizeBeliefConfidence(confidence) {
+  if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
+    return null;
+  }
+  if (confidence >= 0 && confidence <= 1) {
+    return confidence;
+  }
+  if (confidence > 1 && confidence <= 100) {
+    return confidence / 100;
+  }
+  return null;
+}
+function isResolvedByConfidence(confidence) {
+  const normalized = normalizeBeliefConfidence(confidence);
+  if (normalized === null) {
+    return false;
+  }
+  return normalized <= 0 || normalized >= 1;
+}
+function hasResolvedPredictionOutcome(predictionMeta) {
+  if (!predictionMeta || typeof predictionMeta !== "object") {
+    return false;
+  }
+  const outcome = predictionMeta.outcome;
+  return typeof outcome === "string" && RESOLVED_PREDICTION_OUTCOMES.includes(outcome);
+}
+function getPredictionMetaFromMetadata(metadata) {
+  return metadata?.predictionMeta;
+}
+function shouldTreatBeliefAsFact(opts) {
+  if (isResolvedByConfidence(opts.confidence)) {
+    return true;
+  }
+  if (hasResolvedPredictionOutcome(opts.predictionMeta)) {
+    return true;
+  }
+  if (hasResolvedPredictionOutcome(getPredictionMetaFromMetadata(opts.metadata))) {
+    return true;
+  }
+  return false;
+}
+function resolveBeliefLifecycleStatus(opts) {
+  if (shouldTreatBeliefAsFact(opts)) {
+    return "fact";
+  }
+  const direct = opts.beliefStatus;
+  if (isBeliefLifecycleStatus(direct)) {
+    const normalized = normalizeBeliefConfidence(opts.confidence);
+    if (normalized !== null && isPreValidationBeliefStatus(direct)) {
+      return "belief";
+    }
+    return direct;
+  }
+  const metaStatus = opts.metadata?.beliefStatus;
+  if (isBeliefLifecycleStatus(metaStatus)) {
+    const normalized = normalizeBeliefConfidence(opts.confidence);
+    if (normalized !== null && isPreValidationBeliefStatus(metaStatus)) {
+      return "belief";
+    }
+    return metaStatus;
+  }
+  return "assumption";
+}
+function isPreValidationBeliefStatus(status) {
+  return status === "assumption" || status === "hypothesis";
+}
+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."
+  );
+}
+var optionalScopeArgs = {
+  projectId: v.optional(v.string()),
+  topicId: v.optional(v.string())
+};
+function normalizeScopeValue2(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function nodeMatchesWorkspaceReasoningScope(node, scope) {
+  if (!node) {
+    return false;
+  }
+  const scopeTenantId = normalizeScopeValue2(scope.tenantId);
+  const scopeWorkspaceId = normalizeScopeValue2(scope.workspaceId);
+  const nodeTenantId = normalizeScopeValue2(node.tenantId);
+  const nodeWorkspaceId = normalizeScopeValue2(node.workspaceId);
+  const epistemicLayer = typeof node.epistemicLayer === "string" ? node.epistemicLayer : void 0;
+  if (scopeTenantId && nodeTenantId && scopeTenantId !== nodeTenantId) {
+    return false;
+  }
+  if (epistemicLayer === "ontological" && nodeWorkspaceId === void 0) {
+    return true;
+  }
+  if (!scopeWorkspaceId && node.publicationStatus === "published") {
+    return true;
+  }
+  if (!scopeWorkspaceId) {
+    return nodeWorkspaceId === void 0;
+  }
+  return scopeWorkspaceId === nodeWorkspaceId;
+}
+
+// src/epistemicBeliefs.helpers.ts
+v.id("epistemicNodes");
+var optionalBeliefScopeArgs = optionalScopeArgs;
+({
+  tupleContradiction: normalizeTupleContradictionPolicy()
+});
+function throwStructuredMutationError(args) {
+  const error = new Error(args.message);
+  error.status = args.status;
+  error.code = args.code;
+  error.invariantCode = args.invariantCode;
+  error.suggestion = args.suggestion;
+  error.details = args.details;
+  throw error;
+}
+function readFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function assertBaseRateInRange(baseRate, field = "baseRate") {
+  if (baseRate < 0 || baseRate > 1) {
+    throwStructuredMutationError({
+      message: `${field} must be within [0, 1].`,
+      status: 400,
+      code: "INVALID_ARGUMENT",
+      invariantCode: "request.valid_shape",
+      suggestion: `Clamp ${field} into the inclusive [0, 1] interval.`,
+      details: { field, baseRate }
+    });
+  }
+  return baseRate;
+}
+function buildBeliefConfidenceRow(args) {
+  return {
+    beliefId: args.beliefId,
+    confidence: confidenceFromSL(
+      args.belief,
+      args.disbelief,
+      args.uncertainty,
+      args.baseRate
+    ),
+    belief: args.belief,
+    disbelief: args.disbelief,
+    uncertainty: args.uncertainty,
+    baseRate: args.baseRate,
+    slOperator: args.slOperator ?? "manual_assessment",
+    trigger: args.trigger,
+    ...args.rationale ? { rationale: args.rationale } : {},
+    assessedBy: args.assessedBy,
+    assessedAt: args.assessedAt,
+    ...args.triggeringEvidenceId ? {
+      triggeringEvidenceId: args.triggeringEvidenceId,
+      triggeringEvidenceIds: [String(args.triggeringEvidenceId)]
+    } : {},
+    ...args.triggeringContradictionId ? {
+      triggeringContradictionId: args.triggeringContradictionId
+    } : {},
+    ...args.triggeringWorktreeId ? { triggeringWorktreeId: args.triggeringWorktreeId } : {}
+  };
+}
+function deriveSyntheticBackfillOpinion(source) {
+  const belief = readFiniteNumber(source.opinion_b) ?? readFiniteNumber(source.belief);
+  const disbelief = readFiniteNumber(source.opinion_d) ?? readFiniteNumber(source.disbelief);
+  const uncertainty = readFiniteNumber(source.opinion_u) ?? readFiniteNumber(source.uncertainty);
+  const baseRate = readFiniteNumber(source.opinion_a) ?? readFiniteNumber(source.baseRate);
+  if (belief !== void 0 || disbelief !== void 0 || uncertainty !== void 0 || baseRate !== void 0) {
+    try {
+      return readOpinionFromRecord(source);
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[epistemicBeliefs] Failed to decode legacy belief opinion",
+        {
+          error
+        }
+      );
+      return mkOpinion(0, 0, 1, 0.5);
+    }
+  }
+  const confidence = clamp01(readFiniteNumber(source.confidence) ?? 0);
+  return mkOpinion(confidence, 1 - confidence, 0, 0.5);
+}
+async function resolveBeliefScopeOrNull(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(
+      "[epistemicBeliefs] Failed to resolve belief scope",
+      {
+        error,
+        projectId: args.projectId,
+        topicId: args.topicId
+      }
+    );
+    return null;
+  }
+}
+async function getBeliefNodesForScope(ctx, scope, args) {
+  const baseQuery = ctx.db.query("epistemicNodes").withIndex(
+    "by_topic_type",
+    (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
+  );
+  const nodes = await baseQuery.collect();
+  const scopedNodes = nodes.filter(
+    (node) => nodeMatchesWorkspaceReasoningScope(node, scope)
+  );
+  {
+    return scopedNodes;
+  }
+}
+function resolveBeliefStatus(node, metadata) {
+  return resolveBeliefLifecycleStatus({
+    beliefStatus: node.beliefStatus,
+    confidence: node.confidence,
+    predictionMeta: node.predictionMeta,
+    metadata
+  });
+}
+
+// src/epistemicBeliefs.backfills.ts
+var getRecentConfidenceChanges = query({
+  args: {
+    ...optionalBeliefScopeArgs,
+    userId: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 10;
+    const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+    const scope = await resolveBeliefScopeOrNull(ctx, args);
+    if (!scope) {
+      return [];
+    }
+    const scopeId = scope.topicId ? String(scope.topicId) : scope.projectId;
+    if (!scopeId || !await checkScopeAccess(ctx, scopeId, args.userId)) {
+      return [];
+    }
+    const projectBeliefs = await getBeliefNodesForScope(ctx, scope);
+    if (projectBeliefs.length === 0) {
+      return [];
+    }
+    const beliefMap = /* @__PURE__ */ new Map();
+    for (const belief of projectBeliefs) {
+      const info = {
+        id: belief._id,
+        title: belief.canonicalText || belief.title || "Untitled belief",
+        currentConfidence: belief.confidence ?? 0.5
+      };
+      beliefMap.set(belief._id, info);
+    }
+    const recentConfidence = await ctx.db.query("beliefConfidence").order("desc").filter((q) => q.gt(q.field("assessedAt"), sevenDaysAgo)).take(200);
+    const changes = [];
+    const seenBeliefs = /* @__PURE__ */ new Set();
+    for (const entry of recentConfidence) {
+      const beliefInfo = beliefMap.get(entry.beliefId);
+      if (!beliefInfo) {
+        continue;
+      }
+      if (seenBeliefs.has(beliefInfo.id)) {
+        continue;
+      }
+      seenBeliefs.add(beliefInfo.id);
+      const previousEntries = await ctx.db.query("beliefConfidence").withIndex("by_beliefId", (q) => q.eq("beliefId", entry.beliefId)).order("desc").filter((q) => q.lt(q.field("assessedAt"), entry.assessedAt)).take(1);
+      const previousConfidence = previousEntries[0]?.confidence ?? 0.5;
+      const delta = entry.confidence - previousConfidence;
+      if (Math.abs(delta) < 0.05) {
+        continue;
+      }
+      changes.push({
+        beliefId: beliefInfo.id,
+        beliefTitle: beliefInfo.title,
+        delta,
+        trigger: entry.trigger,
+        assessedBy: entry.assessedBy,
+        assessedAt: entry.assessedAt
+      });
+      if (changes.length >= limit) {
+        break;
+      }
+    }
+    return changes;
+  }
+});
+var backfillSyntheticOpinionHistory = internalMutation({
+  args: {
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const limit = Math.max(1, Math.min(args.limit ?? 100, 100));
+    const [beliefNodes, existingHistory] = await Promise.all([
+      ctx.db.query("epistemicNodes").withIndex("by_nodeType", (q) => q.eq("nodeType", "belief")).collect(),
+      ctx.db.query("beliefConfidence").collect()
+    ]);
+    const beliefsWithHistory = new Set(
+      existingHistory.map((entry) => String(entry.beliefId))
+    );
+    let inserted = 0;
+    let skippedNoOpinion = 0;
+    let skippedHasHistory = 0;
+    for (const node of beliefNodes) {
+      if (inserted >= limit) {
+        break;
+      }
+      const hasOpinionSnapshot = readFiniteNumber(node.opinion_b) !== void 0 || readFiniteNumber(node.opinion_d) !== void 0 || readFiniteNumber(node.opinion_u) !== void 0 || readFiniteNumber(node.opinion_a) !== void 0 || readFiniteNumber(node.confidence) !== void 0;
+      if (!hasOpinionSnapshot) {
+        skippedNoOpinion++;
+        continue;
+      }
+      if (beliefsWithHistory.has(String(node._id))) {
+        skippedHasHistory++;
+        continue;
+      }
+      const opinion = deriveSyntheticBackfillOpinion(
+        node
+      );
+      await ctx.db.insert(
+        "beliefConfidence",
+        buildBeliefConfidenceRow({
+          beliefId: node._id,
+          belief: opinion.b,
+          disbelief: opinion.d,
+          uncertainty: opinion.u,
+          baseRate: opinion.a,
+          trigger: "backfill_synthetic",
+          rationale: "LK-6 backfill: synthesized t0 from node-level opinion fields (no prior beliefConfidence row found).",
+          assessedAt: readFiniteNumber(node.createdAt) ?? readFiniteNumber(node.updatedAt) ?? Date.now(),
+          assessedBy: "system:lk-6-backfill",
+          slOperator: "manual_assessment"
+        })
+      );
+      beliefsWithHistory.add(String(node._id));
+      inserted++;
+    }
+    const remainingCandidates = beliefNodes.filter((node) => {
+      const hasOpinionSnapshot = readFiniteNumber(node.opinion_b) !== void 0 || readFiniteNumber(node.opinion_d) !== void 0 || readFiniteNumber(node.opinion_u) !== void 0 || readFiniteNumber(node.opinion_a) !== void 0 || readFiniteNumber(node.confidence) !== void 0;
+      return hasOpinionSnapshot && !beliefsWithHistory.has(String(node._id));
+    }).length;
+    return {
+      scanned: beliefNodes.length,
+      inserted,
+      skippedNoOpinion,
+      skippedHasHistory,
+      remainingCandidates,
+      hasMore: remainingCandidates > 0
+    };
+  }
+});
+var backfillMandatoryPriors = internalMutation({
+  args: {
+    limit: v.optional(v.number()),
+    defaultBaseRate: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const limit = Math.max(1, Math.min(args.limit ?? 100, 1e3));
+    const defaultBaseRate = assertBaseRateInRange(
+      args.defaultBaseRate ?? 0.5,
+      "defaultBaseRate"
+    );
+    const [beliefNodes, historyRows] = await Promise.all([
+      ctx.db.query("epistemicNodes").withIndex("by_nodeType", (q) => q.eq("nodeType", "belief")).collect(),
+      ctx.db.query("beliefConfidence").collect()
+    ]);
+    const historyByBeliefId = /* @__PURE__ */ new Map();
+    for (const row of historyRows) {
+      const beliefId = String(row.beliefId);
+      const entries = historyByBeliefId.get(beliefId) ?? [];
+      entries.push(row);
+      historyByBeliefId.set(beliefId, entries);
+    }
+    let touched = 0;
+    let patchedNodes = 0;
+    let patchedHistoryRows = 0;
+    let insertedInitialRows = 0;
+    let auditEntries = 0;
+    for (const node of beliefNodes) {
+      if (touched >= limit) {
+        break;
+      }
+      const beliefId = String(node._id);
+      const history = historyByBeliefId.get(beliefId) ?? [];
+      const patchedOpinion = {
+        belief: readFiniteNumber(node.opinion_b) ?? 0,
+        disbelief: readFiniteNumber(node.opinion_d) ?? 0,
+        uncertainty: readFiniteNumber(node.opinion_u) ?? 1,
+        baseRate: readFiniteNumber(node.opinion_a) ?? defaultBaseRate
+      };
+      const needsNodePatch = readFiniteNumber(node.opinion_b) === void 0 || readFiniteNumber(node.opinion_d) === void 0 || readFiniteNumber(node.opinion_u) === void 0 || readFiniteNumber(node.opinion_a) === void 0;
+      const rowsMissingBaseRate = history.filter(
+        (row) => readFiniteNumber(row.baseRate) === void 0
+      );
+      const needsInitialRow = history.length === 0;
+      if (!needsNodePatch && rowsMissingBaseRate.length === 0 && !needsInitialRow) {
+        continue;
+      }
+      if (needsNodePatch) {
+        await ctx.db.patch(node._id, {
+          opinion_b: patchedOpinion.belief,
+          opinion_d: patchedOpinion.disbelief,
+          opinion_u: patchedOpinion.uncertainty,
+          opinion_a: patchedOpinion.baseRate,
+          updatedAt: Date.now()
+        });
+        patchedNodes++;
+      }
+      for (const row of rowsMissingBaseRate) {
+        const belief = readFiniteNumber(row.belief) ?? 0;
+        const disbelief = readFiniteNumber(row.disbelief) ?? 0;
+        const uncertainty = readFiniteNumber(row.uncertainty) ?? 1;
+        await ctx.db.patch(row._id, {
+          baseRate: defaultBaseRate,
+          confidence: confidenceFromSL(
+            belief,
+            disbelief,
+            uncertainty,
+            defaultBaseRate
+          )
+        });
+        patchedHistoryRows++;
+      }
+      if (needsInitialRow) {
+        await ctx.db.insert(
+          "beliefConfidence",
+          buildBeliefConfidenceRow({
+            beliefId: node._id,
+            belief: patchedOpinion.belief,
+            disbelief: patchedOpinion.disbelief,
+            uncertainty: patchedOpinion.uncertainty,
+            baseRate: patchedOpinion.baseRate,
+            trigger: "initial",
+            rationale: "LKC-2 backfill: inserted missing initial vacuous opinion with neutral prior.",
+            assessedAt: readFiniteNumber(node.createdAt) ?? readFiniteNumber(node.updatedAt) ?? Date.now(),
+            assessedBy: "system:lkc-2-prior-backfill",
+            slOperator: "manual_assessment"
+          })
+        );
+        insertedInitialRows++;
+      }
+      await ctx.db.insert("epistemicAudit", {
+        entityType: "belief",
+        entityId: beliefId,
+        changeType: "updated",
+        changedAt: Date.now(),
+        changedBy: "system:lkc-2-prior-backfill",
+        isAgent: false,
+        previousState: null,
+        newState: {
+          baseRateBackfilled: true,
+          baseRate: defaultBaseRate,
+          patchedNodeOpinion: needsNodePatch,
+          patchedHistoryRows: rowsMissingBaseRate.length,
+          insertedInitialOpinion: needsInitialRow
+        },
+        projectId: node.projectId,
+        topicId: typeof node.topicId === "string" ? node.topicId : void 0
+      });
+      auditEntries++;
+      touched++;
+    }
+    return {
+      scanned: beliefNodes.length,
+      patchedNodes,
+      patchedHistoryRows,
+      insertedInitialRows,
+      auditEntries,
+      hasMore: touched >= limit
+    };
+  }
+});
+var backfillTwoAxisConfidence = internalMutation({
+  args: {
+    dryRun: v.optional(v.boolean())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const dryRun = args.dryRun ?? false;
+    const allConfRecords = await ctx.db.query("beliefConfidence").collect();
+    let confUpdated = 0;
+    let confSkipped = 0;
+    for (const record of allConfRecords) {
+      if (record.valence !== void 0 && record.certainty !== void 0) {
+        confSkipped++;
+        continue;
+      }
+      const conf = record.confidence ?? 0.5;
+      const valence = Math.round((conf * 2 - 1) * 100) / 100;
+      const certainty = Math.round(Math.abs(conf - 0.5) * 2 * 100) / 100;
+      if (!dryRun) {
+        await ctx.db.patch(record._id, { valence, certainty });
+      }
+      confUpdated++;
+    }
+    const allBeliefNodes = await ctx.db.query("epistemicNodes").filter((q) => q.eq(q.field("nodeType"), "belief")).collect();
+    let nodesUpdated = 0;
+    let nodesSkipped = 0;
+    for (const node of allBeliefNodes) {
+      const meta = node.metadata || {};
+      if (meta.valence !== void 0 && meta.certainty !== void 0) {
+        nodesSkipped++;
+        continue;
+      }
+      const conf = node.confidence ?? 0.5;
+      const valence = Math.round((conf * 2 - 1) * 100) / 100;
+      const certainty = Math.round(Math.abs(conf - 0.5) * 2 * 100) / 100;
+      if (!dryRun) {
+        await ctx.db.patch(node._id, {
+          metadata: { ...meta, valence, certainty }
+        });
+      }
+      nodesUpdated++;
+    }
+    return {
+      dryRun,
+      beliefConfidence: {
+        updated: confUpdated,
+        skipped: confSkipped,
+        total: allConfRecords.length
+      },
+      epistemicNodes: {
+        updated: nodesUpdated,
+        skipped: nodesSkipped,
+        total: allBeliefNodes.length
+      }
+    };
+  }
+});
+var backfillScoredBeliefEdges = internalMutation({
+  args: {
+    ...optionalBeliefScopeArgs,
+    dryRun: v.optional(v.boolean())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const dryRun = args.dryRun ?? false;
+    const allBeliefs = await ctx.db.query("epistemicNodes").withIndex(
+      "by_topic",
+      (q) => q.eq("topicId", args.topicId || args.projectId)
+    ).filter((q) => q.eq(q.field("nodeType"), "belief")).collect();
+    const scoredBeliefs = allBeliefs.filter((belief) => {
+      const metadata = belief.metadata || {};
+      const lifecycle = resolveBeliefStatus(belief, metadata);
+      return lifecycle === "belief" || lifecycle === "fact";
+    });
+    const themeNodes = await ctx.db.query("epistemicNodes").withIndex(
+      "by_topic",
+      (q) => q.eq("topicId", args.topicId || args.projectId)
+    ).filter((q) => q.eq(q.field("nodeType"), "theme")).collect();
+    let created = 0;
+    let skipped = 0;
+    for (const belief of scoredBeliefs) {
+      if (!belief.globalId) {
+        skipped++;
+        continue;
+      }
+      for (const theme of themeNodes) {
+        if (!theme.globalId) {
+          continue;
+        }
+        const edgeGlobalId = `edge-${belief.globalId}-relates_to_thesis-${theme.globalId}`;
+        const existing = await ctx.db.query("epistemicEdges").filter((q) => q.eq(q.field("globalId"), edgeGlobalId)).first();
+        if (existing) {
+          skipped++;
+          continue;
+        }
+        if (!dryRun) {
+          await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
+            globalId: edgeGlobalId,
+            fromGlobalId: belief.globalId,
+            toGlobalId: theme.globalId,
+            edgeType: "relates_to_thesis",
+            weight: belief.confidence ?? 0.5,
+            createdBy: "backfill:scored_belief_theme",
+            topicId: String(args.projectId),
+            fromNodeType: "belief",
+            toNodeType: "theme",
+            fromLayer: "L3",
+            toLayer: "L3"
+          });
+        }
+        created++;
+      }
+    }
+    return {
+      dryRun,
+      scoredBeliefs: scoredBeliefs.length,
+      themeNodes: themeNodes.length,
+      edgesCreated: created,
+      edgesSkipped: skipped
+    };
+  }
+});
+var backfillBeliefSprintIds = internalMutation({
+  args: {
+    ...optionalBeliefScopeArgs,
+    dryRun: v.optional(v.boolean())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, _args) => {
+    return {
+      dryRun: true,
+      message: "backfillBeliefSprintIds removed \u2014 sprints are D-tier legacy. Use worktrees.",
+      sprintsScanned: 0,
+      beliefsWithSprints: 0,
+      updated: 0,
+      skipped: 0
+    };
+  }
+});
+var getBeliefClusterPositions = query({
+  args: {
+    ...optionalBeliefScopeArgs,
+    userId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const scope = await resolveBeliefScopeOrNull(ctx, args);
+    if (!scope || !scope.projectId) {
+      return {
+        positions: {},
+        hasClusters: false,
+        counts: {
+          raw: 0,
+          hypothesis: 0,
+          conditional: 0,
+          unprocessed: 0,
+          total: 0
+        }
+      };
+    }
+    const allBeliefNodes = await getBeliefNodesForScope(ctx, scope);
+    const clusteredBeliefIds = /* @__PURE__ */ new Set();
+    for (const node of allBeliefNodes) {
+      const links = await ctx.db.query("worktreeBeliefCluster").withIndex("by_belief", (q) => q.eq("beliefId", node._id)).first();
+      if (links) {
+        clusteredBeliefIds.add(String(node._id));
+      }
+    }
+    const positions = {};
+    for (const node of allBeliefNodes) {
+      const id = String(node._id);
+      positions[id] = clusteredBeliefIds.has(id) ? "hypothesis" : "unprocessed";
+    }
+    const unprocessedCount = allBeliefNodes.length - clusteredBeliefIds.size;
+    return {
+      positions,
+      hasClusters: clusteredBeliefIds.size > 0,
+      counts: {
+        raw: 0,
+        hypothesis: clusteredBeliefIds.size,
+        conditional: 0,
+        unprocessed: unprocessedCount,
+        total: allBeliefNodes.length
+      }
+    };
+  }
+});
+var reassignBeliefsTopic = mutation({
+  args: {
+    beliefNodeIds: v.array(v.id("epistemicNodes")),
+    targetTopicId: v.string(),
+    reason: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const targetTopic = await ctx.db.get(args.targetTopicId);
+    if (!targetTopic) {
+      throw new Error(`Target topic not found: ${args.targetTopicId}`);
+    }
+    let reassigned = 0;
+    let skipped = 0;
+    const now = Date.now();
+    const movedBeliefIds = /* @__PURE__ */ new Set();
+    for (const beliefNodeId of args.beliefNodeIds) {
+      const node = await ctx.db.get(beliefNodeId);
+      if (!node || node.nodeType !== "belief") {
+        skipped++;
+        continue;
+      }
+      await ctx.db.patch(beliefNodeId, {
+        topicId: args.targetTopicId,
+        updatedAt: now
+      });
+      movedBeliefIds.add(String(beliefNodeId));
+      reassigned++;
+    }
+    let connectedReassigned = 0;
+    const alreadyReassigned = /* @__PURE__ */ new Set();
+    for (const beliefId of movedBeliefIds) {
+      const outbound = await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", beliefId)).collect();
+      const inbound = await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", beliefId)).collect();
+      const connectedNodeIds = /* @__PURE__ */ new Set();
+      for (const edge of outbound) {
+        if (edge.toNodeId) connectedNodeIds.add(String(edge.toNodeId));
+      }
+      for (const edge of inbound) {
+        if (edge.fromNodeId) connectedNodeIds.add(String(edge.fromNodeId));
+      }
+      for (const connectedId of connectedNodeIds) {
+        if (movedBeliefIds.has(connectedId) || alreadyReassigned.has(connectedId)) {
+          continue;
+        }
+        try {
+          const connectedNode = await ctx.db.get(connectedId);
+          if (!connectedNode || connectedNode.status !== "active") continue;
+          if (connectedNode.topicId && String(connectedNode.topicId) !== String(args.targetTopicId)) {
+            await ctx.db.patch(connectedId, {
+              topicId: args.targetTopicId,
+              updatedAt: now
+            });
+            alreadyReassigned.add(connectedId);
+            connectedReassigned++;
+          }
+        } catch (error) {
+          debugGraphPrimitiveFallback(
+            "[epistemicBeliefs] Failed to reassign connected node",
+            {
+              error,
+              connectedId
+            }
+          );
+        }
+      }
+    }
+    return { reassigned, skipped, connectedReassigned };
+  }
+});
+
+export { backfillBeliefSprintIds, backfillMandatoryPriors, backfillScoredBeliefEdges, backfillSyntheticOpinionHistory, backfillTwoAxisConfidence, getBeliefClusterPositions, getRecentConfidenceChanges, reassignBeliefsTopic };
+//# sourceMappingURL=epistemicBeliefs.backfills.js.map
+//# sourceMappingURL=epistemicBeliefs.backfills.js.map