@lucern/graph-primitives 1.0.0 → 1.0.1

package/dist/epistemicBeliefs.admin.js

@@ -0,0 +1,745 @@
+import { v } from 'convex/values';
+import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
+import { componentsGeneric, anyApi, mutationGeneric, queryGeneric } from 'convex/server';
+import { normalizeTupleContradictionPolicy } from '@lucern/confidence';
+import { checkProjectAccess } from '@lucern/access-control/access';
+import '@lucern/access-control/audience';
+import { getCurrentUserId } from '@lucern/access-control/auth';
+import '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
+
+// src/epistemicBeliefs.admin.ts
+var api = anyApi;
+componentsGeneric();
+var internal = anyApi;
+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 ?? {});
+}
+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 DEFAULT_PROJECT_BELIEF_LIMIT = 250;
+var MAX_PROJECT_BELIEF_LIMIT = 1e3;
+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 buildBeliefStatusSuccessResult() {
+  return { success: true };
+}
+function clampBeliefLimit(limit, fallback = DEFAULT_PROJECT_BELIEF_LIMIT) {
+  if (!Number.isFinite(limit)) {
+    return fallback;
+  }
+  return Math.max(
+    1,
+    Math.min(Math.floor(limit), MAX_PROJECT_BELIEF_LIMIT)
+  );
+}
+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 = typeof args?.scanLimit === "number" ? await baseQuery.order("desc").take(args.scanLimit) : await baseQuery.collect();
+  const scopedNodes = nodes.filter(
+    (node) => nodeMatchesWorkspaceReasoningScope(node, scope)
+  );
+  if (!args?.status) {
+    return scopedNodes;
+  }
+  return scopedNodes.filter((node) => node.status === args.status);
+}
+async function requireAuthenticatedUserId(ctx) {
+  const userId = await getCurrentUserId(
+    ctx
+  );
+  if (!userId) {
+    throwStructuredMutationError({
+      message: "Authentication required.",
+      status: 401,
+      code: "AUTHENTICATION_REQUIRED",
+      invariantCode: "auth.required",
+      suggestion: "Provide a valid bearer token before invoking belief mutations."
+    });
+  }
+  return userId;
+}
+async function requireProjectWriteAccess(ctx, projectId, userId) {
+  const hasAccess = await checkProjectAccess(
+    ctx,
+    projectId,
+    userId
+  );
+  if (!hasAccess) {
+    throwStructuredMutationError({
+      message: "Project access required.",
+      status: 403,
+      code: "FORBIDDEN",
+      invariantCode: "policy.scope_required",
+      suggestion: "Request write access for the project and retry.",
+      details: { projectId, userId }
+    });
+  }
+}
+
+// src/epistemicBeliefs.admin.ts
+var deleteRelationship = mutation({
+  args: {
+    edgeId: v.id("epistemicEdges"),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const now = Date.now();
+    const edge = await ctx.db.get(args.edgeId);
+    if (!edge) {
+      throw new Error("Edge not found");
+    }
+    if (!edge.projectId) {
+      throw new Error("Edge has no project scope");
+    }
+    await requireProjectWriteAccess(ctx, edge.projectId, authenticatedUserId);
+    const previousState = {
+      fromNodeId: edge.fromNodeId,
+      toNodeId: edge.toNodeId,
+      edgeType: edge.edgeType
+    };
+    await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
+      globalId: edge.globalId
+    });
+    await ctx.db.delete(args.edgeId);
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "edge",
+      entityId: edge.globalId,
+      changeType: "edge_removed",
+      previousState,
+      newState: null,
+      changedBy: authenticatedUserId,
+      isAgent: false,
+      changedAt: now,
+      projectId: edge.projectId
+    });
+    return buildBeliefStatusSuccessResult();
+  }
+});
+var updateCriticality = mutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    criticality: v.union(
+      v.literal("blocking"),
+      v.literal("important"),
+      v.literal("supporting"),
+      v.literal("essential"),
+      v.literal("nice_to_have")
+    ),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const now = Date.now();
+    const node = await ctx.db.get(args.nodeId);
+    if (!node || node.nodeType !== "belief") {
+      throw new Error("Belief not found");
+    }
+    if (!node.projectId) {
+      throw new Error("Belief has no project scope");
+    }
+    await requireProjectWriteAccess(ctx, node.projectId, authenticatedUserId);
+    const metadata = node.metadata || {};
+    const previousCriticality = metadata.criticality;
+    await ctx.db.patch(args.nodeId, {
+      metadata: {
+        ...metadata,
+        criticality: args.criticality
+      },
+      updatedAt: now
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: args.nodeId,
+      operation: "upsert"
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "belief",
+      entityId: args.nodeId,
+      changeType: "criticality_changed",
+      previousState: { criticality: previousCriticality },
+      newState: { criticality: args.criticality },
+      changedBy: authenticatedUserId,
+      isAgent: false,
+      changedAt: now,
+      projectId: node.projectId
+    });
+    return {
+      nodeId: args.nodeId,
+      previousCriticality,
+      newCriticality: args.criticality
+    };
+  }
+});
+var batchUpdateCriticality = mutation({
+  args: {
+    updates: v.array(
+      v.object({
+        beliefId: v.id("epistemicNodes"),
+        criticality: v.union(
+          v.literal("blocking"),
+          v.literal("important"),
+          v.literal("supporting"),
+          v.literal("essential"),
+          v.literal("nice_to_have")
+        ),
+        ifFalseImpact: v.optional(v.string()),
+        triagePriority: v.optional(v.number()),
+        reasoning: v.optional(v.string()),
+        dependentBeliefIds: v.optional(v.array(v.string())),
+        blockedByBeliefIds: v.optional(v.array(v.string()))
+      })
+    ),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const now = Date.now();
+    const results = [];
+    for (const update of args.updates) {
+      try {
+        const node = await ctx.db.get(update.beliefId);
+        if (!node || node.nodeType !== "belief") {
+          results.push({ beliefId: update.beliefId, success: false });
+          continue;
+        }
+        if (!node.projectId) {
+          results.push({ beliefId: update.beliefId, success: false });
+          continue;
+        }
+        await requireProjectWriteAccess(
+          ctx,
+          node.projectId,
+          authenticatedUserId
+        );
+        const metadata = node.metadata || {};
+        const previousCriticality = metadata.criticality;
+        await ctx.db.patch(node._id, {
+          metadata: {
+            ...metadata,
+            criticality: update.criticality,
+            ifFalseImpact: update.ifFalseImpact,
+            triagePriority: update.triagePriority,
+            criticalityReasoning: update.reasoning,
+            dependentBeliefIds: update.dependentBeliefIds,
+            blockedByBeliefIds: update.blockedByBeliefIds
+          },
+          updatedAt: now
+        });
+        await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+          nodeId: node._id,
+          operation: "upsert"
+        });
+        await ctx.db.insert("epistemicAudit", {
+          entityType: "belief",
+          entityId: node._id,
+          changeType: "criticality_changed",
+          previousState: { criticality: previousCriticality },
+          newState: { criticality: update.criticality },
+          changedBy: authenticatedUserId,
+          isAgent: false,
+          changedAt: now,
+          projectId: node.projectId
+        });
+        const result = {};
+        result.beliefId = update.beliefId;
+        result.nodeId = node._id;
+        result.success = true;
+        results.push(result);
+      } catch (error) {
+        debugGraphPrimitiveFallback(
+          "[epistemicBeliefs] Failed to update belief criticality",
+          {
+            error,
+            beliefId: update.beliefId
+          }
+        );
+        const result = {};
+        result.beliefId = update.beliefId;
+        result.success = false;
+        results.push(result);
+      }
+    }
+    return { results, updatedCount: results.filter((r) => r.success).length };
+  }
+});
+var getByCriticality = query({
+  args: {
+    ...optionalBeliefScopeArgs,
+    criticality: v.union(
+      v.literal("blocking"),
+      v.literal("important"),
+      v.literal("supporting"),
+      v.literal("essential"),
+      v.literal("nice_to_have")
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const scope = await resolveBeliefScopeOrNull(ctx, args);
+    if (!scope) {
+      return [];
+    }
+    const nodes = await getBeliefNodesForScope(ctx, scope);
+    return nodes.filter((n) => {
+      const metadata = n.metadata;
+      return metadata?.criticality === args.criticality && n.status === "active";
+    });
+  }
+});
+var getUnanalyzed = query({
+  args: {
+    ...optionalBeliefScopeArgs,
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const limit = args.limit || 50;
+    const scope = await resolveBeliefScopeOrNull(ctx, args);
+    if (!scope) {
+      return [];
+    }
+    const nodes = await getBeliefNodesForScope(ctx, scope);
+    const unanalyzed = nodes.filter((n) => {
+      const metadata = n.metadata;
+      return !metadata?.criticality && n.status === "active";
+    });
+    return unanalyzed.slice(0, limit);
+  }
+});
+var getByProjectSystem = query({
+  args: {
+    ...optionalBeliefScopeArgs,
+    status: v.optional(
+      v.union(
+        v.literal("active"),
+        v.literal("superseded"),
+        v.literal("archived")
+      )
+    ),
+    limit: v.optional(v.number()),
+    audienceMode: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const pageSize = clampBeliefLimit(args.limit, 500);
+    const scanLimit = Math.min(pageSize * 3, MAX_PROJECT_BELIEF_LIMIT);
+    const scope = await resolveBeliefScopeOrNull(ctx, args);
+    if (!scope) {
+      return [];
+    }
+    const nodes = await getBeliefNodesForScope(ctx, scope, { scanLimit });
+    if (args.status) {
+      return nodes.filter((n) => n.status === args.status).slice(0, pageSize);
+    }
+    return nodes.filter((n) => n.status === "active").slice(0, pageSize);
+  }
+});
+var getByPillar = query({
+  args: {
+    ...optionalBeliefScopeArgs,
+    pillar: v.union(
+      v.literal("market"),
+      v.literal("competition"),
+      v.literal("product"),
+      v.literal("team"),
+      v.literal("financials"),
+      v.literal("regulatory"),
+      v.literal("timing"),
+      v.literal("customer"),
+      v.literal("technology"),
+      v.literal("distribution"),
+      v.literal("deal"),
+      v.literal("risks"),
+      v.literal("other")
+    ),
+    status: v.optional(
+      v.union(
+        v.literal("active"),
+        v.literal("superseded"),
+        v.literal("archived")
+      )
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    if (!args.projectId && !args.topicId) {
+      return [];
+    }
+    let scope;
+    try {
+      scope = await resolveTopicProjectScope(ctx, {
+        projectId: args.projectId,
+        topicId: args.topicId
+      });
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[epistemicBeliefs] Failed to resolve criticality scope",
+        {
+          error,
+          projectId: args.projectId,
+          topicId: args.topicId
+        }
+      );
+      return [];
+    }
+    const nodes = await ctx.db.query("epistemicNodes").withIndex(
+      "by_topic_type",
+      (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
+    ).collect();
+    return nodes.filter((n) => {
+      const metadata = n.metadata;
+      const matchesPillar = metadata?.pillar === args.pillar;
+      const matchesStatus = args.status ? n.status === args.status : n.status === "active";
+      return matchesPillar && matchesStatus;
+    });
+  }
+});
+var getWorktreeCluster = query({
+  args: {
+    worktreeId: v.string(),
+    userId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const worktree = await ctx.db.get(args.worktreeId);
+    if (!worktree) {
+      return { beliefs: [], edges: [], beliefCount: 0 };
+    }
+    const clusterLinks = await ctx.db.query("worktreeBeliefCluster").withIndex("by_worktree", (q) => q.eq("worktreeId", args.worktreeId)).collect();
+    const beliefIds = new Set(clusterLinks.map((l) => String(l.beliefId)));
+    const beliefs = [];
+    for (const link of clusterLinks) {
+      const node = await ctx.db.get(link.beliefId);
+      if (node) beliefs.push(node);
+    }
+    const clusterEdges = [];
+    for (const beliefId of beliefIds) {
+      const outEdges = await ctx.db.query("epistemicEdges").filter(
+        (q) => q.eq(q.field("fromNodeId"), beliefId)
+      ).collect();
+      for (const edge of outEdges) {
+        if (beliefIds.has(String(edge.toNodeId))) {
+          clusterEdges.push({
+            fromNodeId: String(edge.fromNodeId),
+            toNodeId: String(edge.toNodeId),
+            edgeType: edge.edgeType,
+            weight: edge.weight,
+            context: edge.context
+          });
+        }
+      }
+    }
+    return {
+      beliefs,
+      edges: clusterEdges,
+      beliefCount: beliefs.length
+    };
+  }
+});
+
+export { batchUpdateCriticality, deleteRelationship, getByCriticality, getByPillar, getByProjectSystem, getUnanalyzed, getWorktreeCluster, updateCriticality };
+//# sourceMappingURL=epistemicBeliefs.admin.js.map
+//# sourceMappingURL=epistemicBeliefs.admin.js.map