@lucern/graph-primitives 1.0.0 → 1.0.1

package/dist/epistemicBeliefs.links.js

@@ -0,0 +1,761 @@
+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';
+
+// src/epistemicBeliefs.links.ts
+var api = anyApi;
+componentsGeneric();
+var internal = anyApi;
+var mutation = mutationGeneric;
+var query = queryGeneric;
+
+// src/globalId.ts
+function generateGlobalId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(
+    ""
+  );
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// src/logicalRoleInference.ts
+var PILLAR_IMPORTANCE = {
+  market: 1,
+  competition: 2,
+  product: 3,
+  team: 4,
+  financials: 5,
+  timing: 6,
+  other: 10
+};
+async function computeLogicalRole(ctx, evidenceId, beliefId) {
+  const belief = await ctx.db.get(beliefId);
+  if (!belief || belief.nodeType !== "belief") {
+    return "contributory";
+  }
+  const beliefMetadata = belief.metadata;
+  const pillar = beliefMetadata?.pillar || "other";
+  const pillarRank = PILLAR_IMPORTANCE[pillar] ?? 10;
+  const isSynthesized = await checkIfSynthesizedHypothesis(ctx, beliefId);
+  const testingQuestions = await getTestingQuestionsForBelief(ctx, beliefId);
+  const answeredQuestions = await getQuestionsAnsweredByEvidence(
+    ctx,
+    evidenceId
+  );
+  const directlyTests = testingQuestions.filter(
+    (questionId) => answeredQuestions.includes(questionId)
+  );
+  if (directlyTests.length === 0) {
+    return "contributory";
+  }
+  if (isSynthesized && pillarRank <= 2) {
+    return directlyTests.length > 1 ? "necessary_sufficient" : "necessary";
+  }
+  if (isSynthesized) {
+    return "necessary";
+  }
+  return directlyTests.length > 1 ? "necessary" : "contributory";
+}
+async function checkIfSynthesizedHypothesis(ctx, beliefId) {
+  const belief = await ctx.db.get(beliefId);
+  if (!belief) {
+    return false;
+  }
+  const metadata = belief.metadata;
+  return metadata?.isSynthesized === true || metadata?.beliefStatus === "hypothesis";
+}
+async function getTestingQuestionsForBelief(ctx, beliefId) {
+  const testEdges = await ctx.db.query("epistemicEdges").withIndex(
+    "by_to_type",
+    (q) => q.eq("toNodeId", beliefId).eq("edgeType", "tests")
+  ).collect();
+  return testEdges.map((edge) => edge.fromNodeId).filter((id) => id !== void 0);
+}
+async function getQuestionsAnsweredByEvidence(ctx, evidenceId) {
+  const answerEdges = await ctx.db.query("epistemicEdges").withIndex(
+    "by_from_type",
+    (q) => q.eq("fromNodeId", evidenceId).eq("edgeType", "derived_from")
+  ).collect();
+  return answerEdges.map((edge) => edge.toNodeId).filter((id) => id !== void 0);
+}
+
+// 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())
+};
+
+// src/epistemicBeliefs.helpers.ts
+var insightIdUnion = 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 buildBeliefStatusSuccessResult() {
+  return { success: true };
+}
+function buildBeliefEvidenceNotFoundResult() {
+  const result = {};
+  result.success = false;
+  result.message = "Evidence node not found";
+  return result;
+}
+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 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.links.ts
+var updatePillar = mutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    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")
+    ),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const now = Date.now();
+    const existingNode = await ctx.db.get(args.nodeId);
+    if (!existingNode || existingNode.nodeType !== "belief") {
+      throw new Error("Belief not found");
+    }
+    if (!existingNode.projectId) {
+      throw new Error("Belief has no project scope");
+    }
+    await requireProjectWriteAccess(
+      ctx,
+      existingNode.projectId,
+      authenticatedUserId
+    );
+    let previousPillar = null;
+    const metadata = existingNode.metadata || {};
+    previousPillar = metadata.pillar;
+    await ctx.db.patch(args.nodeId, {
+      metadata: {
+        ...metadata,
+        pillar: args.pillar,
+        topic: args.pillar
+      },
+      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: "pillar_changed",
+      projectId: existingNode.projectId,
+      changedBy: authenticatedUserId,
+      changedAt: now,
+      isAgent: false,
+      previousState: { pillar: previousPillar },
+      newState: { pillar: args.pillar }
+    });
+    return {
+      nodeId: args.nodeId,
+      previousPillar,
+      newPillar: args.pillar
+    };
+  }
+});
+var getCountByStatus = query({
+  args: {
+    ...optionalBeliefScopeArgs
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const scope = await resolveBeliefScopeOrNull(ctx, args);
+    if (!scope) {
+      return { active: 0, superseded: 0, archived: 0, total: 0 };
+    }
+    const nodes = await ctx.db.query("epistemicNodes").withIndex(
+      "by_topic_type",
+      (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
+    ).collect();
+    const counts = {
+      active: 0,
+      superseded: 0,
+      archived: 0,
+      total: nodes.length
+    };
+    for (const node of nodes) {
+      if (node.status === "active") {
+        counts.active++;
+      } else if (node.status === "superseded") {
+        counts.superseded++;
+      } else if (node.status === "archived") {
+        counts.archived++;
+      }
+    }
+    return counts;
+  }
+});
+var linkBeliefs = mutation({
+  args: {
+    fromNodeId: v.id("epistemicNodes"),
+    toNodeId: v.id("epistemicNodes"),
+    edgeType: v.union(
+      // Basic belief relationships
+      v.literal("supersedes"),
+      v.literal("depends_on"),
+      v.literal("supports"),
+      v.literal("contains"),
+      v.literal("informs"),
+      v.literal("derived_from"),
+      v.literal("tests")
+    ),
+    weight: v.optional(v.number()),
+    // -1 to 1
+    context: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const fromNode = await ctx.db.get(args.fromNodeId);
+    const toNode = await ctx.db.get(args.toNodeId);
+    if (!fromNode || !toNode) {
+      throw new Error("One or both belief nodes not found");
+    }
+    if (fromNode.nodeType !== "belief" || toNode.nodeType !== "belief") {
+      throw new Error("Both nodes must be beliefs");
+    }
+    if (fromNode.projectId !== toNode.projectId) {
+      throw new Error("Cannot link beliefs across different projects");
+    }
+    if (!fromNode.projectId) {
+      throw new Error("Belief has no project scope");
+    }
+    await requireProjectWriteAccess(
+      ctx,
+      fromNode.projectId,
+      authenticatedUserId
+    );
+    const now = Date.now();
+    const edgeGlobalId = generateGlobalId();
+    await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
+      globalId: edgeGlobalId,
+      fromGlobalId: fromNode.globalId,
+      toGlobalId: toNode.globalId,
+      edgeType: args.edgeType,
+      weight: args.weight ?? 1,
+      context: args.context,
+      createdBy: authenticatedUserId,
+      topicId: fromNode.projectId ? String(fromNode.projectId) : void 0,
+      fromNodeType: "belief",
+      toNodeType: "belief"
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "edge",
+      entityId: edgeGlobalId,
+      changeType: "created",
+      previousState: null,
+      newState: {
+        fromNodeId: args.fromNodeId,
+        toNodeId: args.toNodeId,
+        edgeType: args.edgeType
+      },
+      changedBy: authenticatedUserId,
+      isAgent: false,
+      changedAt: now,
+      projectId: fromNode.projectId
+    });
+    return { edgeGlobalId, created: true };
+  }
+});
+var linkEvidence = mutation({
+  args: {
+    beliefNodeId: v.id("epistemicNodes"),
+    insightId: insightIdUnion,
+    type: v.union(v.literal("supporting"), v.literal("contradicting")),
+    rationale: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const belief = await ctx.db.get(args.beliefNodeId);
+    if (!belief || belief.nodeType !== "belief") {
+      throw new Error("Belief not found");
+    }
+    if (!belief.projectId) {
+      throw new Error("Belief has no project scope");
+    }
+    await requireProjectWriteAccess(ctx, belief.projectId, authenticatedUserId);
+    const insight = await ctx.db.get(args.insightId);
+    if (!insight || insight.nodeType !== "evidence") {
+      throw new Error("Insight not found");
+    }
+    if ("projectId" in insight && insight.projectId && insight.projectId !== belief.projectId) {
+      throw new Error("Insight belongs to a different project");
+    }
+    const evidenceNodeId = insight._id;
+    const evidenceGlobalId = insight.globalId;
+    const edgeType = "informs";
+    const weight = args.type === "supporting" ? 1 : -1;
+    const logicalRole = evidenceNodeId ? await computeLogicalRole(ctx, evidenceNodeId, args.beliefNodeId) : "contributory";
+    const edgeGlobalId = generateGlobalId();
+    await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
+      globalId: edgeGlobalId,
+      fromGlobalId: evidenceGlobalId,
+      toGlobalId: belief.globalId,
+      edgeType,
+      weight,
+      context: args.rationale || `${args.type} evidence`,
+      createdBy: authenticatedUserId,
+      topicId: belief.projectId ? String(belief.projectId) : void 0,
+      fromNodeType: "evidence",
+      toNodeType: "belief",
+      fromLayer: "L2",
+      toLayer: "L3",
+      // Classification fields
+      logicalRole,
+      temporalClass: "structural"
+      // Default - most evidence is long-lived
+    });
+    return { edgeGlobalId, evidenceNodeId, created: true };
+  }
+});
+var unlinkEvidence = mutation({
+  args: {
+    beliefNodeId: v.id("epistemicNodes"),
+    insightId: v.id("epistemicNodes"),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const now = Date.now();
+    const evidenceNode = await ctx.db.get(args.insightId);
+    if (!evidenceNode || evidenceNode.nodeType !== "evidence") {
+      return buildBeliefEvidenceNotFoundResult();
+    }
+    if (!evidenceNode.projectId) {
+      throw new Error("Evidence has no project scope");
+    }
+    await requireProjectWriteAccess(
+      ctx,
+      evidenceNode.projectId,
+      authenticatedUserId
+    );
+    const beliefNode = await ctx.db.get(args.beliefNodeId);
+    if (!beliefNode || beliefNode.nodeType !== "belief") {
+      throw new Error("Belief not found");
+    }
+    if (beliefNode.projectId !== evidenceNode.projectId) {
+      throw new Error("Belief and evidence belong to different projects");
+    }
+    const edge = await ctx.db.query("epistemicEdges").withIndex(
+      "by_from_to",
+      (q) => q.eq("fromNodeId", evidenceNode._id).eq("toNodeId", args.beliefNodeId)
+    ).first();
+    if (edge) {
+      await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
+        globalId: edge.globalId
+      });
+      await ctx.db.delete(edge._id);
+      await ctx.db.insert("epistemicAudit", {
+        entityType: "edge",
+        entityId: edge.globalId,
+        changeType: "edge_removed",
+        changedAt: now,
+        changedBy: authenticatedUserId,
+        isAgent: false,
+        previousState: {
+          fromNodeId: evidenceNode._id,
+          toNodeId: args.beliefNodeId
+        },
+        newState: null,
+        projectId: evidenceNode.projectId
+      });
+    }
+    return buildBeliefStatusSuccessResult();
+  }
+});
+var getWithEvidence = query({
+  args: {
+    nodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const belief = await ctx.db.get(args.nodeId);
+    if (!belief || belief.nodeType !== "belief") {
+      return null;
+    }
+    const incomingEdges = await ctx.db.query("epistemicEdges").withIndex(
+      "by_to_type",
+      (q) => q.eq("toNodeId", args.nodeId).eq("edgeType", "informs")
+    ).collect();
+    const evidenceNodeIds = incomingEdges.filter((e) => e.fromNodeType === "evidence").map((e) => e.fromNodeId);
+    const evidenceNodes = await Promise.all(
+      evidenceNodeIds.map((id) => ctx.db.get(id))
+    );
+    const supporting = [];
+    const contradicting = [];
+    for (let i = 0; i < evidenceNodes.length; i++) {
+      const node = evidenceNodes[i];
+      const edge = incomingEdges[i];
+      if (node) {
+        if ((edge.weight || 0) >= 0) {
+          supporting.push(node);
+        } else {
+          contradicting.push(node);
+        }
+      }
+    }
+    return {
+      belief,
+      evidence: {
+        supporting,
+        contradicting,
+        total: supporting.length + contradicting.length
+      }
+    };
+  }
+});
+var getRelationships = query({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    direction: v.optional(
+      v.union(v.literal("in"), v.literal("out"), v.literal("both"))
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const direction = args.direction || "both";
+    const results = {
+      incoming: [],
+      outgoing: []
+    };
+    if (direction === "in" || direction === "both") {
+      const inEdges = await ctx.db.query("epistemicEdges").filter((q) => q.eq(q.field("toNodeId"), args.nodeId)).collect();
+      for (const edge of inEdges) {
+        const sourceNode = await ctx.db.get(edge.fromNodeId);
+        results.incoming.push({ edge, node: sourceNode });
+      }
+    }
+    if (direction === "out" || direction === "both") {
+      const outEdges = await ctx.db.query("epistemicEdges").filter((q) => q.eq(q.field("fromNodeId"), args.nodeId)).collect();
+      for (const edge of outEdges) {
+        const targetNode = edge.toNodeId ? await ctx.db.get(edge.toNodeId) : null;
+        results.outgoing.push({ edge, node: targetNode });
+      }
+    }
+    return results;
+  }
+});
+
+export { getCountByStatus, getRelationships, getWithEvidence, linkBeliefs, linkEvidence, unlinkEvidence, updatePillar };
+//# sourceMappingURL=epistemicBeliefs.links.js.map
+//# sourceMappingURL=epistemicBeliefs.links.js.map