@lucern/graph-primitives 1.0.29 → 1.0.31

package/dist/epistemicEdges.js

@@ -1,29 +1,52 @@
-import { v } from 'convex/values';
-import { checkScopeAccess, requireScopeWriteAccess } from '@lucern/access-control/access';
+import { REASONING_METHODS, assertEdgePolicyAllowed, edgePolicyManifest } from '@lucern/contracts';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { componentsGeneric, anyApi, queryGeneric, mutationGeneric, internalMutationGeneric } from 'convex/server';
+import { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, internalMutationGeneric, mutationGeneric, queryGeneric } from 'convex/server';
 import { assertUuidV7Identity, assertStorageEdgeVocabulary, assertUuidShapedEdgeEndpoint } from '@lucern/contracts/ids';
-import { assertEdgePolicyAllowed, edgePolicyManifest } from '@lucern/contracts';
+import { requireScopeWriteAccess, checkScopeAccess } from '@lucern/access-control/access';
 
-// src/epistemicEdges.queries.ts
-
-// 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 api = anyApi;
+// src/epistemicEdges.handlers.ts
+var unsafeApi = unsafeConvexAnyApi(
+  "graph-primitives top-level module bundle lacks a committed Convex _generated/api surface"
+);
+var api = unsafeApi;
 componentsGeneric();
-var internal = anyApi;
+var internal = unsafeApi;
 var internalMutation = internalMutationGeneric;
 var mutation = mutationGeneric;
 var query = queryGeneric;
+function readOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readConvexId(value) {
+  const normalized = readOptionalString(value);
+  return normalized;
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readWorkspaceScopedEdge(value) {
+  const record = readRecord(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId(record._id);
+  const edgeType = readOptionalString(record.edgeType);
+  if (!(id && edgeType)) {
+    return null;
+  }
+  const edge = { _id: id, edgeType };
+  const projectId = readOptionalString(record.projectId);
+  if (projectId !== void 0) {
+    edge.projectId = projectId;
+  }
+  const topicId = readOptionalString(record.topicId);
+  if (topicId !== void 0) {
+    edge.topicId = topicId;
+  }
+  return edge;
+}
 var epistemicLayerValidator = v.union(
   v.literal("L4"),
   v.literal("L3"),
@@ -146,7 +169,7 @@ function buildEdgeMirrorWriteResult(edgeId, existed) {
   };
 }
 function edgeMatchesWorkspaceReasoningScope(edge, scope) {
-  return scope.topicId !== void 0 && edge.topicId === scope.topicId || scope.projectId !== void 0 && edge.projectId === scope.projectId;
+  return scope.topicId !== void 0 && edge.topicId === String(scope.topicId) || scope.projectId !== void 0 && (edge.projectId === scope.projectId || edge.topicId === scope.projectId);
 }
 async function collectScopedEdges(ctx, scope, scanLimit) {
   const queries = [];
@@ -169,7 +192,11 @@ async function collectScopedEdges(ctx, scope, scanLimit) {
   const seen = /* @__PURE__ */ new Set();
   const deduped = [];
   const flattened = (await Promise.all(queries)).flat();
-  for (const edge of flattened) {
+  for (const value of flattened) {
+    const edge = readWorkspaceScopedEdge(value);
+    if (!edge) {
+      continue;
+    }
     const key = String(edge._id);
     if (seen.has(key)) {
       continue;
@@ -179,457 +206,115 @@ async function collectScopedEdges(ctx, scope, scanLimit) {
   }
   return deduped;
 }
-
-// src/graphTypes.ts
-var EDGE_TYPE_TO_REL = {
-  // === THE SIX CANONICAL EPISTEMIC EDGE TYPES ===
-  supports: "SUPPORTS",
-  // L3↔L3: belief bears on belief (weight -1 to +1)
-  informs: "INFORMS",
-  // L2→L3: evidence bears on belief
-  depends_on: "DEPENDS_ON",
-  // L3→L3, Q→Q: structural gate
-  derived_from: "DERIVED_FROM",
-  // Any→Any: provenance chain (fork, synthesis, extraction, answer)
-  contains: "CONTAINS",
-  // Any→Any: hierarchy, scoping, membership
-  tests: "TESTS",
-  // Q→L3: question interrogates belief
-  // === L4 DECISION EDGES (derived_from with derivationType=decision) ===
-  // Kept as separate Neo4j relationship types for backward compat with L4 queries.
-  // New code should use derived_from + metadata.
-  based_on_belief: "BASED_ON_BELIEF",
-  based_on_question: "BASED_ON_QUESTION",
-  blocked_by_contradiction: "BLOCKED_BY_CONTRADICTION",
-  informed_by_theme: "INFORMED_BY_THEME",
-  // === ONTOLOGICAL EDGES (tenant-extensible, managed by ontology system) ===
-  works_at: "WORKS_AT",
-  invested_in: "INVESTED_IN",
-  competes_with: "COMPETES_WITH",
-  participates_in: "PARTICIPATES_IN",
-  founded_by: "FOUNDED_BY",
-  evaluates: "EVALUATES",
-  performs: "PERFORMS",
-  function_in: "FUNCTION_IN",
-  impacts: "IMPACTS",
-  raised_from: "RAISED_FROM",
-  mentioned_in: "MENTIONED_IN",
-  perspective_on: "PERSPECTIVE_ON",
-  about_entity: "ABOUT_ENTITY",
-  entity_referenced_in: "ENTITY_REFERENCED_IN"
-};
-function getNodeLayer(nodeType) {
-  const L4_TYPES = ["decision"];
-  const L3_TYPES = ["belief", "question", "theme", "deal"];
-  const L2_TYPES = ["claim", "evidence", "synthesis", "answer"];
-  const L1_TYPES = ["atomic_fact", "excerpt", "source"];
-  const ONTOLOGICAL_TYPES = [
-    "company",
-    "person",
-    "investor",
-    "function",
-    "value_chain"
-  ];
-  const ORGANIZATIONAL_TYPES = ["topic"];
-  if (L4_TYPES.includes(nodeType)) {
-    return "L4";
-  }
-  if (L3_TYPES.includes(nodeType)) {
-    return "L3";
-  }
-  if (L2_TYPES.includes(nodeType)) {
-    return "L2";
+async function assertExistingNodeEndpoint(ctx, endpointRole, endpoint) {
+  assertUuidShapedEdgeEndpoint(endpointRole, endpoint);
+  const node = await ctx.db.query("epistemicNodes").withIndex(
+    "by_globalId",
+    (q) => q.eq("globalId", endpoint)
+  ).first();
+  if (!node) {
+    throw new Error(
+      `edge_endpoint_not_canonical: epistemicEdges insert requires ${endpointRole} to be the globalId of an existing epistemicNodes row, received ${endpoint} (no node with that globalId)`
+    );
   }
-  if (L1_TYPES.includes(nodeType)) {
-    return "L1";
+}
+async function insertEpistemicEdge(ctx, doc) {
+  assertUuidV7Identity("epistemicEdges", doc.globalId);
+  assertStorageEdgeVocabulary(doc.edgeType);
+  if (!doc.fromNodeId || typeof doc.fromNodeId !== "string") {
+    throw new Error(
+      "edge_endpoint_missing: epistemicEdges insert requires a non-empty fromNodeId"
+    );
   }
-  if (ONTOLOGICAL_TYPES.includes(nodeType)) {
-    return "ontological";
+  if (!doc.toNodeId || typeof doc.toNodeId !== "string") {
+    throw new Error(
+      "edge_endpoint_missing: epistemicEdges insert requires a non-empty toNodeId"
+    );
   }
-  if (ORGANIZATIONAL_TYPES.includes(nodeType)) {
-    return "organizational";
+  await assertExistingNodeEndpoint(ctx, "fromNodeId", doc.fromNodeId);
+  await assertExistingNodeEndpoint(ctx, "toNodeId", doc.toNodeId);
+  if (doc.fromNodeType && doc.toNodeType && doc.edgeType !== "extracted_from") {
+    assertEdgePolicyAllowed(
+      edgePolicyManifest,
+      doc.edgeType,
+      {
+        kind: "epistemic_node",
+        nodeId: doc.fromNodeId,
+        nodeType: doc.fromNodeType
+      },
+      {
+        kind: "epistemic_node",
+        nodeId: doc.toNodeId,
+        nodeType: doc.toNodeType
+      }
+    );
   }
-  console.warn(`[GraphTypes] Unknown nodeType "${nodeType}", defaulting to L2`);
-  return "L2";
-}
-var CANONICAL_EPISTEMIC_TYPES = /* @__PURE__ */ new Set([
-  "supports",
-  "informs",
-  "depends_on",
-  "derived_from",
-  "contains",
-  "tests"
-]);
-function isDeprecatedEdgeType(edgeType) {
-  if (CANONICAL_EPISTEMIC_TYPES.has(edgeType)) return false;
-  if (edgeType in EDGE_TYPE_TO_REL) return false;
-  return true;
+  return ctx.db.insert("epistemicEdges", doc);
 }
 
-// src/edgeValidation.ts
-function getLayerDepth(layer) {
-  switch (layer) {
-    case "L4":
-      return 4;
-    case "L3":
-      return 3;
-    case "L2":
-      return 2;
-    case "L1":
-      return 1;
-    case "ontological":
-      return 0;
-    default:
-      return -1;
-  }
+// src/debug.ts
+function isGraphPrimitiveDebugEnabled() {
+  const env = globalThis.process?.env;
+  return env?.LUCERN_COMPAT_FALLBACK_DEBUG === "1" || env?.LUCERN_GRAPH_DEBUG === "1";
 }
-function isValidLayerConnection(fromLayer, toLayer) {
-  if (fromLayer === toLayer) {
-    return true;
-  }
-  if (fromLayer === "ontological" && toLayer === "ontological") {
-    return true;
-  }
-  if (fromLayer === "ontological" && (toLayer === "L3" || toLayer === "L2" || toLayer === "L1")) {
-    return true;
-  }
-  if ((fromLayer === "L3" || fromLayer === "L2" || fromLayer === "L1") && toLayer === "ontological") {
-    return true;
-  }
-  if (fromLayer === "L2" && toLayer === "L1") {
-    return true;
-  }
-  if (fromLayer === "L2" && toLayer === "L3") {
-    return true;
-  }
-  if (fromLayer === "L3" && toLayer === "L2") {
-    return true;
-  }
-  if (fromLayer === "L3" && toLayer === "L4") {
-    return true;
+function debugGraphPrimitiveFallback(message, context) {
+  if (!isGraphPrimitiveDebugEnabled()) {
+    return;
   }
-  if (fromLayer === "L4" && toLayer === "L3") {
-    return true;
+  console.debug(message, context ?? {});
+}
+
+// src/topicScope.ts
+var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
+async function resolveTopicNodeScopeOrNull(ctx, ref) {
+  if (!ctx?.db || typeof ctx.db.query !== "function") {
+    return null;
   }
-  if (fromLayer === "L3" && toLayer === "organizational") {
-    return true;
+  let node = null;
+  try {
+    const byGlobalId = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", ref)).first();
+    if (byGlobalId && byGlobalId.nodeType === "topic") {
+      node = byGlobalId;
+    }
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] topic-node scope lookup by globalId failed",
+      { error, ref }
+    );
   }
-  if (fromLayer === "organizational" && toLayer === "L3") {
-    return true;
+  if (!node) {
+    return null;
   }
-  const fromDepth = getLayerDepth(fromLayer);
-  const toDepth = getLayerDepth(toLayer);
-  if (Math.abs(fromDepth - toDepth) > 1) {
-    return false;
+  const scopeKey = normalizeScopeValue(node.topicId) ?? normalizeScopeValue(node.globalId);
+  if (!scopeKey) {
+    return null;
   }
-  return true;
+  return {
+    topicId: scopeKey,
+    projectId: asMappedProjectId(node),
+    source: "topic_node"
+  };
 }
-function shouldContinueTraversal(currentLayer, targetLayer, options) {
-  const currentDepth = getLayerDepth(currentLayer);
-  const targetDepth = getLayerDepth(targetLayer);
-  if (options.minLayer !== void 0 && targetDepth < options.minLayer) {
-    return false;
+function asMappedProjectId(topic) {
+  if (!topic) {
+    return;
   }
-  if (options.maxLayer !== void 0 && targetDepth > options.maxLayer) {
-    return false;
+  const directLegacyProjectId = normalizeScopeValue(
+    topic[LEGACY_SCOPE_FIELD]
+  );
+  if (directLegacyProjectId) {
+    return directLegacyProjectId;
   }
-  switch (options.mode) {
-    case "anchor_down":
-      return targetDepth <= currentDepth;
-    case "anchor_up":
-      return targetDepth >= currentDepth;
-    case "same_layer":
-      return targetDepth === currentDepth;
-    case "decision_trace":
-      return currentDepth === 4 ? targetDepth === 3 : targetDepth === currentDepth;
-    default:
-      return true;
+  const metadata = topic.metadata || {};
+  const candidate = metadata[LEGACY_SCOPE_FIELD] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
+  return typeof candidate === "string" ? normalizeScopeValue(candidate) : void 0;
+}
+function normalizeScopeValue(value) {
+  if (typeof value !== "string") {
+    return;
   }
-}
-function getDefaultMinLayer(mode) {
-  switch (mode) {
-    case "anchor_down":
-      return 1;
-    case "anchor_up":
-      return 2;
-    case "same_layer":
-      return 1;
-    case "decision_trace":
-      return 3;
-    default:
-      return 1;
-  }
-}
-var EDGE_LAYER_RULES = {
-  // === 6 Canonical Epistemic Types ===
-  supports: {
-    from: ["L3"],
-    to: ["L3"],
-    description: "Belief bears on Belief (weight: +1 supports, -1 contradicts)"
-  },
-  informs: {
-    from: ["L2"],
-    to: ["L3"],
-    description: "Evidence -> Belief (L2 -> L3)"
-  },
-  depends_on: {
-    from: ["L3"],
-    to: ["L3"],
-    description: "Belief B requires Belief A (structural gate)"
-  },
-  derived_from: {
-    from: ["L2", "L3", "L4"],
-    to: ["L1", "L2", "L3"],
-    description: "A was produced from B (provenance chain)"
-  },
-  contains: {
-    from: ["L3", "L4", "ontological"],
-    to: ["L2", "L3", "ontological"],
-    description: "A scopes/aggregates B (hierarchy)"
-  },
-  tests: {
-    from: ["L3"],
-    to: ["L3"],
-    description: "Question -> Belief (L3 -> L3)"
-  },
-  // === Structural / Lifecycle ===
-  supersedes: {
-    from: ["L3"],
-    to: ["L3"],
-    description: "NewNode -> OldNode (fork lineage)"
-  },
-  responds_to: {
-    from: ["L2", "L3"],
-    to: ["L3"],
-    description: "Answer -> Question (L2/L3 -> L3)"
-  },
-  belongs_to: {
-    from: ["L2", "L3", "ontological"],
-    to: ["L3"],
-    description: "Membership (migrating to contains)"
-  },
-  relates_to_thesis: {
-    from: ["L3"],
-    to: ["L3"],
-    description: "Belief -> Theme (L3 -> L3)"
-  },
-  // === Ontological (entity-entity or entity-epistemic bridge) ===
-  works_at: {
-    from: ["ontological"],
-    to: ["ontological"],
-    description: "Person -> Company"
-  },
-  invested_in: {
-    from: ["ontological"],
-    to: ["ontological"],
-    description: "Investor -> Company"
-  },
-  competes_with: {
-    from: ["ontological"],
-    to: ["ontological"],
-    description: "Company -> Company"
-  },
-  participates_in: {
-    from: ["ontological"],
-    to: ["ontological"],
-    description: "Company -> ValueChain"
-  },
-  founded_by: {
-    from: ["ontological"],
-    to: ["ontological"],
-    description: "Company -> Person"
-  },
-  evaluates: {
-    from: ["ontological"],
-    to: ["ontological"],
-    description: "Deal -> Company"
-  },
-  performs: {
-    from: ["ontological"],
-    to: ["ontological"],
-    description: "Company -> Function"
-  },
-  function_in: {
-    from: ["ontological"],
-    to: ["ontological"],
-    description: "Function -> ValueChain"
-  },
-  impacts: {
-    from: ["ontological", "L3"],
-    to: ["ontological"],
-    description: "Theme/Entity -> ValueChain"
-  },
-  raised_from: {
-    from: ["ontological"],
-    to: ["ontological"],
-    description: "Company -> Investor"
-  },
-  mentioned_in: {
-    from: ["ontological"],
-    to: ["L1", "L2"],
-    description: "Entity -> Source/Evidence"
-  },
-  perspective_on: {
-    from: ["ontological"],
-    to: ["L3"],
-    description: "Person -> Belief/Theme"
-  },
-  plays_theme: {
-    from: ["ontological"],
-    to: ["L3"],
-    description: "Deal -> Theme"
-  },
-  // C2-RR.4 — storage migration alias + the remaining 55 reachable edge types.
-  // Mirrors the kernel rule table
-  // (packages/reasoning-kernel/src/adapters/lib/edgeValidation.ts) so this
-  // graph-primitives write path admits the same public edge vocabulary. See the
-  // kernel file for the per-group rationale.
-  extracted_from: {
-    from: ["L2", "L3", "L4"],
-    to: ["L1", "L2", "L3"],
-    description: "Legacy storage migration alias for derived_from; public writes use derived_from"
-  },
-  qualifies: { from: ["L2", "L3"], to: ["L3"], description: "Evidence/Belief qualifies a Belief" },
-  contradicts: { from: ["L2", "L3"], to: ["L3"], description: "Evidence/Belief contradicts a Belief" },
-  reinforces: { from: ["L2", "L3"], to: ["L3"], description: "Evidence/Belief reinforces a Belief" },
-  corroborates: { from: ["L2", "L3"], to: ["L3"], description: "Independent evidence/belief corroborates a Belief" },
-  strengthened_by: { from: ["L3"], to: ["L2", "L3"], description: "Belief is strengthened by Evidence/Belief" },
-  weakened_by: { from: ["L3"], to: ["L2", "L3"], description: "Belief is weakened by Evidence/Belief" },
-  validated_by: { from: ["L3"], to: ["L2", "L3"], description: "Belief is validated by Evidence/Belief" },
-  falsified_by: { from: ["L3"], to: ["L2", "L3"], description: "Belief is falsified by Evidence/Belief" },
-  amplifies: { from: ["L3"], to: ["L3"], description: "Belief amplifies another Belief" },
-  precondition_for: { from: ["L3"], to: ["L3"], description: "Belief is a precondition for another Belief" },
-  prerequisite_for: { from: ["L3"], to: ["L3"], description: "Belief is a prerequisite for another Belief" },
-  required_for: { from: ["L3"], to: ["L3"], description: "Belief is required for another Belief" },
-  in_tension_with: { from: ["L3"], to: ["L3"], description: "Belief is in tension with another Belief" },
-  mutually_exclusive: { from: ["L3"], to: ["L3"], description: "Beliefs cannot both hold" },
-  exclusive_with: { from: ["L3"], to: ["L3"], description: "Belief is exclusive with another Belief" },
-  alternative_to: { from: ["L3"], to: ["L3"], description: "Belief is an alternative to another Belief" },
-  subsumes: { from: ["L3"], to: ["L3"], description: "Belief subsumes a narrower Belief" },
-  extends: { from: ["L3"], to: ["L3"], description: "Belief extends another Belief" },
-  refines: { from: ["L3"], to: ["L3"], description: "Belief refines another Belief" },
-  implements: { from: ["L3"], to: ["L3"], description: "Belief implements an abstract Belief" },
-  violates: { from: ["L3"], to: ["L3"], description: "Belief violates a constraint Belief" },
-  assumes: { from: ["L3"], to: ["L3"], description: "Belief assumes another Belief" },
-  would_predict: { from: ["L3"], to: ["L3"], description: "Belief would predict another Belief" },
-  analogous_to: { from: ["L3"], to: ["L3"], description: "Belief is analogous to another Belief" },
-  independent_of: { from: ["L3"], to: ["L3"], description: "Belief is independent of another Belief" },
-  correlates_with: { from: ["L3"], to: ["L3"], description: "Belief correlates with another Belief" },
-  co_changes_with: { from: ["L3"], to: ["L3"], description: "Belief co-changes with another Belief" },
-  counterfactual_of: { from: ["L3"], to: ["L3"], description: "Belief is a counterfactual of another Belief" },
-  parallel_to: { from: ["L3"], to: ["L3"], description: "Belief runs parallel to another Belief" },
-  cascade_from: { from: ["L3"], to: ["L3"], description: "Cascade from an upstream Belief" },
-  cascade_to: { from: ["L3"], to: ["L3"], description: "Cascade to a downstream Belief" },
-  collapses_if: { from: ["L3"], to: ["L3"], description: "Belief collapses if another fails" },
-  branches_from: { from: ["L3"], to: ["L3"], description: "Belief branches from an ancestor Belief" },
-  same_as: { from: ["L2", "L3", "ontological"], to: ["L2", "L3", "ontological"], description: "Two nodes are the same entity" },
-  answers: { from: ["L2", "L3"], to: ["L3"], description: "Answer/Belief answers a Question" },
-  partially_answers: { from: ["L2", "L3"], to: ["L3"], description: "Answer/Belief partially answers a Question" },
-  explores: { from: ["L3"], to: ["L3"], description: "Question explores a Belief/Theme" },
-  informed_by_theme: { from: ["L3"], to: ["L3"], description: "Belief is informed by a Theme" },
-  same_theme_as: { from: ["L3"], to: ["L3"], description: "Two Beliefs share a Theme" },
-  based_on: { from: ["L4"], to: ["L3"], description: "Decision is based on a Belief/Question" },
-  based_on_belief: { from: ["L4"], to: ["L3"], description: "Decision is based on a Belief" },
-  based_on_question: { from: ["L4"], to: ["L3"], description: "Decision is based on a Question" },
-  blocked_by_contradiction: { from: ["L4"], to: ["L3"], description: "Decision is blocked by a Contradiction" },
-  parent_of: { from: ["L3", "L4", "ontological", "organizational"], to: ["L2", "L3", "ontological", "organizational"], description: "A is the parent of B" },
-  child_of: { from: ["L2", "L3", "ontological", "organizational"], to: ["L3", "L4", "ontological", "organizational"], description: "A is the child of B" },
-  scoped_by: { from: ["L2", "L3"], to: ["L3", "organizational"], description: "Object is scoped by a Topic/Theme" },
-  cites: { from: ["L2", "L3"], to: ["L1", "L2"], description: "Evidence/Belief cites a Source/Excerpt" },
-  summarizes: { from: ["L2", "L3"], to: ["L1", "L2"], description: "Synthesis/Evidence summarizes a Source/Evidence" },
-  same_source_as: { from: ["L1", "L2"], to: ["L1", "L2"], description: "Two nodes derive from the same Source" },
-  migrating_from: { from: ["L2", "L3", "L4"], to: ["L1", "L2", "L3"], description: "Migration lineage: from an ancestor" },
-  migrating_to: { from: ["L1", "L2", "L3"], to: ["L2", "L3", "L4"], description: "Migration lineage: to a successor" },
-  about_entity: { from: ["L2", "L3"], to: ["ontological"], description: "Belief/Evidence is about an Entity" },
-  entity_referenced_in: { from: ["ontological"], to: ["L1", "L2"], description: "Entity is referenced in a Source/Evidence" },
-  related_to: { from: ["L2", "L3", "ontological", "organizational"], to: ["L2", "L3", "ontological", "organizational"], description: "Lateral adjacency; no confidence pressure" },
-  blocks: { from: ["L3", "L4"], to: ["L3", "L4"], description: "A blocks B (structural gate)" }
-};
-function validateEdgeLayers(edgeType, fromLayer, toLayer) {
-  const rules = EDGE_LAYER_RULES[edgeType];
-  if (!rules) {
-    console.warn(
-      `[EdgeValidation] Unknown edge type: ${edgeType}, allowing by default`
-    );
-    return { valid: true };
-  }
-  if (edgeType === "supersedes") {
-    if (fromLayer !== toLayer) {
-      return {
-        valid: false,
-        reason: `${edgeType} edges must be between nodes of the same layer. Got ${fromLayer} -> ${toLayer}`
-      };
-    }
-    return { valid: true };
-  }
-  if (!rules.from.includes(fromLayer)) {
-    return {
-      valid: false,
-      reason: `Edge type '${edgeType}' does not allow source layer ${fromLayer}. Allowed: ${rules.from.join(", ")}`
-    };
-  }
-  if (!rules.to.includes(toLayer)) {
-    return {
-      valid: false,
-      reason: `Edge type '${edgeType}' does not allow target layer ${toLayer}. Allowed: ${rules.to.join(", ")}`
-    };
-  }
-  if (!isValidLayerConnection(fromLayer, toLayer)) {
-    return {
-      valid: false,
-      reason: `Layer transition ${fromLayer} -> ${toLayer} is not permitted`
-    };
-  }
-  return { valid: true };
-}
-var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
-async function resolveTopicNodeScopeOrNull(ctx, ref) {
-  if (!ctx?.db || typeof ctx.db.query !== "function") {
-    return null;
-  }
-  let node = null;
-  try {
-    const byGlobalId = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", ref)).first();
-    if (byGlobalId && byGlobalId.nodeType === "topic") {
-      node = byGlobalId;
-    }
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicScope] topic-node scope lookup by globalId failed",
-      { error, ref }
-    );
-  }
-  if (!node) {
-    return null;
-  }
-  const scopeKey = normalizeScopeValue(node.topicId) ?? normalizeScopeValue(node.globalId);
-  if (!scopeKey) {
-    return null;
-  }
-  return {
-    topicId: scopeKey,
-    projectId: asMappedProjectId(node),
-    source: "topic_node"
-  };
-}
-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;
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
 }
 function pickPrimaryTopic(candidates) {
   return [...candidates].sort((a, b) => {
@@ -647,8 +332,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_FIELD, scopeId)
     ).collect();
@@ -660,7 +346,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);
@@ -716,527 +402,997 @@ 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/epistemicEdges.queries.ts
-var get = query({
-  args: { edgeId: v.id("epistemicEdges") },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    return await ctx.db.get(args.edgeId);
+// src/epistemicEdges.handlers.ts
+var EDGE_CONSTRAINTS = /* @__PURE__ */ new Set([
+  "alternative",
+  "counterfactual",
+  "xor"
+]);
+var EDGE_PROPAGATION_MODES = /* @__PURE__ */ new Set([
+  "continuous",
+  "threshold"
+]);
+var EDGE_LOGICAL_ROLES = /* @__PURE__ */ new Set([
+  "contributory",
+  "corroborative",
+  "necessary",
+  "necessary_sufficient",
+  "sufficient"
+]);
+var EDGE_TEMPORAL_CLASSES = /* @__PURE__ */ new Set([
+  "cyclical",
+  "point_in_time",
+  "structural",
+  "transient"
+]);
+var EPISTEMIC_LAYERS = /* @__PURE__ */ new Set([
+  "L4",
+  "L3",
+  "L2",
+  "L1",
+  "ontological",
+  "organizational"
+]);
+var REASONING_METHOD_SET = new Set(REASONING_METHODS);
+function readOptionalString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readConvexId2(value) {
+  const normalized = readOptionalString2(value);
+  return normalized ? normalized : null;
+}
+function readRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readEdgeMirrorNodeRow(value) {
+  const record = readRecord2(value);
+  if (!record) {
+    return null;
   }
-});
-var getByGlobalId = query({
-  args: { globalId: v.string() },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    return await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first();
+  const globalId = readOptionalString2(record.globalId);
+  return globalId ? { globalId } : null;
+}
+function requireEdgeId(value, context) {
+  const id = readConvexId2(value);
+  if (!id) {
+    throw new Error(`${context} requires a stored epistemic edge id.`);
   }
-});
-var getFromNode = query({
-  args: {
-    fromNodeId: v.id("epistemicNodes"),
-    edgeType: v.optional(edgeTypeValidator)
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const { edgeType } = args;
-    if (edgeType) {
-      return await ctx.db.query("epistemicEdges").withIndex(
-        "by_from_type",
-        (q) => q.eq("fromNodeId", args.fromNodeId).eq("edgeType", edgeType)
-      ).collect();
-    }
-    return await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", args.fromNodeId)).collect();
+  return id;
+}
+function readOptionalEnum(value, allowed, fieldName) {
+  if (value === void 0) {
+    return;
   }
-});
-var getToNode = query({
-  args: {
-    toNodeId: v.id("epistemicNodes"),
-    edgeType: v.optional(edgeTypeValidator)
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const { edgeType } = args;
-    if (edgeType) {
-      return await ctx.db.query("epistemicEdges").withIndex(
-        "by_to_type",
-        (q) => q.eq("toNodeId", args.toNodeId).eq("edgeType", edgeType)
-      ).collect();
-    }
-    return await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", args.toNodeId)).collect();
+  if (allowed.has(value)) {
+    return value;
   }
-});
-var getBySourceNode = query({
+  throw new Error(`${fieldName} received unsupported value "${value}".`);
+}
+var mirrorEdgeToConvex = internalMutation({
   args: {
-    sourceNodeId: v.string(),
-    edgeType: v.optional(v.string())
+    globalId: v.string(),
+    fromGlobalId: v.string(),
+    toGlobalId: v.string(),
+    edgeType: v.string(),
+    weight: v.optional(v.number()),
+    confidence: v.optional(v.number()),
+    context: v.optional(v.string()),
+    derivationType: v.optional(v.string()),
+    createdBy: v.string(),
+    ...optionalScopeArgs,
+    fromLayer: v.optional(v.string()),
+    toLayer: v.optional(v.string()),
+    fromNodeType: v.optional(v.string()),
+    toNodeType: v.optional(v.string()),
+    reasoningMethod: v.optional(v.string()),
+    logicalRole: v.optional(v.string()),
+    temporalClass: v.optional(v.string()),
+    validFrom: v.optional(v.number()),
+    validUntil: v.optional(v.number()),
+    constraint: v.optional(v.string()),
+    propagation: v.optional(v.string()),
+    blocking: v.optional(v.boolean()),
+    implicit: v.optional(v.boolean()),
+    conditionalA: v.optional(subjectiveOpinionValidator),
+    conditionalNotA: v.optional(subjectiveOpinionValidator)
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const isConvexId = args.sourceNodeId.length === 32 || args.sourceNodeId.includes("epistemicNodes");
-    if (isConvexId) {
-      const query2 = args.edgeType ? ctx.db.query("epistemicEdges").withIndex(
-        "by_from_type",
-        (q) => q.eq("fromNodeId", args.sourceNodeId).eq("edgeType", args.edgeType)
-      ) : ctx.db.query("epistemicEdges").withIndex(
-        "by_from",
-        (q) => q.eq("fromNodeId", args.sourceNodeId)
+    const fromNode = readEdgeMirrorNodeRow(
+      await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", args.fromGlobalId)).first()
+    );
+    if (!fromNode) {
+      console.log(
+        `[Dual-Write] Skipping mirror - source node not in Convex: ${args.fromGlobalId}`
       );
-      return await query2.collect();
-    }
-    const byGlobalId = await ctx.db.query("epistemicEdges").withIndex(
-      "by_source_global_id",
-      (q) => q.eq("sourceGlobalId", args.sourceNodeId)
-    ).collect();
-    if (args.edgeType) {
-      return byGlobalId.filter((edge) => edge.edgeType === args.edgeType);
+      return buildEdgeMirrorSkippedResult();
     }
-    return byGlobalId;
-  }
-});
-var getByTargetNode = query({
-  args: {
-    targetNodeId: v.string(),
-    edgeType: v.optional(v.string())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const isConvexId = args.targetNodeId.length === 32 || args.targetNodeId.includes("epistemicNodes");
-    if (isConvexId) {
-      const query2 = args.edgeType ? ctx.db.query("epistemicEdges").withIndex(
-        "by_to_type",
-        (q) => q.eq("toNodeId", args.targetNodeId).eq("edgeType", args.edgeType)
-      ) : ctx.db.query("epistemicEdges").withIndex(
-        "by_to",
-        (q) => q.eq("toNodeId", args.targetNodeId)
+    const toNode = readEdgeMirrorNodeRow(
+      await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", args.toGlobalId)).first()
+    );
+    const existing = await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first();
+    if (existing) {
+      console.log(`[Dual-Write] Edge already exists: ${args.globalId}`);
+      return buildEdgeMirrorWriteResult(
+        requireEdgeId(existing._id, "Edge mirror write result"),
+        true
       );
-      return await query2.collect();
     }
-    const byGlobalId = await ctx.db.query("epistemicEdges").withIndex(
-      "by_target_global_id",
-      (q) => q.eq("targetGlobalId", args.targetNodeId)
-    ).collect();
-    if (args.edgeType) {
-      return byGlobalId.filter((edge) => edge.edgeType === args.edgeType);
+    if (!toNode) {
+      console.log(
+        `[Dual-Write] Skipping mirror - to-node not in Convex: ${args.toGlobalId} (edge ${args.globalId} type ${args.edgeType})`
+      );
+      return buildEdgeMirrorSkippedResult();
     }
-    return byGlobalId;
+    const now = Date.now();
+    const edgeId = await insertEpistemicEdge(ctx, {
+      globalId: args.globalId,
+      // C2-RR.4 Defect E — endpoints are canonical node globalIds, not Convex
+      // doc ids. fromNode/toNode are resolved by_globalId above, so their
+      // stored globalId equals args.from/toGlobalId; persisting the doc _id here
+      // was the "mixed _id/globalId" defect.
+      fromNodeId: fromNode.globalId,
+      toNodeId: toNode.globalId,
+      sourceGlobalId: args.fromGlobalId,
+      targetGlobalId: args.toGlobalId,
+      edgeType: args.edgeType,
+      weight: args.weight,
+      confidence: args.confidence,
+      context: args.context,
+      derivationType: args.derivationType,
+      constraint: readOptionalEnum(
+        args.constraint,
+        EDGE_CONSTRAINTS,
+        "constraint"
+      ),
+      propagation: readOptionalEnum(
+        args.propagation,
+        EDGE_PROPAGATION_MODES,
+        "propagation"
+      ),
+      blocking: args.blocking,
+      implicit: args.implicit,
+      conditionalA: args.conditionalA,
+      conditionalNotA: args.conditionalNotA,
+      createdBy: args.createdBy,
+      createdAt: now,
+      updatedAt: now,
+      topicId: args.projectId,
+      fromLayer: readOptionalEnum(
+        args.fromLayer,
+        EPISTEMIC_LAYERS,
+        "fromLayer"
+      ),
+      toLayer: readOptionalEnum(args.toLayer, EPISTEMIC_LAYERS, "toLayer"),
+      fromNodeType: args.fromNodeType,
+      toNodeType: args.toNodeType,
+      reasoningMethod: readOptionalEnum(
+        args.reasoningMethod,
+        REASONING_METHOD_SET,
+        "reasoningMethod"
+      ),
+      logicalRole: readOptionalEnum(
+        args.logicalRole,
+        EDGE_LOGICAL_ROLES,
+        "logicalRole"
+      ),
+      temporalClass: readOptionalEnum(
+        args.temporalClass,
+        EDGE_TEMPORAL_CLASSES,
+        "temporalClass"
+      ),
+      validFrom: args.validFrom,
+      validUntil: args.validUntil
+    });
+    console.log(
+      `[Dual-Write] Mirrored edge to Convex: ${args.globalId} (${args.edgeType})`
+    );
+    return buildEdgeMirrorWriteResult(edgeId, false);
   }
 });
-var getBetween = query({
+var deleteEdgeFromConvex = internalMutation({
   args: {
-    fromNodeId: v.id("epistemicNodes"),
-    toNodeId: v.id("epistemicNodes"),
-    edgeType: v.optional(edgeTypeValidator)
+    globalId: v.string()
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const edges = await ctx.db.query("epistemicEdges").withIndex(
-      "by_from_to",
-      (q) => q.eq("fromNodeId", args.fromNodeId).eq("toNodeId", args.toNodeId)
-    ).collect();
-    if (args.edgeType) {
-      return edges.filter((e) => e.edgeType === args.edgeType);
+    const existing = await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first();
+    if (!existing) {
+      return buildEdgeMirrorMissingResult();
     }
-    return edges;
-  }
-});
-var getByNodes = query({
-  args: {
-    fromNodeId: v.id("epistemicNodes"),
-    toNodeId: v.id("epistemicNodes")
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    return await ctx.db.query("epistemicEdges").withIndex(
-      "by_from_to",
-      (q) => q.eq("fromNodeId", args.fromNodeId).eq("toNodeId", args.toNodeId)
-    ).first();
+    await ctx.db.delete(
+      requireEdgeId(existing._id, "Delete mirrored edge from Convex")
+    );
+    console.log(`[Dual-Write] Deleted edge from Convex: ${args.globalId}`);
+    return buildEdgeStatusSuccessResult();
   }
 });
-var getByProjectAndType = query({
+var updateEdgeInConvex = internalMutation({
   args: {
-    ...optionalScopeArgs,
-    edgeType: edgeTypeValidator
+    globalId: v.string(),
+    weight: v.optional(v.number()),
+    confidence: v.optional(v.number()),
+    context: v.optional(v.string()),
+    derivationType: v.optional(v.string()),
+    constraint: v.optional(v.string()),
+    propagation: v.optional(v.string()),
+    blocking: v.optional(v.boolean()),
+    implicit: v.optional(v.boolean()),
+    conditionalA: v.optional(subjectiveOpinionValidator),
+    conditionalNotA: v.optional(subjectiveOpinionValidator)
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    if (!args.projectId && !args.topicId) {
-      return [];
+    const existing = await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first();
+    if (!existing) {
+      return buildEdgeMirrorMissingResult();
     }
-    let scope;
-    try {
-      scope = await resolveTopicProjectScope(ctx, {
-        projectId: args.projectId,
-        topicId: args.topicId
-      });
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[epistemicEdges] Failed to resolve getAll scope",
-        {
-          error,
-          projectId: args.projectId,
-          topicId: args.topicId
-        }
-      );
-      return [];
+    const updates = {
+      updatedAt: Date.now()
+    };
+    if (args.weight !== void 0) {
+      updates.weight = args.weight;
     }
-    const projectEdges = await collectScopedEdges(ctx, scope, 5e3);
-    return projectEdges.filter(
-      (e) => e.edgeType === args.edgeType && edgeMatchesWorkspaceReasoningScope(e, scope)
-    ).slice(0, 5e3);
-  }
-});
-var getByProject = query({
-  args: {
-    ...optionalScopeArgs,
-    userId: v.optional(v.string()),
-    limit: v.optional(v.number())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    if (!args.projectId && !args.topicId) {
-      return [];
+    if (args.confidence !== void 0) {
+      updates.confidence = args.confidence;
     }
-    let scope;
-    try {
-      scope = await resolveTopicProjectScope(ctx, {
-        projectId: args.projectId,
-        topicId: args.topicId
-      });
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[epistemicEdges] Failed to resolve getByProject scope",
-        {
-          error,
-          projectId: args.projectId,
-          topicId: args.topicId
-        }
-      );
-      return [];
+    if (args.context !== void 0) {
+      updates.context = args.context;
     }
-    if (args.userId) {
-      const hasAccess = await checkScopeAccess(
-        ctx,
-        String(scope.topicId ?? scope.projectId),
-        args.userId
-      );
-      if (!hasAccess) {
-        return [];
-      }
+    if (args.derivationType !== void 0) {
+      updates.derivationType = args.derivationType;
     }
-    const pageSize = Math.max(1, Math.min(Math.floor(args.limit ?? 500), 2e3));
-    const edges = await collectScopedEdges(
-      ctx,
-      scope,
-      Math.min(pageSize * 3, 6e3)
+    if (args.constraint !== void 0) {
+      updates.constraint = args.constraint;
+    }
+    if (args.propagation !== void 0) {
+      updates.propagation = args.propagation;
+    }
+    if (args.blocking !== void 0) {
+      updates.blocking = args.blocking;
+    }
+    if (args.implicit !== void 0) {
+      updates.implicit = args.implicit;
+    }
+    if (args.conditionalA !== void 0) {
+      updates.conditionalA = args.conditionalA;
+    }
+    if (args.conditionalNotA !== void 0) {
+      updates.conditionalNotA = args.conditionalNotA;
+    }
+    await ctx.db.patch(
+      requireEdgeId(existing._id, "Update mirrored edge in Convex"),
+      updates
     );
-    return edges.filter((edge) => edgeMatchesWorkspaceReasoningScope(edge, scope)).slice(0, pageSize);
+    console.log(`[Dual-Write] Updated edge in Convex: ${args.globalId}`);
+    return buildEdgeStatusSuccessResult();
   }
 });
-var listAll = query({
-  args: {
-    limit: v.optional(v.number())
+
+// src/graphTypes.ts
+var EDGE_TYPE_TO_REL = {
+  // === THE SIX CANONICAL EPISTEMIC EDGE TYPES ===
+  supports: "SUPPORTS",
+  // L3↔L3: belief bears on belief (weight -1 to +1)
+  informs: "INFORMS",
+  // L2→L3: evidence bears on belief
+  depends_on: "DEPENDS_ON",
+  // L3→L3, Q→Q: structural gate
+  derived_from: "DERIVED_FROM",
+  // Any→Any: provenance chain (fork, synthesis, extraction, answer)
+  contains: "CONTAINS",
+  // Any→Any: hierarchy, scoping, membership
+  tests: "TESTS",
+  // Q→L3: question interrogates belief
+  // === L4 DECISION EDGES (derived_from with derivationType=decision) ===
+  // Kept as separate Neo4j relationship types for backward compat with L4 queries.
+  // New code should use derived_from + metadata.
+  based_on_belief: "BASED_ON_BELIEF",
+  based_on_question: "BASED_ON_QUESTION",
+  blocked_by_contradiction: "BLOCKED_BY_CONTRADICTION",
+  informed_by_theme: "INFORMED_BY_THEME",
+  // === ONTOLOGICAL EDGES (tenant-extensible, managed by ontology system) ===
+  works_at: "WORKS_AT",
+  invested_in: "INVESTED_IN",
+  competes_with: "COMPETES_WITH",
+  participates_in: "PARTICIPATES_IN",
+  founded_by: "FOUNDED_BY",
+  evaluates: "EVALUATES",
+  performs: "PERFORMS",
+  function_in: "FUNCTION_IN",
+  impacts: "IMPACTS",
+  raised_from: "RAISED_FROM",
+  mentioned_in: "MENTIONED_IN",
+  perspective_on: "PERSPECTIVE_ON",
+  about_entity: "ABOUT_ENTITY",
+  entity_referenced_in: "ENTITY_REFERENCED_IN"
+};
+function getNodeLayer(nodeType) {
+  const L4_TYPES = ["decision"];
+  const L3_TYPES = ["belief", "question", "theme", "deal"];
+  const L2_TYPES = ["claim", "evidence", "synthesis", "answer"];
+  const L1_TYPES = ["atomic_fact", "excerpt", "source"];
+  const ONTOLOGICAL_TYPES = [
+    "company",
+    "person",
+    "investor",
+    "function",
+    "value_chain"
+  ];
+  const ORGANIZATIONAL_TYPES = ["topic"];
+  if (L4_TYPES.includes(nodeType)) {
+    return "L4";
+  }
+  if (L3_TYPES.includes(nodeType)) {
+    return "L3";
+  }
+  if (L2_TYPES.includes(nodeType)) {
+    return "L2";
+  }
+  if (L1_TYPES.includes(nodeType)) {
+    return "L1";
+  }
+  if (ONTOLOGICAL_TYPES.includes(nodeType)) {
+    return "ontological";
+  }
+  if (ORGANIZATIONAL_TYPES.includes(nodeType)) {
+    return "organizational";
+  }
+  console.warn(`[GraphTypes] Unknown nodeType "${nodeType}", defaulting to L2`);
+  return "L2";
+}
+var CANONICAL_EPISTEMIC_TYPES = /* @__PURE__ */ new Set([
+  "supports",
+  "informs",
+  "depends_on",
+  "derived_from",
+  "contains",
+  "tests"
+]);
+function isDeprecatedEdgeType(edgeType) {
+  if (CANONICAL_EPISTEMIC_TYPES.has(edgeType)) {
+    return false;
+  }
+  if (edgeType in EDGE_TYPE_TO_REL) {
+    return false;
+  }
+  return true;
+}
+
+// src/edgeValidation.ts
+var VALID_LAYER_CONNECTIONS = {
+  ontological: /* @__PURE__ */ new Set(["ontological", "L1", "L2", "L3"]),
+  L1: /* @__PURE__ */ new Set(["L1", "L2"]),
+  L2: /* @__PURE__ */ new Set(["L1", "L2", "L3", "ontological"]),
+  L3: /* @__PURE__ */ new Set(["L2", "L3", "L4", "ontological", "organizational"]),
+  L4: /* @__PURE__ */ new Set(["L3", "L4"]),
+  organizational: /* @__PURE__ */ new Set(["organizational", "L3"])
+};
+function getLayerDepth(layer) {
+  switch (layer) {
+    case "L4":
+      return 4;
+    case "L3":
+      return 3;
+    case "L2":
+      return 2;
+    case "L1":
+      return 1;
+    case "ontological":
+      return 0;
+    default:
+      return -1;
+  }
+}
+function isValidLayerConnection(fromLayer, toLayer) {
+  if (!VALID_LAYER_CONNECTIONS[fromLayer].has(toLayer)) {
+    return false;
+  }
+  if (fromLayer === "ontological" || toLayer === "ontological") {
+    return true;
+  }
+  if (fromLayer === "organizational" || toLayer === "organizational") {
+    return true;
+  }
+  const fromDepth = getLayerDepth(fromLayer);
+  const toDepth = getLayerDepth(toLayer);
+  if (Math.abs(fromDepth - toDepth) > 1) {
+    return false;
+  }
+  return true;
+}
+function shouldContinueTraversal(currentLayer, targetLayer, options) {
+  const currentDepth = getLayerDepth(currentLayer);
+  const targetDepth = getLayerDepth(targetLayer);
+  if (options.minLayer !== void 0 && targetDepth < options.minLayer) {
+    return false;
+  }
+  if (options.maxLayer !== void 0 && targetDepth > options.maxLayer) {
+    return false;
+  }
+  switch (options.mode) {
+    case "anchor_down":
+      return targetDepth <= currentDepth;
+    case "anchor_up":
+      return targetDepth >= currentDepth;
+    case "same_layer":
+      return targetDepth === currentDepth;
+    case "decision_trace":
+      return currentDepth === 4 ? targetDepth === 3 : targetDepth === currentDepth;
+    default:
+      return true;
+  }
+}
+function getDefaultMinLayer(mode) {
+  switch (mode) {
+    case "anchor_down":
+      return 1;
+    case "anchor_up":
+      return 2;
+    case "same_layer":
+      return 1;
+    case "decision_trace":
+      return 3;
+    default:
+      return 1;
+  }
+}
+var EDGE_LAYER_RULES = {
+  // === 6 Canonical Epistemic Types ===
+  supports: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief bears on Belief (weight: +1 supports, -1 contradicts)"
+  },
+  informs: {
+    from: ["L2"],
+    to: ["L3"],
+    description: "Evidence -> Belief (L2 -> L3)"
+  },
+  depends_on: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief B requires Belief A (structural gate)"
+  },
+  derived_from: {
+    from: ["L2", "L3", "L4"],
+    to: ["L1", "L2", "L3"],
+    description: "A was produced from B (provenance chain)"
+  },
+  contains: {
+    from: ["L3", "L4", "ontological"],
+    to: ["L2", "L3", "ontological"],
+    description: "A scopes/aggregates B (hierarchy)"
+  },
+  tests: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Question -> Belief (L3 -> L3)"
+  },
+  // === Structural / Lifecycle ===
+  supersedes: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "NewNode -> OldNode (fork lineage)"
+  },
+  responds_to: {
+    from: ["L2", "L3"],
+    to: ["L3"],
+    description: "Answer -> Question (L2/L3 -> L3)"
+  },
+  belongs_to: {
+    from: ["L2", "L3", "ontological"],
+    to: ["L3"],
+    description: "Membership (migrating to contains)"
+  },
+  relates_to_thesis: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief -> Theme (L3 -> L3)"
+  },
+  // === Ontological (entity-entity or entity-epistemic bridge) ===
+  works_at: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Person -> Company"
+  },
+  invested_in: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Investor -> Company"
+  },
+  competes_with: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Company -> Company"
+  },
+  participates_in: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Company -> ValueChain"
+  },
+  founded_by: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Company -> Person"
+  },
+  evaluates: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Deal -> Company"
+  },
+  performs: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Company -> Function"
+  },
+  function_in: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Function -> ValueChain"
+  },
+  impacts: {
+    from: ["ontological", "L3"],
+    to: ["ontological"],
+    description: "Theme/Entity -> ValueChain"
+  },
+  raised_from: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Company -> Investor"
+  },
+  mentioned_in: {
+    from: ["ontological"],
+    to: ["L1", "L2"],
+    description: "Entity -> Source/Evidence"
+  },
+  perspective_on: {
+    from: ["ontological"],
+    to: ["L3"],
+    description: "Person -> Belief/Theme"
+  },
+  plays_theme: {
+    from: ["ontological"],
+    to: ["L3"],
+    description: "Deal -> Theme"
+  },
+  // C2-RR.4 — storage migration alias + the remaining 55 reachable edge types.
+  // Mirrors the kernel rule table
+  // (packages/reasoning-kernel/src/adapters/lib/edgeValidation.ts) so this
+  // graph-primitives write path admits the same public edge vocabulary. See the
+  // kernel file for the per-group rationale.
+  extracted_from: {
+    from: ["L2", "L3", "L4"],
+    to: ["L1", "L2", "L3"],
+    description: "Legacy storage migration alias for derived_from; public writes use derived_from"
+  },
+  qualifies: {
+    from: ["L2", "L3"],
+    to: ["L3"],
+    description: "Evidence/Belief qualifies a Belief"
+  },
+  contradicts: {
+    from: ["L2", "L3"],
+    to: ["L3"],
+    description: "Evidence/Belief contradicts a Belief"
+  },
+  reinforces: {
+    from: ["L2", "L3"],
+    to: ["L3"],
+    description: "Evidence/Belief reinforces a Belief"
+  },
+  corroborates: {
+    from: ["L2", "L3"],
+    to: ["L3"],
+    description: "Independent evidence/belief corroborates a Belief"
+  },
+  strengthened_by: {
+    from: ["L3"],
+    to: ["L2", "L3"],
+    description: "Belief is strengthened by Evidence/Belief"
+  },
+  weakened_by: {
+    from: ["L3"],
+    to: ["L2", "L3"],
+    description: "Belief is weakened by Evidence/Belief"
+  },
+  validated_by: {
+    from: ["L3"],
+    to: ["L2", "L3"],
+    description: "Belief is validated by Evidence/Belief"
+  },
+  falsified_by: {
+    from: ["L3"],
+    to: ["L2", "L3"],
+    description: "Belief is falsified by Evidence/Belief"
+  },
+  amplifies: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief amplifies another Belief"
+  },
+  precondition_for: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief is a precondition for another Belief"
+  },
+  prerequisite_for: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief is a prerequisite for another Belief"
+  },
+  required_for: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief is required for another Belief"
+  },
+  in_tension_with: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief is in tension with another Belief"
+  },
+  mutually_exclusive: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Beliefs cannot both hold"
+  },
+  exclusive_with: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief is exclusive with another Belief"
+  },
+  alternative_to: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief is an alternative to another Belief"
+  },
+  subsumes: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief subsumes a narrower Belief"
+  },
+  extends: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief extends another Belief"
+  },
+  refines: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief refines another Belief"
+  },
+  implements: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief implements an abstract Belief"
+  },
+  violates: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief violates a constraint Belief"
+  },
+  assumes: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief assumes another Belief"
+  },
+  would_predict: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief would predict another Belief"
+  },
+  analogous_to: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief is analogous to another Belief"
+  },
+  independent_of: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief is independent of another Belief"
+  },
+  correlates_with: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief correlates with another Belief"
+  },
+  co_changes_with: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief co-changes with another Belief"
+  },
+  counterfactual_of: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief is a counterfactual of another Belief"
+  },
+  parallel_to: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief runs parallel to another Belief"
+  },
+  cascade_from: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Cascade from an upstream Belief"
+  },
+  cascade_to: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Cascade to a downstream Belief"
+  },
+  collapses_if: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief collapses if another fails"
+  },
+  branches_from: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief branches from an ancestor Belief"
+  },
+  same_as: {
+    from: ["L2", "L3", "ontological"],
+    to: ["L2", "L3", "ontological"],
+    description: "Two nodes are the same entity"
   },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const pageSize = Math.max(
-      1,
-      Math.min(Math.floor(args.limit ?? 5e3), 1e4)
-    );
-    return await ctx.db.query("epistemicEdges").order("desc").take(pageSize);
-  }
-});
-var findContradictions = query({
-  args: {
-    nodeId: v.id("epistemicNodes")
+  answers: {
+    from: ["L2", "L3"],
+    to: ["L3"],
+    description: "Answer/Belief answers a Question"
   },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const edges = await ctx.db.query("epistemicEdges").withIndex(
-      "by_to_type",
-      (q) => q.eq("toNodeId", args.nodeId).eq("edgeType", "informs")
-    ).collect();
-    return edges.filter((e) => (e.weight ?? 0) < 0);
-  }
-});
-var findSupport = query({
-  args: {
-    nodeId: v.id("epistemicNodes")
+  partially_answers: {
+    from: ["L2", "L3"],
+    to: ["L3"],
+    description: "Answer/Belief partially answers a Question"
   },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const edges = await ctx.db.query("epistemicEdges").withIndex(
-      "by_to_type",
-      (q) => q.eq("toNodeId", args.nodeId).eq("edgeType", "informs")
-    ).collect();
-    return edges.filter((e) => (e.weight ?? 0) >= 0);
-  }
-});
-var getLineage = query({
-  args: {
-    nodeId: v.id("epistemicNodes"),
-    maxDepth: v.optional(v.number()),
-    // Phase 2D: Layer-aware traversal options
-    minLayer: v.optional(v.number()),
-    // 1=L1, 2=L2, 3=L3, 4=L4
-    maxLayer: v.optional(v.number()),
-    mode: v.optional(
-      v.union(
-        v.literal("anchor_down"),
-        v.literal("anchor_up"),
-        v.literal("same_layer"),
-        v.literal("decision_trace")
-      )
-    )
+  explores: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Question explores a Belief/Theme"
   },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const maxDepth = args.maxDepth ?? 10;
-    const mode = args.mode ?? "anchor_down";
-    const minLayer = args.minLayer ?? getDefaultMinLayer(mode);
-    const maxLayer = args.maxLayer ?? 4;
-    const lineage = [];
-    const visited = /* @__PURE__ */ new Set();
-    const startNode = await ctx.db.get(args.nodeId);
-    if (!startNode) {
-      return lineage;
-    }
-    const startLayer = startNode.epistemicLayer || getNodeLayer(startNode.nodeType);
-    const queue = [{ nodeId: args.nodeId, depth: 0, currentLayer: startLayer }];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (!current || current.depth >= maxDepth) {
-        continue;
-      }
-      const nodeIdStr = current.nodeId.toString();
-      if (visited.has(nodeIdStr)) {
-        continue;
-      }
-      visited.add(nodeIdStr);
-      const edges = await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", current.nodeId)).collect();
-      const lineageEdges = edges.filter((e) => e.edgeType === "derived_from");
-      for (const edge of lineageEdges) {
-        if (!edge.toNodeId) {
-          continue;
-        }
-        const targetNode = await ctx.db.get(edge.toNodeId);
-        if (!targetNode || visited.has(edge.toNodeId.toString())) {
-          continue;
-        }
-        const targetLayer = edge.toLayer || targetNode.epistemicLayer || getNodeLayer(targetNode.nodeType);
-        const shouldContinue = shouldContinueTraversal(
-          current.currentLayer,
-          targetLayer,
-          { mode, minLayer, maxLayer }
-        );
-        if (!shouldContinue) {
-          continue;
-        }
-        lineage.push({
-          node: targetNode,
-          depth: current.depth + 1,
-          edgeType: edge.edgeType,
-          layer: targetLayer
-        });
-        queue.push({
-          nodeId: edge.toNodeId,
-          depth: current.depth + 1,
-          currentLayer: targetLayer
-        });
-      }
-    }
-    return lineage;
-  }
-});
-var getEvidenceForBelief = query({
-  args: {
-    beliefNodeId: v.id("epistemicNodes")
+  informed_by_theme: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief is informed by a Theme"
   },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const informsEdges = await ctx.db.query("epistemicEdges").withIndex(
-      "by_to_type",
-      (q) => q.eq("toNodeId", args.beliefNodeId).eq("edgeType", "informs")
-    ).collect();
-    const supportEdges = informsEdges.filter((e) => (e.weight ?? 0) >= 0);
-    const contradictEdges = informsEdges.filter((e) => (e.weight ?? 0) < 0);
-    const supportingEvidence = await Promise.all(
-      supportEdges.map(async (edge) => ({
-        edge,
-        node: await ctx.db.get(edge.fromNodeId)
-      }))
-    );
-    const contradictingEvidence = await Promise.all(
-      contradictEdges.map(async (edge) => ({
-        edge,
-        node: await ctx.db.get(edge.fromNodeId)
-      }))
-    );
-    const filteredSupporting = supportingEvidence.filter((e) => e.node !== null);
-    const filteredContradicting = contradictingEvidence.filter(
-      (e) => e.node !== null
+  same_theme_as: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Two Beliefs share a Theme"
+  },
+  based_on: {
+    from: ["L4"],
+    to: ["L3"],
+    description: "Decision is based on a Belief/Question"
+  },
+  based_on_belief: {
+    from: ["L4"],
+    to: ["L3"],
+    description: "Decision is based on a Belief"
+  },
+  based_on_question: {
+    from: ["L4"],
+    to: ["L3"],
+    description: "Decision is based on a Question"
+  },
+  blocked_by_contradiction: {
+    from: ["L4"],
+    to: ["L3"],
+    description: "Decision is blocked by a Contradiction"
+  },
+  parent_of: {
+    from: ["L3", "L4", "ontological", "organizational"],
+    to: ["L2", "L3", "ontological", "organizational"],
+    description: "A is the parent of B"
+  },
+  child_of: {
+    from: ["L2", "L3", "ontological", "organizational"],
+    to: ["L3", "L4", "ontological", "organizational"],
+    description: "A is the child of B"
+  },
+  scoped_by: {
+    from: ["L2", "L3"],
+    to: ["L3", "organizational"],
+    description: "Object is scoped by a Topic/Theme"
+  },
+  cites: {
+    from: ["L2", "L3"],
+    to: ["L1", "L2"],
+    description: "Evidence/Belief cites a Source/Excerpt"
+  },
+  summarizes: {
+    from: ["L2", "L3"],
+    to: ["L1", "L2"],
+    description: "Synthesis/Evidence summarizes a Source/Evidence"
+  },
+  same_source_as: {
+    from: ["L1", "L2"],
+    to: ["L1", "L2"],
+    description: "Two nodes derive from the same Source"
+  },
+  migrating_from: {
+    from: ["L2", "L3", "L4"],
+    to: ["L1", "L2", "L3"],
+    description: "Migration lineage: from an ancestor"
+  },
+  migrating_to: {
+    from: ["L1", "L2", "L3"],
+    to: ["L2", "L3", "L4"],
+    description: "Migration lineage: to a successor"
+  },
+  about_entity: {
+    from: ["L2", "L3"],
+    to: ["ontological"],
+    description: "Belief/Evidence is about an Entity"
+  },
+  entity_referenced_in: {
+    from: ["ontological"],
+    to: ["L1", "L2"],
+    description: "Entity is referenced in a Source/Evidence"
+  },
+  related_to: {
+    from: ["L2", "L3", "ontological", "organizational"],
+    to: ["L2", "L3", "ontological", "organizational"],
+    description: "Lateral adjacency; no confidence pressure"
+  },
+  blocks: {
+    from: ["L3", "L4"],
+    to: ["L3", "L4"],
+    description: "A blocks B (structural gate)"
+  }
+};
+function validateEdgeLayers(edgeType, fromLayer, toLayer) {
+  const rules = EDGE_LAYER_RULES[edgeType];
+  if (!rules) {
+    console.warn(
+      `[EdgeValidation] Unknown edge type: ${edgeType}, allowing by default`
     );
+    return { valid: true };
+  }
+  if (edgeType === "supersedes") {
+    if (fromLayer !== toLayer) {
+      return {
+        valid: false,
+        reason: `${edgeType} edges must be between nodes of the same layer. Got ${fromLayer} -> ${toLayer}`
+      };
+    }
+    return { valid: true };
+  }
+  if (!rules.from.includes(fromLayer)) {
     return {
-      supporting: filteredSupporting,
-      contradicting: filteredContradicting,
-      supportCount: filteredSupporting.length,
-      contradictCount: filteredContradicting.length
+      valid: false,
+      reason: `Edge type '${edgeType}' does not allow source layer ${fromLayer}. Allowed: ${rules.from.join(", ")}`
     };
   }
-});
-var getClusterEdges = query({
-  args: {
-    beliefIds: v.array(v.string())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    if (args.beliefIds.length === 0) {
-      return [];
-    }
-    const beliefIdSet = new Set(args.beliefIds);
-    const allEdges = await ctx.db.query("epistemicEdges").collect();
-    return allEdges.filter((edge) => {
-      const fromInCluster = beliefIdSet.has(String(edge.fromNodeId)) || edge.sourceGlobalId && beliefIdSet.has(edge.sourceGlobalId);
-      const toInCluster = beliefIdSet.has(String(edge.toNodeId)) || edge.targetGlobalId && beliefIdSet.has(edge.targetGlobalId);
-      return fromInCluster && toInCluster;
-    });
+  if (!rules.to.includes(toLayer)) {
+    return {
+      valid: false,
+      reason: `Edge type '${edgeType}' does not allow target layer ${toLayer}. Allowed: ${rules.to.join(", ")}`
+    };
   }
-});
+  if (!isValidLayerConnection(fromLayer, toLayer)) {
+    return {
+      valid: false,
+      reason: `Layer transition ${fromLayer} -> ${toLayer} is not permitted`
+    };
+  }
+  return { valid: true };
+}
 
 // src/topicProjectOverlay.ts
 var LEGACY_SCOPE_FIELD2 = "graphScopeProjectId";
@@ -1256,6 +1412,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;
@@ -1336,9 +1496,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;
     }
@@ -1358,8 +1521,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,
@@ -1428,90 +1601,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);
+  }
+  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;
   }
-  patch.updatedAt = Date.now();
-  patch.metadata = nextMetadata;
-  topicUpdateArgs.metadata = nextMetadata;
+  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
@@ -1539,7 +1735,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(
@@ -1572,8 +1768,140 @@ function resolveGraphPrimitivesAppResolvers(_ctx) {
     ...resolverOverrides
   };
 }
-
-// src/epistemicEdges.mutations.ts
+
+// src/epistemicEdges.mutations.ts
+var EPISTEMIC_LAYERS2 = /* @__PURE__ */ new Set([
+  "L4",
+  "L3",
+  "L2",
+  "L1",
+  "ontological",
+  "organizational"
+]);
+function readOptionalString3(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readConvexId3(value) {
+  const normalized = readOptionalString3(value);
+  return normalized;
+}
+function readRecord3(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readEpistemicLayer(value) {
+  const layer = readOptionalString3(value);
+  return layer && EPISTEMIC_LAYERS2.has(layer) ? layer : void 0;
+}
+function readEdgeNodeRow(value) {
+  const record = readRecord3(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId3(record._id);
+  const globalId = readOptionalString3(record.globalId);
+  const nodeType = readOptionalString3(record.nodeType);
+  if (!(id && globalId && nodeType)) {
+    return null;
+  }
+  const node = { _id: id, globalId, nodeType };
+  const epistemicLayer = readEpistemicLayer(record.epistemicLayer);
+  if (epistemicLayer !== void 0) {
+    node.epistemicLayer = epistemicLayer;
+  }
+  const projectId = readOptionalString3(record.projectId);
+  if (projectId !== void 0) {
+    node.projectId = projectId;
+  }
+  return node;
+}
+function requireEdgeNodeRow(value, context) {
+  const node = readEdgeNodeRow(value);
+  if (!node) {
+    throw new Error(`${context} requires a canonical epistemic node row.`);
+  }
+  return node;
+}
+function readEdgeRow(value) {
+  const record = readRecord3(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId3(record._id);
+  const globalId = readOptionalString3(record.globalId);
+  const edgeType = readOptionalString3(record.edgeType);
+  if (!(id && globalId && edgeType)) {
+    return null;
+  }
+  const edge = { _id: id, globalId, edgeType };
+  const createdBy = readOptionalString3(record.createdBy);
+  if (createdBy !== void 0) {
+    edge.createdBy = createdBy;
+  }
+  const fromNodeId = readOptionalString3(record.fromNodeId);
+  if (fromNodeId !== void 0) {
+    edge.fromNodeId = fromNodeId;
+  }
+  const projectId = readOptionalString3(record.projectId);
+  if (projectId !== void 0) {
+    edge.projectId = projectId;
+  }
+  const toNodeId = readOptionalString3(record.toNodeId);
+  if (toNodeId !== void 0) {
+    edge.toNodeId = toNodeId;
+  }
+  const confidence = readOptionalNumber(record.confidence);
+  if (confidence !== void 0) {
+    edge.confidence = confidence;
+  }
+  const weight = readOptionalNumber(record.weight);
+  if (weight !== void 0) {
+    edge.weight = weight;
+  }
+  if ("context" in record) {
+    edge.context = record.context;
+  }
+  if ("description" in record) {
+    edge.description = record.description;
+  }
+  return edge;
+}
+function readEdgeRows(values) {
+  return values.flatMap((value) => {
+    const edge = readEdgeRow(value);
+    return edge ? [edge] : [];
+  });
+}
+function nodeEndpointRefs(nodeId, node) {
+  const refs = /* @__PURE__ */ new Set([String(nodeId)]);
+  if (node?.globalId) {
+    refs.add(node.globalId);
+  }
+  return [...refs];
+}
+async function collectEdgesBetween(ctx, fromRefs, toRefs) {
+  const seen = /* @__PURE__ */ new Set();
+  const edges = [];
+  for (const fromRef of fromRefs) {
+    for (const toRef of toRefs) {
+      const rows = await ctx.db.query("epistemicEdges").withIndex(
+        "by_from_to",
+        (q) => q.eq("fromNodeId", fromRef).eq("toNodeId", toRef)
+      ).collect();
+      for (const edge of readEdgeRows(rows)) {
+        const key = String(edge._id);
+        if (seen.has(key)) {
+          continue;
+        }
+        seen.add(key);
+        edges.push(edge);
+      }
+    }
+  }
+  return edges;
+}
 var create = mutation({
   args: {
     globalId: v.string(),
@@ -1590,11 +1918,14 @@ var create = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    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 nodes not found");
-    }
+    const fromNode = requireEdgeNodeRow(
+      await ctx.db.get(args.fromNodeId),
+      "Create edge source"
+    );
+    const toNode = requireEdgeNodeRow(
+      await ctx.db.get(args.toNodeId),
+      "Create edge target"
+    );
     const resolvedScope = args.topicId || args.projectId ? await resolveTopicProjectScope(ctx, {
       topicId: args.topicId,
       projectId: args.projectId
@@ -1603,8 +1934,8 @@ var create = mutation({
     if (resolvedProjectId) {
       await requireScopeWriteAccess(ctx, resolvedProjectId, args.createdBy);
     }
-    const fromLayer = fromNode.epistemicLayer || getNodeLayer(fromNode.nodeType);
-    const toLayer = toNode.epistemicLayer || getNodeLayer(toNode.nodeType);
+    const fromLayer = fromNode.epistemicLayer ?? getNodeLayer(fromNode.nodeType);
+    const toLayer = toNode.epistemicLayer ?? getNodeLayer(toNode.nodeType);
     if (!args.skipLayerValidation) {
       const validation = validateEdgeLayers(args.edgeType, fromLayer, toLayer);
       if (!validation.valid) {
@@ -1618,10 +1949,11 @@ var create = mutation({
         `FORBIDDEN: Edge type '${args.edgeType}' has been removed from StackOS schema.`
       );
     }
-    const existing = await ctx.db.query("epistemicEdges").withIndex(
-      "by_from_to",
-      (q) => q.eq("fromNodeId", args.fromNodeId).eq("toNodeId", args.toNodeId)
-    ).collect();
+    const existing = await collectEdgesBetween(
+      ctx,
+      nodeEndpointRefs(args.fromNodeId, fromNode),
+      nodeEndpointRefs(args.toNodeId, toNode)
+    );
     const duplicateEdge = existing.find((e) => e.edgeType === args.edgeType);
     if (duplicateEdge) {
       return { edgeId: duplicateEdge._id, isDuplicate: true };
@@ -1698,7 +2030,7 @@ var update = mutation({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const { edgeId, userId, ...updates } = args;
-    const edge = await ctx.db.get(edgeId);
+    const edge = readEdgeRow(await ctx.db.get(edgeId));
     if (!edge) {
       throw new Error("Edge not found");
     }
@@ -1739,7 +2071,7 @@ var remove = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const edge = await ctx.db.get(args.edgeId);
+    const edge = readEdgeRow(await ctx.db.get(args.edgeId));
     if (!edge) {
       return buildEdgeNotFoundResult();
     }
@@ -1785,10 +2117,13 @@ var removeBetween = mutation({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const edges = await ctx.db.query("epistemicEdges").withIndex(
-      "by_from_to",
-      (q) => q.eq("fromNodeId", args.fromNodeId).eq("toNodeId", args.toNodeId)
-    ).collect();
+    const fromNode = readEdgeNodeRow(await ctx.db.get(args.fromNodeId));
+    const toNode = readEdgeNodeRow(await ctx.db.get(args.toNodeId));
+    const edges = await collectEdgesBetween(
+      ctx,
+      nodeEndpointRefs(args.fromNodeId, fromNode),
+      nodeEndpointRefs(args.toNodeId, toNode)
+    );
     let deleted = 0;
     for (const edge of edges) {
       if (!args.edgeType || edge.edgeType === args.edgeType) {
@@ -1825,19 +2160,23 @@ var batchCreate = mutation({
     const results = [];
     const errors = [];
     for (const edge of args.edges) {
-      const fromNode = await ctx.db.get(edge.fromNodeId);
-      const toNode = await ctx.db.get(edge.toNodeId);
-      if (!fromNode || !toNode) {
+      const fromNode = readEdgeNodeRow(await ctx.db.get(edge.fromNodeId));
+      const toNode = readEdgeNodeRow(await ctx.db.get(edge.toNodeId));
+      if (!(fromNode && toNode)) {
         errors.push({
           globalId: edge.globalId,
           error: "One or both nodes not found"
         });
         continue;
       }
-      const fromLayer = fromNode.epistemicLayer || getNodeLayer(fromNode.nodeType);
-      const toLayer = toNode.epistemicLayer || getNodeLayer(toNode.nodeType);
+      const fromLayer = fromNode.epistemicLayer ?? getNodeLayer(fromNode.nodeType);
+      const toLayer = toNode.epistemicLayer ?? getNodeLayer(toNode.nodeType);
       if (!args.skipLayerValidation) {
-        const validation = validateEdgeLayers(edge.edgeType, fromLayer, toLayer);
+        const validation = validateEdgeLayers(
+          edge.edgeType,
+          fromLayer,
+          toLayer
+        );
         if (!validation.valid) {
           errors.push({
             globalId: edge.globalId,
@@ -1872,9 +2211,7 @@ var batchCreate = mutation({
       results.push({ globalId: edge.globalId, edgeGlobalId: edge.globalId });
     }
     const projectIds = new Set(
-      args.edges.flatMap(
-        (edge) => typeof edge.projectId === "string" ? [edge.projectId] : []
-      )
+      args.edges.flatMap((edge) => edge.projectId ? [edge.projectId] : [])
     );
     for (const pid of projectIds) {
       if (pid) {
@@ -1895,8 +2232,11 @@ var cleanupDeprecatedEdges = mutation({
   handler: async (ctx, args) => {
     const DEPRECATED_TYPES = ["contradicts"];
     const scopeId = args.topicId || args.projectId;
-    const allEdges = scopeId ? await ctx.db.query("epistemicEdges").withIndex("by_topic", (q) => q.eq("topicId", scopeId)).collect() : [];
-    const deprecatedEdges = allEdges.filter(
+    const allEdges = scopeId ? await ctx.db.query("epistemicEdges").withIndex(
+      "by_topic",
+      (q) => q.eq("topicId", scopeId)
+    ).collect() : [];
+    const deprecatedEdges = readEdgeRows(allEdges).filter(
       (edge) => DEPRECATED_TYPES.includes(edge.edgeType)
     );
     if (args.dryRun) {
@@ -1939,15 +2279,15 @@ var deleteEdges = mutation({
     const deleted = [];
     const notFound = [];
     for (const edgeId of args.edgeIds) {
-      const edge = await ctx.db.get(edgeId);
+      const edge = readEdgeRow(await ctx.db.get(edgeId));
       if (edge) {
         await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
           globalId: edge.globalId
         });
         await ctx.db.delete(edgeId);
-        deleted.push(edgeId);
+        deleted.push(String(edgeId));
       } else {
-        notFound.push(edgeId);
+        notFound.push(String(edgeId));
       }
     }
     return {
@@ -1957,219 +2297,643 @@ var deleteEdges = mutation({
     };
   }
 });
-async function assertExistingNodeEndpoint(ctx, endpointRole, endpoint) {
-  assertUuidShapedEdgeEndpoint(endpointRole, endpoint);
-  const node = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", endpoint)).first();
-  if (!node) {
-    throw new Error(
-      `edge_endpoint_not_canonical: epistemicEdges insert requires ${endpointRole} to be the globalId of an existing epistemicNodes row, received ${endpoint} (no node with that globalId)`
+var DERIVED_FROM_EDGE_TYPE = "derived_from";
+var EPISTEMIC_LAYERS3 = /* @__PURE__ */ new Set([
+  "L4",
+  "L3",
+  "L2",
+  "L1",
+  "ontological",
+  "organizational"
+]);
+function readOptionalString4(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readOptionalNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readConvexId4(value) {
+  const normalized = readOptionalString4(value);
+  return normalized;
+}
+function readRecord4(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readEpistemicLayer2(value) {
+  const layer = readOptionalString4(value);
+  return layer && EPISTEMIC_LAYERS3.has(layer) ? layer : void 0;
+}
+function readEdgeNodeRow2(value) {
+  const record = readRecord4(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId4(record._id);
+  const nodeType = readOptionalString4(record.nodeType);
+  if (!(id && nodeType)) {
+    return null;
+  }
+  const node = { ...record, _id: id, nodeType };
+  const globalId = readOptionalString4(record.globalId);
+  if (globalId !== void 0) {
+    node.globalId = globalId;
+  }
+  const epistemicLayer = readEpistemicLayer2(record.epistemicLayer);
+  if (epistemicLayer !== void 0) {
+    node.epistemicLayer = epistemicLayer;
+  }
+  return node;
+}
+function readEdgeRow2(value) {
+  const record = readRecord4(value);
+  if (!record) {
+    return null;
+  }
+  const id = readConvexId4(record._id);
+  const edgeType = readOptionalString4(record.edgeType);
+  if (!(id && edgeType)) {
+    return null;
+  }
+  const edge = { ...record, _id: id, edgeType };
+  const globalId = readOptionalString4(record.globalId);
+  if (globalId !== void 0) {
+    edge.globalId = globalId;
+  }
+  const fromNodeId = readOptionalString4(record.fromNodeId);
+  if (fromNodeId !== void 0) {
+    edge.fromNodeId = fromNodeId;
+  }
+  const toNodeId = readOptionalString4(record.toNodeId);
+  if (toNodeId !== void 0) {
+    edge.toNodeId = toNodeId;
+  }
+  const sourceGlobalId = readOptionalString4(record.sourceGlobalId);
+  if (sourceGlobalId !== void 0) {
+    edge.sourceGlobalId = sourceGlobalId;
+  }
+  const targetGlobalId = readOptionalString4(record.targetGlobalId);
+  if (targetGlobalId !== void 0) {
+    edge.targetGlobalId = targetGlobalId;
+  }
+  const fromGlobalId = readOptionalString4(record.fromGlobalId);
+  if (fromGlobalId !== void 0) {
+    edge.fromGlobalId = fromGlobalId;
+  }
+  const toGlobalId = readOptionalString4(record.toGlobalId);
+  if (toGlobalId !== void 0) {
+    edge.toGlobalId = toGlobalId;
+  }
+  const toLayer = readEpistemicLayer2(record.toLayer);
+  if (toLayer !== void 0) {
+    edge.toLayer = toLayer;
+  }
+  const weight = readOptionalNumber2(record.weight);
+  if (weight !== void 0) {
+    edge.weight = weight;
+  }
+  return edge;
+}
+function readEdgeRows2(values) {
+  return values.flatMap((value) => {
+    const edge = readEdgeRow2(value);
+    return edge ? [edge] : [];
+  });
+}
+function dedupeEdges(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const edge of edges) {
+    const key = String(edge._id);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    deduped.push(edge);
+  }
+  return deduped;
+}
+function filterEdgesByType(edges, edgeType) {
+  return edgeType ? edges.filter((edge) => edge.edgeType === edgeType) : [...edges];
+}
+function nodeEndpointRefs2(node) {
+  const refs = /* @__PURE__ */ new Set([String(node._id)]);
+  if (node.globalId) {
+    refs.add(node.globalId);
+  }
+  return [...refs];
+}
+function edgeSourceRefs(edge) {
+  return [edge.fromNodeId, edge.sourceGlobalId, edge.fromGlobalId].flatMap(
+    (value) => value ? [value] : []
+  );
+}
+function edgeTargetRefs(edge) {
+  return [edge.toNodeId, edge.targetGlobalId, edge.toGlobalId].flatMap(
+    (value) => value ? [value] : []
+  );
+}
+function primaryEdgeSourceRef(edge) {
+  return edge.sourceGlobalId ?? edge.fromGlobalId ?? edge.fromNodeId;
+}
+function primaryEdgeTargetRef(edge) {
+  return edge.targetGlobalId ?? edge.toGlobalId ?? edge.toNodeId;
+}
+function hasVisitedNode(node, visited) {
+  return nodeEndpointRefs2(node).some((ref) => visited.has(ref));
+}
+function markVisitedNode(node, visited) {
+  for (const ref of nodeEndpointRefs2(node)) {
+    visited.add(ref);
+  }
+}
+async function resolveNodeRefSoft(ctx, nodeRef) {
+  const normalizedId = ctx.db.normalizeId?.("epistemicNodes", nodeRef) ?? readConvexId4(nodeRef);
+  if (normalizedId) {
+    try {
+      const direct = readEdgeNodeRow2(await ctx.db.get(normalizedId));
+      if (direct) {
+        return direct;
+      }
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[epistemicEdges] Direct node-ref lookup failed",
+        { error, nodeRef }
+      );
+    }
+  }
+  return readEdgeNodeRow2(
+    await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", nodeRef)).first()
+  );
+}
+async function collectNodeReferenceIds(ctx, nodeRef) {
+  const refs = /* @__PURE__ */ new Set([nodeRef]);
+  const node = await resolveNodeRefSoft(ctx, nodeRef);
+  if (node) {
+    for (const ref of nodeEndpointRefs2(node)) {
+      refs.add(ref);
+    }
+  }
+  return [...refs];
+}
+async function collectEdgesFromRefs(ctx, refs, edgeType) {
+  const reads = [];
+  for (const ref of refs) {
+    reads.push(
+      edgeType ? ctx.db.query("epistemicEdges").withIndex(
+        "by_from_type",
+        (q) => q.eq("fromNodeId", ref).eq("edgeType", edgeType)
+      ).collect() : ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", ref)).collect(),
+      ctx.db.query("epistemicEdges").withIndex("by_source_global_id", (q) => q.eq("sourceGlobalId", ref)).collect()
+    );
+  }
+  const edges = readEdgeRows2((await Promise.all(reads)).flat());
+  return dedupeEdges(filterEdgesByType(edges, edgeType));
+}
+async function collectEdgesToRefs(ctx, refs, edgeType) {
+  const reads = [];
+  for (const ref of refs) {
+    reads.push(
+      edgeType ? ctx.db.query("epistemicEdges").withIndex(
+        "by_to_type",
+        (q) => q.eq("toNodeId", ref).eq("edgeType", edgeType)
+      ).collect() : ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", ref)).collect(),
+      ctx.db.query("epistemicEdges").withIndex("by_target_global_id", (q) => q.eq("targetGlobalId", ref)).collect()
+    );
+  }
+  const edges = readEdgeRows2((await Promise.all(reads)).flat());
+  return dedupeEdges(filterEdgesByType(edges, edgeType));
+}
+async function collectEdgesFromNodeRef(ctx, nodeRef, edgeType) {
+  return collectEdgesFromRefs(
+    ctx,
+    await collectNodeReferenceIds(ctx, nodeRef),
+    edgeType
+  );
+}
+async function collectEdgesToNodeRef(ctx, nodeRef, edgeType) {
+  return collectEdgesToRefs(
+    ctx,
+    await collectNodeReferenceIds(ctx, nodeRef),
+    edgeType
+  );
+}
+async function collectEdgesBetweenRefs(ctx, fromRefs, toRefs) {
+  const reads = [];
+  for (const fromRef of fromRefs) {
+    for (const toRef of toRefs) {
+      reads.push(
+        ctx.db.query("epistemicEdges").withIndex(
+          "by_from_to",
+          (q) => q.eq("fromNodeId", fromRef).eq("toNodeId", toRef)
+        ).collect()
+      );
+    }
+    reads.push(
+      ctx.db.query("epistemicEdges").withIndex(
+        "by_source_global_id",
+        (q) => q.eq("sourceGlobalId", fromRef)
+      ).collect()
+    );
+  }
+  for (const toRef of toRefs) {
+    reads.push(
+      ctx.db.query("epistemicEdges").withIndex("by_target_global_id", (q) => q.eq("targetGlobalId", toRef)).collect()
+    );
+  }
+  const fromRefSet = new Set(fromRefs);
+  const toRefSet = new Set(toRefs);
+  const edges = readEdgeRows2((await Promise.all(reads)).flat()).filter(
+    (edge) => edgeSourceRefs(edge).some((ref) => fromRefSet.has(ref)) && edgeTargetRefs(edge).some((ref) => toRefSet.has(ref))
+  );
+  return dedupeEdges(edges);
+}
+async function collectEdgesBetweenNodeRefs(ctx, fromNodeRef, toNodeRef) {
+  const [fromRefs, toRefs] = await Promise.all([
+    collectNodeReferenceIds(ctx, fromNodeRef),
+    collectNodeReferenceIds(ctx, toNodeRef)
+  ]);
+  return collectEdgesBetweenRefs(ctx, fromRefs, toRefs);
+}
+function buildLineageTraversalConfig(args) {
+  const mode = args.mode ?? "anchor_down";
+  return {
+    maxDepth: args.maxDepth ?? 10,
+    mode,
+    minLayer: args.minLayer ?? getDefaultMinLayer(mode),
+    maxLayer: args.maxLayer ?? 4
+  };
+}
+function buildLineageQueueSeed(node) {
+  return {
+    node,
+    depth: 0,
+    currentLayer: node.epistemicLayer ?? getNodeLayer(node.nodeType)
+  };
+}
+function shouldSkipLineageNode(item, state, visited) {
+  if (item.depth >= state.maxDepth) {
+    return true;
+  }
+  return hasVisitedNode(item.node, visited);
+}
+function resolveLineageTargetLayer(edge, targetNode) {
+  return edge.toLayer ?? targetNode.epistemicLayer ?? getNodeLayer(targetNode.nodeType);
+}
+function collectDerivedFromEdges(ctx, node) {
+  return collectEdgesFromRefs(
+    ctx,
+    nodeEndpointRefs2(node),
+    DERIVED_FROM_EDGE_TYPE
+  );
+}
+function shouldAdvanceLineage(currentLayer, targetLayer, state) {
+  return shouldContinueTraversal(currentLayer, targetLayer, {
+    mode: state.mode,
+    minLayer: state.minLayer,
+    maxLayer: state.maxLayer
+  });
+}
+async function appendLineageEdges(ctx, current, state, lineage, queue, visited) {
+  const lineageEdges = await collectDerivedFromEdges(ctx, current.node);
+  for (const edge of lineageEdges) {
+    const targetRef = primaryEdgeTargetRef(edge);
+    if (!targetRef) {
+      continue;
+    }
+    const targetNode = await resolveNodeRefSoft(ctx, targetRef);
+    if (!targetNode || hasVisitedNode(targetNode, visited)) {
+      continue;
+    }
+    const targetLayer = resolveLineageTargetLayer(edge, targetNode);
+    if (!shouldAdvanceLineage(current.currentLayer, targetLayer, state)) {
+      continue;
+    }
+    const nextDepth = current.depth + 1;
+    lineage.push({
+      node: targetNode,
+      depth: nextDepth,
+      edgeType: edge.edgeType,
+      layer: targetLayer
+    });
+    queue.push({
+      node: targetNode,
+      depth: nextDepth,
+      currentLayer: targetLayer
+    });
+  }
+}
+var get = query({
+  args: { edgeId: v.id("epistemicEdges") },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => await ctx.db.get(args.edgeId)
+});
+var getByGlobalId = query({
+  args: { globalId: v.string() },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first()
+});
+var getFromNode = query({
+  args: {
+    fromNodeId: v.id("epistemicNodes"),
+    edgeType: v.optional(edgeTypeValidator)
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => await collectEdgesFromNodeRef(ctx, String(args.fromNodeId), args.edgeType)
+});
+var getToNode = query({
+  args: {
+    toNodeId: v.id("epistemicNodes"),
+    edgeType: v.optional(edgeTypeValidator)
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => await collectEdgesToNodeRef(ctx, String(args.toNodeId), args.edgeType)
+});
+var getBySourceNode = query({
+  args: {
+    sourceNodeId: v.string(),
+    edgeType: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => await collectEdgesFromNodeRef(ctx, args.sourceNodeId, args.edgeType)
+});
+var getByTargetNode = query({
+  args: {
+    targetNodeId: v.string(),
+    edgeType: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => await collectEdgesToNodeRef(ctx, args.targetNodeId, args.edgeType)
+});
+var getBetween = query({
+  args: {
+    fromNodeId: v.id("epistemicNodes"),
+    toNodeId: v.id("epistemicNodes"),
+    edgeType: v.optional(edgeTypeValidator)
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => filterEdgesByType(
+    await collectEdgesBetweenNodeRefs(
+      ctx,
+      String(args.fromNodeId),
+      String(args.toNodeId)
+    ),
+    args.edgeType
+  )
+});
+var getByNodes = query({
+  args: {
+    fromNodeId: v.id("epistemicNodes"),
+    toNodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => (await collectEdgesBetweenNodeRefs(
+    ctx,
+    String(args.fromNodeId),
+    String(args.toNodeId)
+  ))[0] ?? null
+});
+var getByProjectAndType = query({
+  args: {
+    ...optionalScopeArgs,
+    edgeType: edgeTypeValidator
+  },
+  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(
+        "[epistemicEdges] Failed to resolve getAll scope",
+        {
+          error,
+          projectId: args.projectId,
+          topicId: args.topicId
+        }
+      );
+      return [];
+    }
+    const projectEdges = await collectScopedEdges(ctx, scope, 5e3);
+    return projectEdges.filter(
+      (e) => e.edgeType === args.edgeType && edgeMatchesWorkspaceReasoningScope(e, scope)
+    ).slice(0, 5e3);
+  }
+});
+var getByProject = query({
+  args: {
+    ...optionalScopeArgs,
+    userId: v.optional(v.string()),
+    limit: v.optional(v.number())
+  },
+  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(
+        "[epistemicEdges] Failed to resolve getByProject scope",
+        {
+          error,
+          projectId: args.projectId,
+          topicId: args.topicId
+        }
+      );
+      return [];
+    }
+    if (args.userId) {
+      const hasAccess = await checkScopeAccess(
+        ctx,
+        String(scope.topicId ?? scope.projectId),
+        args.userId
+      );
+      if (!hasAccess) {
+        return [];
+      }
+    }
+    const pageSize = Math.max(1, Math.min(Math.floor(args.limit ?? 500), 2e3));
+    const edges = await collectScopedEdges(
+      ctx,
+      scope,
+      Math.min(pageSize * 3, 6e3)
     );
+    return edges.filter((edge) => edgeMatchesWorkspaceReasoningScope(edge, scope)).slice(0, pageSize);
   }
-}
-async function insertEpistemicEdge(ctx, doc) {
-  assertUuidV7Identity("epistemicEdges", doc.globalId);
-  assertStorageEdgeVocabulary(doc.edgeType);
-  if (!doc.fromNodeId || typeof doc.fromNodeId !== "string") {
-    throw new Error(
-      "edge_endpoint_missing: epistemicEdges insert requires a non-empty fromNodeId"
+});
+var listAll = query({
+  args: {
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const pageSize = Math.max(
+      1,
+      Math.min(Math.floor(args.limit ?? 5e3), 1e4)
     );
+    return await ctx.db.query("epistemicEdges").order("desc").take(pageSize);
   }
-  if (!doc.toNodeId || typeof doc.toNodeId !== "string") {
-    throw new Error(
-      "edge_endpoint_missing: epistemicEdges insert requires a non-empty toNodeId"
+});
+var findContradictions = query({
+  args: {
+    nodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const edges = await collectEdgesToNodeRef(
+      ctx,
+      String(args.nodeId),
+      "informs"
     );
+    return edges.filter((e) => (e.weight ?? 0) < 0);
   }
-  await assertExistingNodeEndpoint(ctx, "fromNodeId", doc.fromNodeId);
-  await assertExistingNodeEndpoint(ctx, "toNodeId", doc.toNodeId);
-  if (doc.fromNodeType && doc.toNodeType && doc.edgeType !== "extracted_from") {
-    assertEdgePolicyAllowed(
-      edgePolicyManifest,
-      doc.edgeType,
-      {
-        kind: "epistemic_node",
-        nodeId: doc.fromNodeId,
-        nodeType: doc.fromNodeType
-      },
-      {
-        kind: "epistemic_node",
-        nodeId: doc.toNodeId,
-        nodeType: doc.toNodeType
-      }
+});
+var findSupport = query({
+  args: {
+    nodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const edges = await collectEdgesToNodeRef(
+      ctx,
+      String(args.nodeId),
+      "informs"
     );
+    return edges.filter((e) => (e.weight ?? 0) >= 0);
   }
-  return ctx.db.insert("epistemicEdges", doc);
-}
-
-// src/epistemicEdges.handlers.ts
-var mirrorEdgeToConvex = internalMutation({
+});
+var getLineage = query({
   args: {
-    globalId: v.string(),
-    fromGlobalId: v.string(),
-    toGlobalId: v.string(),
-    edgeType: v.string(),
-    weight: v.optional(v.number()),
-    confidence: v.optional(v.number()),
-    context: v.optional(v.string()),
-    derivationType: v.optional(v.string()),
-    createdBy: v.string(),
-    ...optionalScopeArgs,
-    fromLayer: v.optional(v.string()),
-    toLayer: v.optional(v.string()),
-    fromNodeType: v.optional(v.string()),
-    toNodeType: v.optional(v.string()),
-    reasoningMethod: v.optional(v.string()),
-    logicalRole: v.optional(v.string()),
-    temporalClass: v.optional(v.string()),
-    validFrom: v.optional(v.number()),
-    validUntil: v.optional(v.number()),
-    constraint: v.optional(v.string()),
-    propagation: v.optional(v.string()),
-    blocking: v.optional(v.boolean()),
-    implicit: v.optional(v.boolean()),
-    conditionalA: v.optional(subjectiveOpinionValidator),
-    conditionalNotA: v.optional(subjectiveOpinionValidator)
+    nodeId: v.id("epistemicNodes"),
+    maxDepth: v.optional(v.number()),
+    // Phase 2D: Layer-aware traversal options
+    minLayer: v.optional(v.number()),
+    // 1=L1, 2=L2, 3=L3, 4=L4
+    maxLayer: v.optional(v.number()),
+    mode: v.optional(
+      v.union(
+        v.literal("anchor_down"),
+        v.literal("anchor_up"),
+        v.literal("same_layer"),
+        v.literal("decision_trace")
+      )
+    )
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const fromNode = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", args.fromGlobalId)).first();
-    if (!fromNode) {
-      console.log(
-        `[Dual-Write] Skipping mirror - source node not in Convex: ${args.fromGlobalId}`
-      );
-      return buildEdgeMirrorSkippedResult();
-    }
-    const toNode = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", args.toGlobalId)).first();
-    const existing = await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first();
-    if (existing) {
-      console.log(`[Dual-Write] Edge already exists: ${args.globalId}`);
-      return buildEdgeMirrorWriteResult(existing._id, true);
+    const traversalState = buildLineageTraversalConfig(args);
+    const lineage = [];
+    const queue = [];
+    const visited = /* @__PURE__ */ new Set();
+    const startNode = readEdgeNodeRow2(await ctx.db.get(args.nodeId));
+    if (!startNode) {
+      return lineage;
     }
-    if (!toNode) {
-      console.log(
-        `[Dual-Write] Skipping mirror - to-node not in Convex: ${args.toGlobalId} (edge ${args.globalId} type ${args.edgeType})`
+    queue.push(buildLineageQueueSeed(startNode));
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!current || shouldSkipLineageNode(current, traversalState, visited)) {
+        continue;
+      }
+      markVisitedNode(current.node, visited);
+      await appendLineageEdges(
+        ctx,
+        current,
+        traversalState,
+        lineage,
+        queue,
+        visited
       );
-      return buildEdgeMirrorSkippedResult();
     }
-    const now = Date.now();
-    const edgeId = await insertEpistemicEdge(ctx, {
-      globalId: args.globalId,
-      // C2-RR.4 Defect E — endpoints are canonical node globalIds, not Convex
-      // doc ids. fromNode/toNode are resolved by_globalId above, so their
-      // stored globalId equals args.from/toGlobalId; persisting the doc _id here
-      // was the "mixed _id/globalId" defect.
-      fromNodeId: fromNode.globalId,
-      toNodeId: toNode.globalId,
-      sourceGlobalId: args.fromGlobalId,
-      targetGlobalId: args.toGlobalId,
-      // Preserve the canonical string value even when the local schema lags.
-      edgeType: args.edgeType,
-      weight: args.weight,
-      confidence: args.confidence,
-      context: args.context,
-      derivationType: args.derivationType,
-      constraint: args.constraint,
-      propagation: args.propagation,
-      blocking: args.blocking,
-      implicit: args.implicit,
-      conditionalA: args.conditionalA,
-      conditionalNotA: args.conditionalNotA,
-      createdBy: args.createdBy,
-      createdAt: now,
-      updatedAt: now,
-      topicId: args.projectId,
-      fromLayer: args.fromLayer,
-      toLayer: args.toLayer,
-      fromNodeType: args.fromNodeType,
-      toNodeType: args.toNodeType,
-      reasoningMethod: args.reasoningMethod,
-      logicalRole: args.logicalRole,
-      temporalClass: args.temporalClass,
-      validFrom: args.validFrom,
-      validUntil: args.validUntil
-    });
-    console.log(
-      `[Dual-Write] Mirrored edge to Convex: ${args.globalId} (${args.edgeType})`
-    );
-    return buildEdgeMirrorWriteResult(edgeId, false);
+    return lineage;
   }
 });
-var deleteEdgeFromConvex = internalMutation({
+var getEvidenceForBelief = query({
   args: {
-    globalId: v.string()
+    beliefNodeId: v.id("epistemicNodes")
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const existing = await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first();
-    if (!existing) {
-      return buildEdgeMirrorMissingResult();
-    }
-    await ctx.db.delete(existing._id);
-    console.log(`[Dual-Write] Deleted edge from Convex: ${args.globalId}`);
-    return buildEdgeStatusSuccessResult();
+    const informsEdges = await collectEdgesToNodeRef(
+      ctx,
+      String(args.beliefNodeId),
+      "informs"
+    );
+    const supportEdges = informsEdges.filter((e) => (e.weight ?? 0) >= 0);
+    const contradictEdges = informsEdges.filter((e) => (e.weight ?? 0) < 0);
+    const supportingEvidence = await Promise.all(
+      supportEdges.map(async (edge) => {
+        const sourceRef = primaryEdgeSourceRef(edge);
+        return {
+          edge,
+          node: sourceRef ? await resolveNodeRefSoft(ctx, sourceRef) : null
+        };
+      })
+    );
+    const contradictingEvidence = await Promise.all(
+      contradictEdges.map(async (edge) => {
+        const sourceRef = primaryEdgeSourceRef(edge);
+        return {
+          edge,
+          node: sourceRef ? await resolveNodeRefSoft(ctx, sourceRef) : null
+        };
+      })
+    );
+    const filteredSupporting = supportingEvidence.filter(
+      (e) => e.node !== null
+    );
+    const filteredContradicting = contradictingEvidence.filter(
+      (e) => e.node !== null
+    );
+    return {
+      supporting: filteredSupporting,
+      contradicting: filteredContradicting,
+      supportCount: filteredSupporting.length,
+      contradictCount: filteredContradicting.length
+    };
   }
 });
-var updateEdgeInConvex = internalMutation({
+var getClusterEdges = query({
   args: {
-    globalId: v.string(),
-    weight: v.optional(v.number()),
-    confidence: v.optional(v.number()),
-    context: v.optional(v.string()),
-    derivationType: v.optional(v.string()),
-    constraint: v.optional(v.string()),
-    propagation: v.optional(v.string()),
-    blocking: v.optional(v.boolean()),
-    implicit: v.optional(v.boolean()),
-    conditionalA: v.optional(subjectiveOpinionValidator),
-    conditionalNotA: v.optional(subjectiveOpinionValidator)
+    beliefIds: v.array(v.string())
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const existing = await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first();
-    if (!existing) {
-      return buildEdgeMirrorMissingResult();
-    }
-    const updates = {
-      updatedAt: Date.now()
-    };
-    if (args.weight !== void 0) {
-      updates.weight = args.weight;
-    }
-    if (args.confidence !== void 0) {
-      updates.confidence = args.confidence;
-    }
-    if (args.context !== void 0) {
-      updates.context = args.context;
-    }
-    if (args.derivationType !== void 0) {
-      updates.derivationType = args.derivationType;
-    }
-    if (args.constraint !== void 0) {
-      updates.constraint = args.constraint;
-    }
-    if (args.propagation !== void 0) {
-      updates.propagation = args.propagation;
-    }
-    if (args.blocking !== void 0) {
-      updates.blocking = args.blocking;
-    }
-    if (args.implicit !== void 0) {
-      updates.implicit = args.implicit;
-    }
-    if (args.conditionalA !== void 0) {
-      updates.conditionalA = args.conditionalA;
+    if (args.beliefIds.length === 0) {
+      return [];
     }
-    if (args.conditionalNotA !== void 0) {
-      updates.conditionalNotA = args.conditionalNotA;
+    const beliefIdSet = /* @__PURE__ */ new Set();
+    for (const beliefId of args.beliefIds) {
+      for (const ref of await collectNodeReferenceIds(ctx, beliefId)) {
+        beliefIdSet.add(ref);
+      }
     }
-    await ctx.db.patch(existing._id, updates);
-    console.log(`[Dual-Write] Updated edge in Convex: ${args.globalId}`);
-    return buildEdgeStatusSuccessResult();
+    const allEdges = readEdgeRows2(
+      await ctx.db.query("epistemicEdges").collect()
+    );
+    return allEdges.filter((edge) => {
+      const fromInCluster = edgeSourceRefs(edge).some(
+        (ref) => beliefIdSet.has(ref)
+      );
+      const toInCluster = edgeTargetRefs(edge).some(
+        (ref) => beliefIdSet.has(ref)
+      );
+      return fromInCluster && toInCluster;
+    });
   }
 });
 
-// src/epistemicEdges.ts
-var getByTopic = getByProject;
-
-export { batchCreate, cleanupDeprecatedEdges, create, deleteEdgeFromConvex, deleteEdges, edgeTypeValidator, epistemicLayerValidator, findContradictions, findSupport, get, getBetween, getByGlobalId, getByNodes, getByProject, getByProjectAndType, getBySourceNode, getByTargetNode, getByTopic, getClusterEdges, getEvidenceForBelief, getFromNode, getLineage, getToNode, listAll, mirrorEdgeToConvex, remove, removeBetween, update, updateEdgeInConvex };
+export { batchCreate, cleanupDeprecatedEdges, create, deleteEdgeFromConvex, deleteEdges, edgeTypeValidator, epistemicLayerValidator, findContradictions, findSupport, get, getBetween, getByGlobalId, getByNodes, getByProject, getByProjectAndType, getBySourceNode, getByTargetNode, getByProject as getByTopic, getClusterEdges, getEvidenceForBelief, getFromNode, getLineage, getToNode, listAll, mirrorEdgeToConvex, remove, removeBetween, update, updateEdgeInConvex };
 //# sourceMappingURL=epistemicEdges.js.map
 //# sourceMappingURL=epistemicEdges.js.map