@lucern/graph-sync 0.3.0-alpha.10

package/dist/index.js

@@ -0,0 +1,3249 @@
+import neo4j from 'neo4j-driver';
+import { v } from 'convex/values';
+import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
+import { NODE_TYPE_TO_LABEL, EDGE_TYPE_TO_REL, getNeo4jRelType } from '@lucern/graph-primitives/graphTypes';
+import { componentsGeneric, anyApi, internalActionGeneric, actionGeneric, internalMutationGeneric, internalQueryGeneric } from 'convex/server';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/neo4jDriver.ts
+var neo4jDriver_exports = {};
+__export(neo4jDriver_exports, {
+  COMPLEX_QUERY_TIMEOUT_MS: () => COMPLEX_QUERY_TIMEOUT_MS,
+  DEFAULT_QUERY_TIMEOUT_MS: () => DEFAULT_QUERY_TIMEOUT_MS,
+  batchUpsertEdges: () => batchUpsertEdges,
+  batchUpsertNodes: () => batchUpsertNodes,
+  closeDriver: () => closeDriver,
+  deleteEdge: () => deleteEdge,
+  deleteNode: () => deleteNode,
+  getConnectionInfo: () => getConnectionInfo,
+  healthCheck: () => healthCheck,
+  runBatchTransaction: () => runBatchTransaction,
+  runCypher: () => runCypher,
+  runWriteTransaction: () => runWriteTransaction,
+  upsertEdge: () => upsertEdge,
+  upsertNode: () => upsertNode,
+  validateLabel: () => validateLabel,
+  validateRelType: () => validateRelType
+});
+var VALID_NODE_LABELS = /* @__PURE__ */ new Set([
+  // Ontological
+  "ValueChain",
+  "Function",
+  "FinSector",
+  "Company",
+  "Person",
+  "Investor",
+  // Epistemic
+  "Theme",
+  "Belief",
+  "Question",
+  "Evidence",
+  "Source",
+  "Decision",
+  "Sprint",
+  "Claim",
+  "Synthesis",
+  "Answer"
+]);
+var VALID_RELATIONSHIP_TYPES = /* @__PURE__ */ new Set([
+  // Cross-layer edges
+  "EXTRACTED_FROM",
+  "ANSWERS",
+  "RESPONDS_TO",
+  "INFORMS",
+  "QUALIFIES",
+  "TESTS",
+  "EXPLORES",
+  "BASED_ON",
+  "RELATES_TO_THESIS",
+  "BELONGS_TO",
+  "PLAYS_THEME",
+  // Same-layer edges
+  "SUPERSEDES",
+  "SAME_AS",
+  "DEPENDS_ON",
+  "REINFORCES",
+  "PARENT_OF",
+  "CHILD_OF",
+  "FALSIFIED_BY",
+  "EXCLUSIVE_WITH",
+  "COLLAPSES_IF",
+  "CASCADE_FROM",
+  "STRENGTHENED_BY",
+  "WEAKENED_BY",
+  "ALTERNATIVE_TO",
+  "SUBSUMES",
+  "VALIDATED_BY",
+  "REQUIRED_FOR",
+  "PREREQUISITE_FOR",
+  "PARALLEL_TO",
+  "CORROBORATES",
+  "EXTENDS",
+  "SAME_SOURCE_AS",
+  "SAME_THEME_AS",
+  // Ontological
+  "EVALUATES",
+  "PERSPECTIVE_ON",
+  "WORKS_AT",
+  "PARTICIPATES_IN",
+  "PERFORMS",
+  "FUNCTION_IN",
+  "IMPACTS",
+  "INVESTED_IN",
+  "RAISED_FROM",
+  "BASED_ON_BELIEF",
+  "BASED_ON_QUESTION",
+  "BLOCKED_BY_CONTRADICTION",
+  "INFORMED_BY_THEME"
+]);
+function validateLabel(label) {
+  if (!VALID_NODE_LABELS.has(label)) {
+    throw new Error(
+      `[Neo4j Security] Invalid node label: ${label}. Must be one of: ${Array.from(VALID_NODE_LABELS).join(", ")}`
+    );
+  }
+}
+function validateRelType(relType) {
+  if (!VALID_RELATIONSHIP_TYPES.has(relType)) {
+    throw new Error(
+      `[Neo4j Security] Invalid relationship type: ${relType}. Must be one of: ${Array.from(VALID_RELATIONSHIP_TYPES).join(", ")}`
+    );
+  }
+}
+var driver = null;
+function getDriver() {
+  if (!driver) {
+    const uri = process.env.NEO4J_URI;
+    const user = process.env.NEO4J_USER;
+    const password = process.env.NEO4J_PASSWORD;
+    if (!uri || !user || !password) {
+      throw new Error(
+        "[Neo4j Driver] Missing credentials. Set NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD via `npx convex env set`"
+      );
+    }
+    driver = neo4j.driver(uri, neo4j.auth.basic(user, password), {
+      // Connection pool settings
+      maxConnectionPoolSize: 50,
+      connectionAcquisitionTimeout: 3e4,
+      // Logging
+      logging: {
+        level: "warn",
+        logger: (level, message) => console.log(`[Neo4j ${level}] ${message}`)
+      }
+    });
+  }
+  return driver;
+}
+var DEFAULT_QUERY_TIMEOUT_MS = 3e4;
+var COMPLEX_QUERY_TIMEOUT_MS = 6e4;
+function toNeo4jParams(params) {
+  const result = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (typeof value === "number" && Number.isInteger(value)) {
+      result[key] = neo4j.int(value);
+    } else if (Array.isArray(value)) {
+      result[key] = value.map(
+        (v5) => typeof v5 === "number" && Number.isInteger(v5) ? neo4j.int(v5) : v5
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+async function runCypher(query, params = {}, timeoutMs = DEFAULT_QUERY_TIMEOUT_MS) {
+  const neo4jDriver = getDriver();
+  const session = neo4jDriver.session();
+  try {
+    const neo4jParams = toNeo4jParams(params);
+    const result = await session.run(query, neo4jParams, {
+      timeout: neo4j.int(timeoutMs)
+    });
+    return result.records.map((record) => {
+      const obj = {};
+      for (const key of record.keys) {
+        const field = String(key);
+        obj[field] = convertNeo4jValue(record.get(field));
+      }
+      return obj;
+    });
+  } finally {
+    await session.close();
+  }
+}
+async function runWriteTransaction(query, params = {}, timeoutMs = DEFAULT_QUERY_TIMEOUT_MS) {
+  const neo4jDriver = getDriver();
+  const session = neo4jDriver.session();
+  try {
+    const neo4jParams = toNeo4jParams(params);
+    const result = await session.executeWrite(
+      async (tx) => {
+        return await tx.run(query, neo4jParams);
+      },
+      { timeout: timeoutMs }
+    );
+    return result.records.map((record) => {
+      const obj = {};
+      for (const key of record.keys) {
+        const field = String(key);
+        obj[field] = convertNeo4jValue(record.get(field));
+      }
+      return obj;
+    });
+  } finally {
+    await session.close();
+  }
+}
+async function runBatchTransaction(queries, timeoutMs = COMPLEX_QUERY_TIMEOUT_MS) {
+  const neo4jDriver = getDriver();
+  const session = neo4jDriver.session();
+  try {
+    await session.executeWrite(
+      async (tx) => {
+        for (const { query, params } of queries) {
+          await tx.run(query, params);
+        }
+      },
+      { timeout: timeoutMs }
+    );
+  } finally {
+    await session.close();
+  }
+}
+async function upsertNode(label, globalId, properties) {
+  validateLabel(label);
+  await runWriteTransaction(
+    `
+    MERGE (n:${label} {globalId: $globalId})
+    SET n += $properties
+    SET n.updatedAt = timestamp()
+    `,
+    { globalId, properties }
+  );
+}
+async function deleteNode(globalId) {
+  await runWriteTransaction(
+    `
+    MATCH (n {globalId: $globalId})
+    DETACH DELETE n
+    `,
+    { globalId }
+  );
+}
+async function batchUpsertNodes(label, nodes) {
+  if (nodes.length === 0) {
+    return;
+  }
+  validateLabel(label);
+  await runWriteTransaction(
+    `
+    UNWIND $nodes as node
+    MERGE (n:${label} {globalId: node.globalId})
+    SET n += node.properties
+    SET n.updatedAt = timestamp()
+    `,
+    { nodes }
+  );
+}
+async function upsertEdge(relType, globalId, fromGlobalId, toGlobalId, properties = {}) {
+  validateRelType(relType);
+  await runWriteTransaction(
+    `
+    MATCH (from {globalId: $fromGlobalId})
+    MATCH (to {globalId: $toGlobalId})
+    MERGE (from)-[r:${relType} {globalId: $globalId}]->(to)
+    SET r += $properties
+    SET r.updatedAt = timestamp()
+    `,
+    { globalId, fromGlobalId, toGlobalId, properties }
+  );
+}
+async function deleteEdge(globalId) {
+  await runWriteTransaction(
+    `
+    MATCH ()-[r {globalId: $globalId}]->()
+    DELETE r
+    `,
+    { globalId }
+  );
+}
+async function batchUpsertEdges(edges) {
+  if (edges.length === 0) {
+    return;
+  }
+  const byType = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const existing = byType.get(edge.relType) || [];
+    existing.push(edge);
+    byType.set(edge.relType, existing);
+  }
+  const queries = [];
+  for (const [relType, typeEdges] of byType) {
+    queries.push({
+      query: `
+        UNWIND $edges as edge
+        MATCH (from {globalId: edge.fromGlobalId})
+        MATCH (to {globalId: edge.toGlobalId})
+        MERGE (from)-[r:${relType} {globalId: edge.globalId}]->(to)
+        SET r += edge.properties
+        SET r.updatedAt = timestamp()
+      `,
+      params: {
+        edges: typeEdges.map((e) => ({
+          globalId: e.globalId,
+          fromGlobalId: e.fromGlobalId,
+          toGlobalId: e.toGlobalId,
+          properties: e.properties || {}
+        }))
+      }
+    });
+  }
+  await runBatchTransaction(queries);
+}
+async function healthCheck() {
+  try {
+    const result = await runCypher(
+      "MATCH (n) RETURN count(n) as count LIMIT 1"
+    );
+    return {
+      healthy: true,
+      nodeCount: result[0]?.count || 0
+    };
+  } catch (error) {
+    return {
+      healthy: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+function getConnectionInfo() {
+  return {
+    uri: process.env.NEO4J_URI,
+    user: process.env.NEO4J_USER,
+    configured: Boolean(
+      process.env.NEO4J_URI && process.env.NEO4J_USER && process.env.NEO4J_PASSWORD
+    )
+  };
+}
+function convertNeo4jValue(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (neo4j.isInt(value)) {
+    return neo4j.integer.toNumber(value);
+  }
+  if (neo4j.isDate(value) || neo4j.isDateTime(value) || neo4j.isTime(value)) {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.map(convertNeo4jValue);
+  }
+  if (value && typeof value === "object" && "properties" in value) {
+    const nodeObj = value;
+    const result = {};
+    for (const [k, v5] of Object.entries(nodeObj.properties)) {
+      result[k] = convertNeo4jValue(v5);
+    }
+    return result;
+  }
+  if (typeof value === "object") {
+    const result = {};
+    for (const [k, v5] of Object.entries(value)) {
+      result[k] = convertNeo4jValue(v5);
+    }
+    return result;
+  }
+  return value;
+}
+async function closeDriver() {
+  if (driver) {
+    await driver.close();
+    driver = null;
+  }
+}
+
+// src/neo4jEdgeAPI.ts
+var neo4jEdgeAPI_exports = {};
+__export(neo4jEdgeAPI_exports, {
+  DUAL_WRITE_EDGE_TYPES: () => DUAL_WRITE_EDGE_TYPES,
+  createEdge: () => createEdge,
+  deleteEdge: () => deleteEdge2,
+  getEdge: () => getEdge,
+  needsDualWrite: () => needsDualWrite,
+  retryProjectionByGlobalId: () => retryProjectionByGlobalId,
+  updateEdge: () => updateEdge
+});
+componentsGeneric();
+var internal = anyApi;
+var action = actionGeneric;
+var internalAction = internalActionGeneric;
+var internalMutation = internalMutationGeneric;
+var internalQuery = internalQueryGeneric;
+
+// src/neo4jEdgeAPI.ts
+var DUAL_WRITE_EDGE_TYPES = [
+  "supports",
+  "informs",
+  "tests",
+  "depends_on",
+  "derived_from",
+  "contains",
+  "supersedes",
+  "extracted_from",
+  "responds_to",
+  "based_on",
+  "answers",
+  "belongs_to",
+  "relates_to_thesis",
+  "corroborates",
+  "extends",
+  "same_source_as",
+  "same_theme_as",
+  "plays_theme",
+  "impacts",
+  "evaluates",
+  "mentioned_in",
+  "perspective_on"
+];
+function needsDualWrite(edgeType) {
+  return DUAL_WRITE_EDGE_TYPES.includes(edgeType);
+}
+function normalizeEdgeType(edgeType) {
+  const normalized = edgeType.trim().toLowerCase();
+  if (!/^[a-z0-9_]+$/u.test(normalized)) {
+    throw new Error(`[Neo4j Edge API] Invalid edge type: ${edgeType}`);
+  }
+  return normalized;
+}
+function resolveRelationshipType(edgeType) {
+  const relType = getNeo4jRelType(edgeType);
+  if (!/^[A-Z0-9_]+$/u.test(relType)) {
+    throw new Error(`[Neo4j Edge API] Invalid relationship type: ${relType}`);
+  }
+  return relType;
+}
+function readStringProperty(source, key) {
+  const value = source?.[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function readNumberProperty(source, key) {
+  const value = source?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function metadataSummary(metadata) {
+  if (!metadata) {
+    return void 0;
+  }
+  return Object.entries(metadata).map(([key, value]) => `${key}=${String(value)}`).slice(0, 8).join(" | ");
+}
+async function mirrorEdgeToConvex(ctx, args) {
+  await ctx.runMutation(internal.epistemicEdges.mirrorEdgeToConvex, args);
+}
+async function queueEdgeRetry(ctx, args) {
+  await ctx.runMutation(internal.neo4jSyncHelpers.queueForRetry, {
+    entityType: "edge",
+    entityId: args.globalId,
+    operation: args.operation,
+    error: args.error
+  });
+}
+var createEdge = internalAction({
+  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()),
+    metadata: v.optional(v.any()),
+    createdBy: v.string(),
+    topicId: v.optional(v.string()),
+    tenantId: v.optional(v.string()),
+    workspaceId: v.optional(v.string()),
+    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())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const connInfo = getConnectionInfo();
+    if (!connInfo.configured) {
+      throw new Error(
+        "[Neo4j Edge API] Neo4j not configured. Set NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD"
+      );
+    }
+    const edgeType = normalizeEdgeType(args.edgeType);
+    const relType = resolveRelationshipType(edgeType);
+    const metadata = args.metadata && typeof args.metadata === "object" ? args.metadata : void 0;
+    const now = Date.now();
+    const properties = {
+      globalId: args.globalId,
+      edgeType,
+      weight: args.weight ?? 1,
+      confidence: args.confidence ?? readNumberProperty(metadata, "confidence") ?? 1,
+      context: args.context ?? metadataSummary(metadata) ?? "",
+      derivationType: args.derivationType ?? "",
+      createdBy: args.createdBy,
+      createdAt: now,
+      updatedAt: now,
+      topicId: args.topicId ?? readStringProperty(metadata, "topicId") ?? "",
+      tenantId: args.tenantId ?? readStringProperty(metadata, "tenantId") ?? "",
+      workspaceId: args.workspaceId ?? readStringProperty(metadata, "workspaceId") ?? "",
+      fromLayer: args.fromLayer ?? "",
+      toLayer: args.toLayer ?? "",
+      fromNodeType: args.fromNodeType ?? "",
+      toNodeType: args.toNodeType ?? "",
+      reasoningMethod: args.reasoningMethod ?? "",
+      logicalRole: args.logicalRole ?? "",
+      temporalClass: args.temporalClass ?? "structural",
+      validFrom: args.validFrom ?? now,
+      validUntil: args.validUntil ?? null
+    };
+    const result = await runWriteTransaction(
+      `
+      MATCH (from {globalId: $fromGlobalId})
+      MATCH (to {globalId: $toGlobalId})
+      MERGE (from)-[r:${relType} {globalId: $globalId}]->(to)
+      SET r += $properties
+      RETURN r.globalId as globalId
+      `,
+      {
+        fromGlobalId: args.fromGlobalId,
+        toGlobalId: args.toGlobalId,
+        globalId: args.globalId,
+        properties
+      }
+    );
+    if (result.length === 0) {
+      await queueEdgeRetry(ctx, {
+        globalId: args.globalId,
+        operation: "upsert",
+        error: `Source or target node not yet synced to Neo4j (from: ${args.fromGlobalId}, to: ${args.toGlobalId})`
+      });
+      if (needsDualWrite(edgeType)) {
+        try {
+          await mirrorEdgeToConvex(ctx, {
+            globalId: args.globalId,
+            fromGlobalId: args.fromGlobalId,
+            toGlobalId: args.toGlobalId,
+            edgeType,
+            weight: args.weight,
+            confidence: args.confidence,
+            context: args.context,
+            derivationType: args.derivationType,
+            createdBy: args.createdBy,
+            topicId: args.topicId,
+            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
+          });
+        } catch {
+        }
+      }
+      return {
+        success: false,
+        globalId: args.globalId,
+        edgeType,
+        queuedForRetry: true,
+        reason: "nodes_not_synced"
+      };
+    }
+    if (needsDualWrite(edgeType)) {
+      try {
+        await mirrorEdgeToConvex(ctx, {
+          globalId: args.globalId,
+          fromGlobalId: args.fromGlobalId,
+          toGlobalId: args.toGlobalId,
+          edgeType,
+          weight: args.weight,
+          confidence: args.confidence,
+          context: args.context,
+          derivationType: args.derivationType,
+          createdBy: args.createdBy,
+          topicId: args.topicId,
+          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
+        });
+      } catch (error) {
+        await queueEdgeRetry(ctx, {
+          globalId: args.globalId,
+          operation: "upsert",
+          error: `Convex mirror failed: ${error instanceof Error ? error.message : "Unknown error"}`
+        });
+      }
+    }
+    return {
+      success: true,
+      globalId: args.globalId,
+      edgeType,
+      dualWritten: needsDualWrite(edgeType)
+    };
+  }
+});
+var deleteEdge2 = internalAction({
+  args: {
+    globalId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const connInfo = getConnectionInfo();
+    if (!connInfo.configured) {
+      throw new Error("[Neo4j Edge API] Neo4j not configured");
+    }
+    await runWriteTransaction(
+      `
+      MATCH ()-[r {globalId: $globalId}]->()
+      DELETE r
+      `,
+      { globalId: args.globalId }
+    );
+    try {
+      await ctx.runMutation(internal.epistemicEdges.deleteEdgeFromConvex, {
+        globalId: args.globalId
+      });
+    } catch {
+    }
+    return { success: true };
+  }
+});
+var updateEdge = internalAction({
+  args: {
+    globalId: v.string(),
+    weight: v.optional(v.number()),
+    confidence: v.optional(v.number()),
+    context: v.optional(v.string()),
+    derivationType: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const connInfo = getConnectionInfo();
+    if (!connInfo.configured) {
+      throw new Error("[Neo4j Edge API] Neo4j not configured");
+    }
+    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;
+    }
+    const result = await runWriteTransaction(
+      `
+      MATCH ()-[r {globalId: $globalId}]->()
+      SET r += $updates
+      RETURN true as updated, r.edgeType as edgeType
+      `,
+      { globalId: args.globalId, updates }
+    );
+    if (result.length === 0) {
+      return { success: false, error: "Edge not found" };
+    }
+    const edgeType = result[0]?.edgeType;
+    if (edgeType && needsDualWrite(edgeType)) {
+      try {
+        await ctx.runMutation(internal.epistemicEdges.updateEdgeInConvex, {
+          globalId: args.globalId,
+          weight: args.weight,
+          confidence: args.confidence,
+          context: args.context,
+          derivationType: args.derivationType
+        });
+      } catch {
+        await queueEdgeRetry(ctx, {
+          globalId: args.globalId,
+          operation: "upsert",
+          error: "Convex mirror update failed"
+        });
+      }
+    }
+    return { success: true, globalId: args.globalId };
+  }
+});
+var getEdge = internalAction({
+  args: {
+    globalId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const connInfo = getConnectionInfo();
+    if (!connInfo.configured) {
+      return null;
+    }
+    const result = await runCypher(
+      `
+      MATCH (from)-[r {globalId: $globalId}]->(to)
+      RETURN r.globalId as globalId,
+             r.edgeType as edgeType,
+             from.globalId as fromGlobalId,
+             to.globalId as toGlobalId,
+             properties(r) as properties
+      LIMIT 1
+      `,
+      { globalId: args.globalId }
+    );
+    return result[0] ?? null;
+  }
+});
+var retryProjectionByGlobalId = internalAction({
+  args: {
+    globalId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const connInfo = getConnectionInfo();
+    if (!connInfo.configured) {
+      return { success: false, error: "[Neo4j Edge API] Neo4j not configured" };
+    }
+    const result = await runCypher(
+      `
+      MATCH (from)-[r {globalId: $globalId}]->(to)
+      RETURN r.edgeType as edgeType,
+             from.globalId as fromGlobalId,
+             to.globalId as toGlobalId,
+             properties(r) as properties
+      LIMIT 1
+      `,
+      { globalId: args.globalId }
+    );
+    if (result.length === 0) {
+      return {
+        success: false,
+        error: `[Neo4j Edge API] Edge not found in Neo4j: ${args.globalId}`
+      };
+    }
+    const edge = result[0];
+    if (!needsDualWrite(edge.edgeType)) {
+      return {
+        success: true,
+        skipped: true,
+        reason: "edge_type_not_projected",
+        edgeType: edge.edgeType
+      };
+    }
+    const props = edge.properties || {};
+    await mirrorEdgeToConvex(ctx, {
+      globalId: args.globalId,
+      fromGlobalId: edge.fromGlobalId,
+      toGlobalId: edge.toGlobalId,
+      edgeType: edge.edgeType,
+      weight: readNumberProperty(props, "weight"),
+      confidence: readNumberProperty(props, "confidence"),
+      context: readStringProperty(props, "context"),
+      derivationType: readStringProperty(props, "derivationType"),
+      createdBy: readStringProperty(props, "createdBy") ?? "neo4j_projection_retry",
+      topicId: readStringProperty(props, "topicId"),
+      fromLayer: readStringProperty(props, "fromLayer"),
+      toLayer: readStringProperty(props, "toLayer"),
+      fromNodeType: readStringProperty(props, "fromNodeType"),
+      toNodeType: readStringProperty(props, "toNodeType"),
+      reasoningMethod: readStringProperty(props, "reasoningMethod"),
+      logicalRole: readStringProperty(props, "logicalRole"),
+      temporalClass: readStringProperty(props, "temporalClass"),
+      validFrom: readNumberProperty(props, "validFrom"),
+      validUntil: readNumberProperty(props, "validUntil")
+    });
+    return { success: true, globalId: args.globalId, projected: true };
+  }
+});
+
+// src/neo4jQueries.ts
+var neo4jQueries_exports = {};
+__export(neo4jQueries_exports, {
+  findPotentialContradictions: () => findPotentialContradictions,
+  getAnchoringBiasDetection: () => getAnchoringBiasDetection,
+  getBeliefEvidenceGraph: () => getBeliefEvidenceGraph,
+  getBeliefHalfLife: () => getBeliefHalfLife,
+  getBeliefsByCompany: () => getBeliefsByCompany,
+  getBeliefsByEpistemicStatus: () => getBeliefsByEpistemicStatus,
+  getCausalChains: () => getCausalChains,
+  getChallengedBeliefs: () => getChallengedBeliefs,
+  getCompaniesByTheme: () => getCompaniesByTheme,
+  getConfirmationBiasScore: () => getConfirmationBiasScore,
+  getConnectedNodesGraph: () => getConnectedNodesGraph,
+  getContradictionTensionMap: () => getContradictionTensionMap,
+  getCrossThemeBeliefs: () => getCrossThemeBeliefs,
+  getEvidenceByCompany: () => getEvidenceByCompany,
+  getEvidenceByMethodology: () => getEvidenceByMethodology,
+  getEvidenceToBeliefPath: () => getEvidenceToBeliefPath,
+  getFalsificationQuestions: () => getFalsificationQuestions,
+  getFunctionsByValueChain: () => getFunctionsByValueChain,
+  getGraphStats: () => getGraphStats,
+  getHighPriorityQuestions: () => getHighPriorityQuestions,
+  getKnowledgeFrontier: () => getKnowledgeFrontier,
+  getMeetingPrepBrief: () => getMeetingPrepBrief,
+  getMinimumFalsificationSet: () => getMinimumFalsificationSet,
+  getMissingQuestionDetection: () => getMissingQuestionDetection,
+  getNecessaryEvidence: () => getNecessaryEvidence,
+  getNodeLineageGraph: () => getNodeLineageGraph,
+  getNodeRelationships: () => getNodeRelationships,
+  getNonConsensusBeliefs: () => getNonConsensusBeliefs,
+  getPeopleByCompany: () => getPeopleByCompany,
+  getPeopleByTheme: () => getPeopleByTheme,
+  getPortfolioConviction: () => getPortfolioConviction,
+  getPredictions: () => getPredictions,
+  getProprietaryEvidence: () => getProprietaryEvidence,
+  getProprietarySignals: () => getProprietarySignals,
+  getQuestionsByTheme: () => getQuestionsByTheme,
+  getQuestionsByValueChain: () => getQuestionsByValueChain,
+  getReasoningDepthScore: () => getReasoningDepthScore,
+  getSemanticBridges: () => getSemanticBridges,
+  getSemanticOrphans: () => getSemanticOrphans,
+  getSoftContradictions: () => getSoftContradictions,
+  getSourceConcentrationRisk: () => getSourceConcentrationRisk,
+  getStaleThemes: () => getStaleThemes,
+  getSurpriseDetection: () => getSurpriseDetection,
+  getThemeBeliefsGraph: () => getThemeBeliefsGraph,
+  getThemeStats: () => getThemeStats,
+  getThemeSubgraph: () => getThemeSubgraph,
+  getThemeValueChainCandidates: () => getThemeValueChainCandidates,
+  getThemesImpactingCompany: () => getThemesImpactingCompany,
+  getValueChainsByTheme: () => getValueChainsByTheme,
+  graphAwareSearch: () => graphAwareSearch,
+  queryGraph: () => queryGraph,
+  searchAllNodes: () => searchAllNodes,
+  semanticSearch: () => semanticSearch
+});
+function toInt(value, defaultValue) {
+  if (value === void 0 || value === null) {
+    return defaultValue;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.floor(parsed) : defaultValue;
+}
+function isAllowedProxyUrl(urlString) {
+  try {
+    const url = new URL(urlString);
+    const isLocalhost = url.hostname === "localhost" || url.hostname === "127.0.0.1";
+    if (!isLocalhost && url.protocol !== "https:") {
+      return false;
+    }
+    if (url.username || url.password) {
+      return false;
+    }
+    const configuredHosts = (process.env.LUCERN_GRAPH_SYNC_ALLOWED_PROXY_HOSTS || "").split(",").map((host) => host.trim().toLowerCase()).filter(Boolean);
+    if (configuredHosts.length === 0) {
+      return true;
+    }
+    const hostname = url.hostname.toLowerCase();
+    return configuredHosts.some(
+      (host) => host.startsWith(".") ? hostname.endsWith(host) : hostname === host
+    );
+  } catch {
+    console.warn("[Neo4j Queries] Rejected malformed proxy URL", urlString);
+    return false;
+  }
+}
+function createNeo4jQueryTransportSuccess(data) {
+  return { success: true, data };
+}
+function createNeo4jQueryTransportFailure(error) {
+  return { success: false, error };
+}
+function resolveProxyBaseUrl(apiBaseUrl) {
+  const resolved = apiBaseUrl || process.env.LUCERN_GRAPH_SYNC_QUERY_BASE_URL || process.env.NEXT_PUBLIC_APP_URL;
+  const normalized = resolved?.trim();
+  return normalized ? normalized.replace(/\/+$/u, "") : null;
+}
+function buildProxyEndpoint(proxyBaseUrl) {
+  const endpoint = new URL(proxyBaseUrl);
+  if (!endpoint.pathname.endsWith("/api/neo4j-query")) {
+    endpoint.pathname = `${endpoint.pathname.replace(/\/+$/u, "")}/api/neo4j-query`;
+  }
+  return endpoint.toString();
+}
+async function callNeo4jQuery(queryName, params, apiBaseUrl) {
+  const proxyUrl = resolveProxyBaseUrl(apiBaseUrl);
+  if (!proxyUrl) {
+    return createNeo4jQueryTransportFailure(
+      "Neo4j query proxy URL not configured"
+    );
+  }
+  if (!isAllowedProxyUrl(proxyUrl)) {
+    console.error(
+      "[Neo4j Queries] Blocked request to disallowed URL:",
+      proxyUrl
+    );
+    return createNeo4jQueryTransportFailure("Invalid proxy URL");
+  }
+  const syncSecret = process.env.NEO4J_SYNC_SECRET;
+  if (!syncSecret) {
+    console.error("[Neo4j Queries] NEO4J_SYNC_SECRET not configured");
+    return createNeo4jQueryTransportFailure(
+      "Neo4j sync secret not configured"
+    );
+  }
+  try {
+    const explicitTenant = typeof params.tenantId === "string" ? params.tenantId.trim() : "";
+    const scopedTopic = typeof params.topicId === "string" ? params.topicId.trim() : "";
+    const legacyProject = typeof params.projectId === "string" ? params.projectId.trim() : "";
+    const scopedTopicId = scopedTopic || legacyProject;
+    const projectTenant = scopedTopicId ? `project:${scopedTopicId}` : "";
+    const defaultTenant = process.env.LUCERN_DEFAULT_TENANT_ID?.trim() || "";
+    const tenantId = explicitTenant || projectTenant || defaultTenant;
+    if (!tenantId) {
+      return createNeo4jQueryTransportFailure(
+        "Missing required tenant context (tenantId or topicId)"
+      );
+    }
+    const scopedParams = { ...params, tenantId };
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${syncSecret}`
+    };
+    const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+    if (bypassSecret && apiBaseUrl) {
+      headers["x-vercel-protection-bypass"] = bypassSecret;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 1e4);
+    try {
+      const response = await fetch(buildProxyEndpoint(proxyUrl), {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ queryName, params: scopedParams }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const result = await response.json();
+      if (!response.ok) {
+        return createNeo4jQueryTransportFailure(result.error || "Query failed");
+      }
+      return createNeo4jQueryTransportSuccess(result.data || []);
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+      if (fetchError instanceof Error && fetchError.name === "AbortError") {
+        console.warn("[Neo4j Queries] Request timed out for:", queryName);
+        return createNeo4jQueryTransportFailure("Query timed out (10s)");
+      }
+      throw fetchError;
+    }
+  } catch (error) {
+    console.error("[Neo4j Queries] Error in callNeo4jQuery:", queryName, error);
+    return createNeo4jQueryTransportFailure(
+      error instanceof Error ? error.message : "Network error connecting to query proxy"
+    );
+  }
+}
+function withTopicScope(args, params) {
+  return args.topicId ? { ...params, topicId: args.topicId } : params;
+}
+var getNodeLineageGraph = action({
+  args: {
+    globalId: v.string(),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "nodeLineage",
+      withTopicScope(args, {
+        globalId: args.globalId
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      console.error("[Neo4j] Lineage query failed:", result.error);
+      return { lineage: [], error: result.error };
+    }
+    const lineage = result.data?.[0]?.lineage || [];
+    return { lineage };
+  }
+});
+var getConnectedNodesGraph = action({
+  args: {
+    globalId: v.string(),
+    maxHops: v.optional(v.number()),
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const maxHops = Math.min(toInt(args.maxHops, 2), 5);
+    const limit = toInt(args.limit, 50);
+    const result = await callNeo4jQuery(
+      "connectedNodes",
+      withTopicScope(args, {
+        globalId: args.globalId,
+        maxHops,
+        limit
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      console.error("[Neo4j] Connected nodes query failed:", result.error);
+      return { nodes: [], error: result.error };
+    }
+    return { nodes: result.data || [] };
+  }
+});
+var getThemeBeliefsGraph = action({
+  args: {
+    themeGlobalId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("themeBeliefs", {
+      themeGlobalId: args.themeGlobalId
+    });
+    if (!result.success) {
+      return { beliefs: [], error: result.error };
+    }
+    return {
+      beliefs: result.data?.map((r) => r.belief) || []
+    };
+  }
+});
+var getBeliefEvidenceGraph = action({
+  args: {
+    beliefGlobalId: v.string(),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "beliefEvidence",
+      withTopicScope(args, {
+        beliefGlobalId: args.beliefGlobalId
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { evidence: [], error: result.error };
+    }
+    return {
+      evidence: result.data?.map((r) => r.evidence) || []
+    };
+  }
+});
+var getCrossThemeBeliefs = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "crossThemeBeliefs",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 20)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { beliefs: [], error: result.error };
+    }
+    return {
+      beliefs: result.data?.map((r) => r.belief) || []
+    };
+  }
+});
+var findPotentialContradictions = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "potentialContradictions",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 10)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { contradictions: [], error: result.error };
+    }
+    return {
+      contradictions: result.data?.map(
+        (r) => r.contradiction
+      ) || []
+    };
+  }
+});
+var getThemeSubgraph = action({
+  args: {
+    themeGlobalId: v.string(),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "themeSubgraph",
+      withTopicScope(args, {
+        themeGlobalId: args.themeGlobalId
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { subgraph: null, error: result.error };
+    }
+    return {
+      subgraph: result.data?.[0]?.subgraph || null
+    };
+  }
+});
+var getEvidenceToBeliefPath = action({
+  args: {
+    evidenceGlobalId: v.string(),
+    beliefGlobalId: v.string(),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "evidenceToBeliefPath",
+      withTopicScope(args, {
+        evidenceGlobalId: args.evidenceGlobalId,
+        beliefGlobalId: args.beliefGlobalId
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { path: null, error: result.error };
+    }
+    const pathResult = result.data?.[0];
+    if (!pathResult?.pathResult) {
+      return { path: null, error: "No path found between evidence and belief" };
+    }
+    return {
+      path: {
+        nodes: pathResult.pathResult.nodes || [],
+        relationships: pathResult.pathResult.relationships || [],
+        length: pathResult.pathResult.length || 0
+      }
+    };
+  }
+});
+var getThemeStats = action({
+  args: {
+    themeGlobalId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("themeStats", {
+      themeGlobalId: args.themeGlobalId
+    });
+    if (!result.success) {
+      return { stats: null, error: result.error };
+    }
+    return { stats: result.data?.[0]?.stats || null };
+  }
+});
+var getThemeValueChainCandidates = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "themeValueChainCandidates",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 100)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { candidates: [], error: result.error };
+    }
+    return {
+      candidates: result.data?.map((r) => r.candidate) || []
+    };
+  }
+});
+var getThemesImpactingCompany = action({
+  args: {
+    companyName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("themesImpactingCompany", {
+      companyName: args.companyName,
+      limit: toInt(args.limit, 20)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getCompaniesByTheme = action({
+  args: {
+    themeName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("companiesByTheme", {
+      themeName: args.themeName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getQuestionsByValueChain = action({
+  args: {
+    valueChainName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("questionsByValueChain", {
+      valueChainName: args.valueChainName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getQuestionsByTheme = action({
+  args: {
+    themeName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("questionsByTheme", {
+      themeName: args.themeName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getPeopleByTheme = action({
+  args: {
+    themeName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("peopleByTheme", {
+      themeName: args.themeName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getPeopleByCompany = action({
+  args: {
+    companyName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("peopleByCompany", {
+      companyName: args.companyName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getValueChainsByTheme = action({
+  args: {
+    themeName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("valueChainsByTheme", {
+      themeName: args.themeName,
+      limit: toInt(args.limit, 20)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getFunctionsByValueChain = action({
+  args: {
+    valueChainName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("functionsByValueChain", {
+      valueChainName: args.valueChainName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getBeliefsByCompany = action({
+  args: {
+    companyName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("beliefsByCompany", {
+      companyName: args.companyName,
+      limit: toInt(args.limit, 30)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getEvidenceByCompany = action({
+  args: {
+    companyName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("evidenceByCompany", {
+      companyName: args.companyName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var searchAllNodes = action({
+  args: {
+    searchText: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("searchAllNodes", {
+      searchText: args.searchText,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getNodeRelationships = action({
+  args: {
+    globalId: v.optional(v.string()),
+    searchText: v.optional(v.string()),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("nodeRelationships", {
+      globalId: args.globalId || "",
+      searchText: args.searchText || "",
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getGraphStats = action({
+  args: {},
+  returns: permissiveReturn,
+  handler: async () => {
+    const result = await callNeo4jQuery("graphStats", {});
+    if (!result.success) {
+      return { stats: [], error: result.error };
+    }
+    return { stats: result.data || [] };
+  }
+});
+var queryGraph = action({
+  args: {
+    queryType: v.union(
+      v.literal("themesImpactingCompany"),
+      v.literal("companiesByTheme"),
+      v.literal("questionsByValueChain"),
+      v.literal("questionsByTheme"),
+      v.literal("peopleByTheme"),
+      v.literal("peopleByCompany"),
+      v.literal("valueChainsByTheme"),
+      v.literal("functionsByValueChain"),
+      v.literal("beliefsByCompany"),
+      v.literal("evidenceByCompany"),
+      v.literal("searchAllNodes"),
+      v.literal("nodeRelationships"),
+      v.literal("graphStats")
+    ),
+    params: v.object({
+      companyName: v.optional(v.string()),
+      themeName: v.optional(v.string()),
+      valueChainName: v.optional(v.string()),
+      searchText: v.optional(v.string()),
+      globalId: v.optional(v.string()),
+      limit: v.optional(v.number())
+    }),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const limit = toInt(args.params.limit, 30);
+    const themeRequiredQueries = [
+      "questionsByTheme",
+      "peopleByTheme",
+      "companiesByTheme",
+      "valueChainsByTheme"
+    ];
+    const companyRequiredQueries = [
+      "themesImpactingCompany",
+      "peopleByCompany",
+      "beliefsByCompany",
+      "evidenceByCompany"
+    ];
+    const valueChainRequiredQueries = [
+      "questionsByValueChain",
+      "functionsByValueChain"
+    ];
+    if (themeRequiredQueries.includes(args.queryType) && !args.params.themeName) {
+      return {
+        results: [],
+        error: `Query type '${args.queryType}' requires 'themeName' parameter`
+      };
+    }
+    if (companyRequiredQueries.includes(args.queryType) && !args.params.companyName) {
+      return {
+        results: [],
+        error: `Query type '${args.queryType}' requires 'companyName' parameter`
+      };
+    }
+    if (valueChainRequiredQueries.includes(args.queryType) && !args.params.valueChainName) {
+      return {
+        results: [],
+        error: `Query type '${args.queryType}' requires 'valueChainName' parameter`
+      };
+    }
+    const result = await callNeo4jQuery(
+      args.queryType,
+      withTopicScope(args, {
+        ...args.params,
+        limit
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getHighPriorityQuestions = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "highPriorityQuestions",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { questions: [], error: result.error };
+    }
+    return { questions: result.data || [] };
+  }
+});
+var getEvidenceByMethodology = action({
+  args: {
+    methodology: v.string(),
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "evidenceByMethodology",
+      withTopicScope(args, {
+        methodology: args.methodology,
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { evidence: [], error: result.error };
+    }
+    return { evidence: result.data || [] };
+  }
+});
+var getProprietaryEvidence = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "proprietaryEvidence",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { evidence: [], error: result.error };
+    }
+    return { evidence: result.data || [] };
+  }
+});
+var getBeliefsByEpistemicStatus = action({
+  args: {
+    epistemicStatus: v.string(),
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "beliefsByEpistemicStatus",
+      withTopicScope(args, {
+        epistemicStatus: args.epistemicStatus,
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { beliefs: [], error: result.error };
+    }
+    return { beliefs: result.data || [] };
+  }
+});
+var getChallengedBeliefs = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "challengedBeliefs",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { beliefs: [], error: result.error };
+    }
+    return { beliefs: result.data || [] };
+  }
+});
+var getPredictions = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "predictions",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { predictions: [], error: result.error };
+    }
+    return { predictions: result.data || [] };
+  }
+});
+var getCausalChains = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "causalChains",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { chains: [], error: result.error };
+    }
+    return { chains: result.data || [] };
+  }
+});
+var getNecessaryEvidence = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "necessaryEvidence",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getFalsificationQuestions = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "falsificationQuestions",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { questions: [], error: result.error };
+    }
+    return { questions: result.data || [] };
+  }
+});
+var getConfirmationBiasScore = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "confirmationBiasScore",
+      {
+        ...args.topicId ? { topicId: args.topicId } : {},
+        limit: toInt(args.limit, 30)
+      },
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getAnchoringBiasDetection = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "anchoringBiasDetection",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getSourceConcentrationRisk = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "sourceConcentrationRisk",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getMinimumFalsificationSet = action({
+  args: {
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "minimumFalsificationSet",
+      withTopicScope(args, {}),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { result: null, error: result.error };
+    }
+    const data = result.data;
+    return { result: Array.isArray(data) && data.length > 0 ? data[0] : null };
+  }
+});
+var getContradictionTensionMap = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "contradictionTensionMap",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getReasoningDepthScore = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "reasoningDepthScore",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getKnowledgeFrontier = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "knowledgeFrontier",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getBeliefHalfLife = action({
+  args: {
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "beliefHalfLife",
+      withTopicScope(args, {}),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { result: null, error: result.error };
+    }
+    const data = result.data;
+    return { result: Array.isArray(data) && data.length > 0 ? data[0] : null };
+  }
+});
+var getMeetingPrepBrief = action({
+  args: {
+    personGlobalId: v.string(),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "meetingPrepBrief",
+      withTopicScope(args, {
+        personGlobalId: args.personGlobalId
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { brief: null, error: result.error };
+    }
+    const data = result.data;
+    return { brief: Array.isArray(data) && data.length > 0 ? data[0] : null };
+  }
+});
+var getProprietarySignals = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "proprietarySignals",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getPortfolioConviction = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "portfolioConviction",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { portfolio: [], error: result.error };
+    }
+    return { portfolio: result.data || [] };
+  }
+});
+var getStaleThemes = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "staleThemes",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { themes: [], error: result.error };
+    }
+    return { themes: result.data || [] };
+  }
+});
+var getMissingQuestionDetection = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "missingQuestionDetection",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getSurpriseDetection = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "surpriseDetection",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getNonConsensusBeliefs = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "nonConsensusBeliefs",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var EMBEDDING_DIMENSIONS = 1024;
+var VALID_INDEX_NAMES = /* @__PURE__ */ new Set([
+  "belief_embedding_index",
+  "question_embedding_index",
+  "evidence_embedding_index",
+  "theme_embedding_index",
+  "source_embedding_index",
+  "synthesis_embedding_index"
+]);
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+var semanticSearch = action({
+  args: {
+    embedding: v.array(v.float64()),
+    indexName: v.optional(v.string()),
+    topK: v.optional(v.number()),
+    minScore: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    if (args.embedding.length !== EMBEDDING_DIMENSIONS) {
+      return {
+        results: [],
+        error: `Embedding must be ${EMBEDDING_DIMENSIONS} dimensions, got ${args.embedding.length}`
+      };
+    }
+    const indexName = args.indexName || "belief_embedding_index";
+    if (!VALID_INDEX_NAMES.has(indexName)) {
+      return { results: [], error: `Invalid index name: ${indexName}` };
+    }
+    const result = await callNeo4jQuery(
+      "semanticSearch",
+      {
+        embedding: args.embedding,
+        indexName,
+        topK: toInt(args.topK, 10),
+        minScore: clamp(args.minScore ?? 0.5, 0, 1)
+      },
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getSemanticOrphans = action({
+  args: {
+    threshold: v.optional(v.number()),
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "semanticOrphans",
+      withTopicScope(args, {
+        threshold: clamp(args.threshold ?? 0.4, 0, 1),
+        limit: toInt(args.limit, 20)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getSoftContradictions = action({
+  args: {
+    similarityThreshold: v.optional(v.number()),
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "softContradictions",
+      withTopicScope(args, {
+        similarityThreshold: clamp(args.similarityThreshold ?? 0.7, 0, 1),
+        limit: toInt(args.limit, 20)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getSemanticBridges = action({
+  args: {
+    similarityThreshold: v.optional(v.number()),
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "semanticBridges",
+      withTopicScope(args, {
+        similarityThreshold: clamp(args.similarityThreshold ?? 0.7, 0, 1),
+        limit: toInt(args.limit, 20)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var graphAwareSearch = action({
+  args: {
+    embedding: v.array(v.float64()),
+    indexName: v.optional(v.string()),
+    topK: v.optional(v.number()),
+    minScore: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    if (args.embedding.length !== EMBEDDING_DIMENSIONS) {
+      return {
+        results: [],
+        error: `Embedding must be ${EMBEDDING_DIMENSIONS} dimensions, got ${args.embedding.length}`
+      };
+    }
+    const indexName = args.indexName || "belief_embedding_index";
+    if (!VALID_INDEX_NAMES.has(indexName)) {
+      return { results: [], error: `Invalid index name: ${indexName}` };
+    }
+    const result = await callNeo4jQuery(
+      "graphAwareSearch",
+      withTopicScope(args, {
+        embedding: args.embedding,
+        indexName,
+        topK: toInt(args.topK, 10),
+        minScore: clamp(args.minScore ?? 0.5, 0, 1)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+
+// src/neo4jQueryRoute.ts
+var neo4jQueryRoute_exports = {};
+__export(neo4jQueryRoute_exports, {
+  createNeo4jQueryRouteHandler: () => createNeo4jQueryRouteHandler
+});
+function jsonResponse(body, init) {
+  return new Response(JSON.stringify(body), {
+    ...init,
+    headers: {
+      "Content-Type": "application/json",
+      ...init?.headers
+    }
+  });
+}
+function readBearerSecret(request) {
+  const authorization = request.headers.get("authorization") ?? "";
+  const match = authorization.match(/^Bearer\s+(.+)$/iu);
+  return match?.[1]?.trim() || null;
+}
+function hasTenantContext(params) {
+  const tenantId = params.tenantId;
+  const topicId = params.topicId;
+  const projectId = params.projectId;
+  return [tenantId, topicId, projectId].some(
+    (value) => typeof value === "string" && value.trim().length > 0
+  );
+}
+function normalizeConnectedNodesQuery(queryName, params, queries) {
+  if (queryName !== "connectedNodes") {
+    return queryName;
+  }
+  const hops = typeof params.maxHops === "number" && Number.isFinite(params.maxHops) ? Math.min(Math.max(Math.floor(params.maxHops), 1), 5) : 2;
+  const aliased = `connectedNodes${hops}`;
+  return queries[aliased] ? aliased : queryName;
+}
+function createNeo4jQueryRouteHandler(options) {
+  return async function handleNeo4jQuery(request) {
+    const expectedSecret = options.syncSecret ?? process.env.NEO4J_SYNC_SECRET?.trim();
+    if (!expectedSecret) {
+      return jsonResponse(
+        { error: "Neo4j sync secret not configured" },
+        { status: 500 }
+      );
+    }
+    if (readBearerSecret(request) !== expectedSecret) {
+      return jsonResponse({ error: "Unauthorized" }, { status: 401 });
+    }
+    let body;
+    try {
+      body = await request.json();
+    } catch {
+      return jsonResponse({ error: "Invalid JSON body" }, { status: 400 });
+    }
+    if (typeof body.queryName !== "string" || body.queryName.length === 0) {
+      return jsonResponse({ error: "Missing queryName" }, { status: 400 });
+    }
+    const params = body.params && typeof body.params === "object" && !Array.isArray(body.params) ? body.params : {};
+    if ((options.requireTenantContext ?? true) && !hasTenantContext(params)) {
+      return jsonResponse(
+        { error: "Missing required tenant context" },
+        { status: 400 }
+      );
+    }
+    const queryName = normalizeConnectedNodesQuery(
+      body.queryName,
+      params,
+      options.queries
+    );
+    const query = options.queries[queryName];
+    if (!query) {
+      return jsonResponse(
+        { error: `Unknown query: ${body.queryName}` },
+        { status: 400 }
+      );
+    }
+    try {
+      const data = await runCypher(
+        query.cypher,
+        params,
+        query.timeoutMs ?? DEFAULT_QUERY_TIMEOUT_MS
+      );
+      return jsonResponse({ data, queryName });
+    } catch (error) {
+      return jsonResponse(
+        {
+          error: error instanceof Error ? error.message : "Neo4j query failed",
+          queryName
+        },
+        { status: 500 }
+      );
+    }
+  };
+}
+
+// src/neo4jSync.ts
+var neo4jSync_exports = {};
+__export(neo4jSync_exports, {
+  backfillAllToNeo4j: () => backfillAllToNeo4j,
+  checkNeo4jHealth: () => checkNeo4jHealth,
+  processRetryQueue: () => processRetryQueue,
+  resyncAllEdges: () => resyncAllEdges,
+  resyncAllNodes: () => resyncAllNodes,
+  syncAllEdgesToNeo4j: () => syncAllEdgesToNeo4j,
+  syncAllNodesToNeo4j: () => syncAllNodesToNeo4j,
+  syncEdgeToNeo4j: () => syncEdgeToNeo4j,
+  syncEmbeddingToNeo4j: () => syncEmbeddingToNeo4j,
+  syncNodeToNeo4j: () => syncNodeToNeo4j
+});
+function buildSyncResponse(entityType, operation, fields) {
+  return {
+    entityType,
+    operation,
+    ...fields
+  };
+}
+function buildSyncSuccess(entityType, operation, fields) {
+  return buildSyncResponse(entityType, operation, {
+    success: true,
+    ...fields
+  });
+}
+function buildSyncFailure(entityType, operation, error, fields) {
+  return buildSyncResponse(entityType, operation, {
+    success: false,
+    error,
+    ...fields
+  });
+}
+function buildNodeProperties(node) {
+  const metadata = node.metadata || {};
+  const pillar = metadata.pillar || metadata.topic || "";
+  const stage = metadata.stage || metadata.beliefStage || "";
+  const criticality = metadata.criticality || "";
+  const synthesizedFrom = metadata.synthesizedFrom || [];
+  const epistemicStatus = node.epistemicStatus || "";
+  const methodology = node.methodology || "";
+  const informationAsymmetry = node.informationAsymmetry || "";
+  const questionType = node.questionType || "";
+  const questionPriority = node.questionPriority || "";
+  const answerQuality = node.answerQuality || "";
+  const reversibility = node.reversibility || "";
+  const predictionMeta = node.predictionMeta;
+  return {
+    convexId: node._id,
+    canonicalText: node.canonicalText || "",
+    title: node.title || "",
+    status: node.status || "active",
+    subtype: node.subtype || "",
+    domain: node.domain || "",
+    confidence: node.confidence || 0,
+    verificationStatus: node.verificationStatus || "unverified",
+    sourceType: node.sourceType || "unknown",
+    createdAt: node.createdAt,
+    updatedAt: node.updatedAt || Date.now(),
+    createdBy: node.createdBy || "",
+    nodeType: node.nodeType,
+    epistemicLayer: node.epistemicLayer || "",
+    // Project and metadata fields
+    projectId: node.projectId || "",
+    tenantId: node.tenantId || "",
+    workspaceId: node.workspaceId || "",
+    pillar,
+    stage,
+    criticality,
+    synthesizedFromCount: synthesizedFrom.length,
+    // Classification fields (Logic Machine)
+    epistemicStatus,
+    methodology,
+    informationAsymmetry,
+    questionType,
+    questionPriority,
+    answerQuality,
+    reversibility,
+    isPrediction: predictionMeta?.isPrediction ? "true" : "false",
+    expectedBy: predictionMeta?.expectedBy ? String(predictionMeta.expectedBy) : ""
+  };
+}
+function buildEdgeProperties(edge) {
+  return {
+    convexId: edge._id,
+    weight: edge.weight || 1,
+    confidence: edge.confidence || 0,
+    context: edge.context || "",
+    derivationType: edge.derivationType || "",
+    createdAt: edge.createdAt,
+    createdBy: edge.createdBy || "",
+    edgeType: edge.edgeType,
+    fromLayer: edge.fromLayer || "",
+    toLayer: edge.toLayer || "",
+    projectId: edge.projectId || "",
+    tenantId: edge.tenantId || "",
+    workspaceId: edge.workspaceId || "",
+    // Classification fields (Logic Machine)
+    reasoningMethod: edge.reasoningMethod || "",
+    logicalRole: edge.logicalRole || "",
+    temporalClass: edge.temporalClass || ""
+  };
+}
+var syncNodeToNeo4j = internalAction({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    operation: v.union(v.literal("upsert"), v.literal("delete"))
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const connInfo = getConnectionInfo();
+    if (!connInfo.configured) {
+      console.warn(
+        "[Neo4j Sync] Missing Neo4j credentials, skipping sync. Set via `npx convex env set`"
+      );
+      return buildSyncFailure("node", args.operation, "Missing credentials", {
+        skippedReason: "credentials_missing"
+      });
+    }
+    const node = await ctx.runQuery(internal.neo4jSyncHelpers.getNodeForSync, {
+      nodeId: args.nodeId
+    });
+    if (!node) {
+      if (args.operation === "upsert") {
+        return buildSyncFailure("node", args.operation, "Node not found", {
+          skippedReason: "source_node_missing"
+        });
+      }
+      console.log("[Neo4j Sync] Node not found for delete, skipping");
+      return buildSyncSuccess("node", args.operation, {
+        skipped: true,
+        skippedReason: "source_node_missing"
+      });
+    }
+    const label = NODE_TYPE_TO_LABEL[node.nodeType] || "Node";
+    try {
+      if (args.operation === "delete") {
+        await deleteNode(node.globalId);
+        console.log(`[Neo4j Sync] Deleted node ${node.globalId}`);
+      } else {
+        const props = buildNodeProperties(node);
+        const embedding = await ctx.runQuery(
+          internal.neo4jSyncHelpers.getEmbeddingForSync,
+          { nodeId: args.nodeId }
+        );
+        if (embedding) {
+          props.embedding = embedding;
+        }
+        await upsertNode(label, node.globalId, props);
+        console.log(
+          `[Neo4j Sync] Upserted node ${node.globalId} as ${label} with projectId=${node.projectId}` + (embedding ? ` (with ${embedding.length}-dim embedding)` : "")
+        );
+      }
+      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
+        eventType: args.operation === "delete" ? "node_deleted" : node ? "node_updated" : "node_created",
+        entityId: args.nodeId,
+        entityType: node.nodeType,
+        status: "success"
+      });
+      return buildSyncSuccess("node", args.operation);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      console.error("[Neo4j Sync] Node sync error:", errorMsg);
+      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
+        eventType: args.operation === "delete" ? "node_deleted" : "node_updated",
+        entityId: args.nodeId,
+        entityType: node.nodeType,
+        status: "failed",
+        error: errorMsg
+      });
+      await ctx.runMutation(internal.neo4jSyncHelpers.queueForRetry, {
+        entityType: "node",
+        entityId: args.nodeId,
+        operation: args.operation,
+        error: errorMsg
+      });
+      return buildSyncFailure("node", args.operation, errorMsg);
+    }
+  }
+});
+var syncEdgeToNeo4j = internalAction({
+  args: {
+    edgeId: v.id("epistemicEdges"),
+    operation: v.union(v.literal("upsert"), v.literal("delete"))
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const connInfo = getConnectionInfo();
+    if (!connInfo.configured) {
+      console.warn(
+        "[Neo4j Sync] Missing Neo4j credentials, skipping sync. Set via `npx convex env set`"
+      );
+      return buildSyncFailure("edge", args.operation, "Missing credentials", {
+        skippedReason: "credentials_missing"
+      });
+    }
+    const edge = await ctx.runQuery(internal.neo4jSyncHelpers.getEdgeForSync, {
+      edgeId: args.edgeId
+    });
+    if (!edge) {
+      if (args.operation === "upsert") {
+        return buildSyncFailure("edge", args.operation, "Edge not found", {
+          skippedReason: "source_edge_missing"
+        });
+      }
+      console.log("[Neo4j Sync] Edge not found for delete, skipping");
+      return buildSyncSuccess("edge", args.operation, {
+        skipped: true,
+        skippedReason: "source_edge_missing"
+      });
+    }
+    if (!edge.fromGlobalId || !edge.toGlobalId) {
+      console.warn(
+        "[Neo4j Sync] Edge missing fromGlobalId or toGlobalId, skipping"
+      );
+      return buildSyncFailure(
+        "edge",
+        args.operation,
+        "Edge missing connected node globalIds",
+        {
+          skippedReason: "edge_endpoint_missing"
+        }
+      );
+    }
+    const relType = EDGE_TYPE_TO_REL[edge.edgeType] || edge.edgeType.toUpperCase();
+    try {
+      if (args.operation === "delete") {
+        await deleteEdge(edge.globalId);
+        console.log(`[Neo4j Sync] Deleted edge ${edge.globalId}`);
+      } else {
+        await upsertEdge(
+          relType,
+          edge.globalId,
+          edge.fromGlobalId,
+          edge.toGlobalId,
+          {
+            convexId: args.edgeId,
+            weight: edge.weight || 1,
+            confidence: edge.confidence || 0,
+            context: edge.context || "",
+            derivationType: edge.derivationType || "",
+            createdAt: edge.createdAt,
+            createdBy: edge.createdBy || "",
+            edgeType: edge.edgeType,
+            fromLayer: edge.fromLayer || "",
+            toLayer: edge.toLayer || "",
+            // Classification fields (Logic Machine)
+            reasoningMethod: edge.reasoningMethod || "",
+            logicalRole: edge.logicalRole || "",
+            temporalClass: edge.temporalClass || ""
+          }
+        );
+        console.log(
+          `[Neo4j Sync] Upserted edge ${edge.globalId} as ${relType}`
+        );
+      }
+      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
+        eventType: args.operation === "delete" ? "edge_deleted" : "edge_created",
+        entityId: args.edgeId,
+        entityType: edge.edgeType,
+        status: "success"
+      });
+      return buildSyncSuccess("edge", args.operation);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      console.error("[Neo4j Sync] Edge sync error:", errorMsg);
+      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
+        eventType: args.operation === "delete" ? "edge_deleted" : "edge_created",
+        entityId: args.edgeId,
+        entityType: edge.edgeType,
+        status: "failed",
+        error: errorMsg
+      });
+      await ctx.runMutation(internal.neo4jSyncHelpers.queueForRetry, {
+        entityType: "edge",
+        entityId: args.edgeId,
+        operation: args.operation,
+        error: errorMsg
+      });
+      return buildSyncFailure("edge", args.operation, errorMsg);
+    }
+  }
+});
+var syncAllNodesToNeo4j = internalAction({
+  args: {
+    batchSize: v.optional(v.number()),
+    cursor: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const batchSize = args.batchSize ?? 100;
+    const result = await ctx.runQuery(
+      internal.neo4jSyncHelpers.getNodeBatchForSync,
+      {
+        limit: batchSize,
+        cursor: args.cursor
+      }
+    );
+    if (result.nodes.length === 0) {
+      return { synced: 0, failed: 0, hasMore: false };
+    }
+    const nodesByLabel = /* @__PURE__ */ new Map();
+    for (const node of result.nodes) {
+      const label = NODE_TYPE_TO_LABEL[node.nodeType] || "Node";
+      if (!nodesByLabel.has(label)) {
+        nodesByLabel.set(label, []);
+      }
+      nodesByLabel.get(label)?.push({
+        globalId: node.globalId,
+        properties: buildNodeProperties(node)
+      });
+    }
+    let synced = 0;
+    let failed = 0;
+    for (const [label, nodes] of nodesByLabel) {
+      try {
+        await batchUpsertNodes(label, nodes);
+        synced += nodes.length;
+        console.log(
+          `[Neo4j Sync] Batch upserted ${nodes.length} ${label} nodes`
+        );
+      } catch (error) {
+        console.error(`[Neo4j Sync] Batch upsert failed for ${label}:`, error);
+        failed += nodes.length;
+      }
+    }
+    return {
+      synced,
+      failed,
+      hasMore: result.hasMore,
+      nextCursor: result.nextCursor
+    };
+  }
+});
+var syncAllEdgesToNeo4j = internalAction({
+  args: {
+    batchSize: v.optional(v.number()),
+    cursor: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const batchSize = args.batchSize ?? 100;
+    const result = await ctx.runQuery(
+      internal.neo4jSyncHelpers.getEdgeBatchForSync,
+      {
+        limit: batchSize,
+        cursor: args.cursor
+      }
+    );
+    if (result.edges.length === 0) {
+      return { synced: 0, failed: 0, hasMore: false };
+    }
+    const edgesToSync = [];
+    for (const edge of result.edges) {
+      if (!edge.fromGlobalId || !edge.toGlobalId) {
+        console.warn(
+          `[Neo4j Sync] Skipping edge ${edge.globalId} - missing globalIds`
+        );
+        continue;
+      }
+      const relType = EDGE_TYPE_TO_REL[edge.edgeType] || edge.edgeType.toUpperCase();
+      edgesToSync.push({
+        relType,
+        globalId: edge.globalId,
+        fromGlobalId: edge.fromGlobalId,
+        toGlobalId: edge.toGlobalId,
+        properties: buildEdgeProperties(edge)
+      });
+    }
+    let synced = 0;
+    let failed = 0;
+    try {
+      await batchUpsertEdges(edgesToSync);
+      synced = edgesToSync.length;
+      console.log(`[Neo4j Sync] Batch upserted ${synced} edges`);
+    } catch (error) {
+      console.error("[Neo4j Sync] Batch edge upsert failed:", error);
+      failed = edgesToSync.length;
+    }
+    return {
+      synced,
+      failed,
+      hasMore: result.hasMore,
+      nextCursor: result.nextCursor
+    };
+  }
+});
+var backfillAllToNeo4j = internalAction({
+  args: {
+    batchSize: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const batchSize = args.batchSize ?? 100;
+    let totalNodes = 0;
+    let totalEdges = 0;
+    let totalFailed = 0;
+    console.log("[Neo4j Sync] Starting full backfill...");
+    let nodeCursor;
+    do {
+      const result = await ctx.runAction(
+        internal.neo4jSync.syncAllNodesToNeo4j,
+        {
+          batchSize,
+          cursor: nodeCursor
+        }
+      );
+      totalNodes += result.synced;
+      totalFailed += result.failed;
+      nodeCursor = result.hasMore ? result.nextCursor : void 0;
+      console.log(
+        `[Neo4j Sync] Nodes progress: ${totalNodes} synced, ${totalFailed} failed`
+      );
+    } while (nodeCursor);
+    console.log(`[Neo4j Sync] Finished nodes: ${totalNodes} synced`);
+    let edgeCursor;
+    do {
+      const result = await ctx.runAction(
+        internal.neo4jSync.syncAllEdgesToNeo4j,
+        {
+          batchSize,
+          cursor: edgeCursor
+        }
+      );
+      totalEdges += result.synced;
+      totalFailed += result.failed;
+      edgeCursor = result.hasMore ? result.nextCursor : void 0;
+      console.log(
+        `[Neo4j Sync] Edges progress: ${totalEdges} synced, ${totalFailed} failed`
+      );
+    } while (edgeCursor);
+    console.log(
+      `[Neo4j Sync] Backfill complete: ${totalNodes} nodes, ${totalEdges} edges, ${totalFailed} failed`
+    );
+    return {
+      totalNodes,
+      totalEdges,
+      totalFailed
+    };
+  }
+});
+var processRetryQueue = internalAction({
+  args: {
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 10;
+    const pendingItems = await ctx.runQuery(
+      internal.neo4jSyncHelpers.getPendingRetries,
+      { limit }
+    );
+    if (pendingItems.length === 0) {
+      return { processed: 0, succeeded: 0, failed: 0 };
+    }
+    let succeeded = 0;
+    let failed = 0;
+    for (const item of pendingItems) {
+      await ctx.runMutation(internal.neo4jSyncHelpers.updateQueueStatus, {
+        queueId: item._id,
+        status: "in_progress"
+      });
+      let result;
+      if (item.entityType === "node") {
+        result = await ctx.runAction(internal.neo4jSync.syncNodeToNeo4j, {
+          nodeId: item.entityId,
+          operation: item.operation
+        });
+      } else {
+        const resolved = await ctx.runQuery(
+          internal.neo4jSyncHelpers.resolveEdgeRetryTarget,
+          {
+            entityId: item.entityId
+          }
+        );
+        if (resolved.mode === "convex_id" || resolved.mode === "global_id_in_convex") {
+          result = await ctx.runAction(internal.neo4jSync.syncEdgeToNeo4j, {
+            edgeId: resolved.edgeId,
+            operation: item.operation
+          });
+        } else {
+          result = await ctx.runAction(
+            internal.neo4jEdgeAPI.retryProjectionByGlobalId,
+            {
+              globalId: resolved.edgeGlobalId
+            }
+          );
+        }
+      }
+      if (result.success) {
+        await ctx.runMutation(internal.neo4jSyncHelpers.updateQueueStatus, {
+          queueId: item._id,
+          status: "succeeded"
+        });
+        succeeded++;
+      } else {
+        const updated = await ctx.runMutation(
+          internal.neo4jSyncHelpers.incrementAttempts,
+          {
+            queueId: item._id,
+            error: result.error || "Unknown error"
+          }
+        );
+        if (updated.failed) {
+          failed++;
+        }
+      }
+    }
+    return { processed: pendingItems.length, succeeded, failed };
+  }
+});
+var syncEmbeddingToNeo4j = internalAction({
+  args: {
+    nodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const connInfo = getConnectionInfo();
+    if (!connInfo.configured) {
+      return buildSyncFailure("embedding", "sync", "Missing credentials", {
+        skippedReason: "credentials_missing"
+      });
+    }
+    const node = await ctx.runQuery(internal.neo4jSyncHelpers.getNodeForSync, {
+      nodeId: args.nodeId
+    });
+    if (!node?.globalId) {
+      return buildSyncFailure("embedding", "sync", "Node not found", {
+        skippedReason: "source_node_missing"
+      });
+    }
+    const embedding = await ctx.runQuery(
+      internal.neo4jSyncHelpers.getEmbeddingForSync,
+      { nodeId: args.nodeId }
+    );
+    if (!embedding) {
+      return buildSyncFailure("embedding", "sync", "Embedding not found", {
+        skippedReason: "embedding_missing"
+      });
+    }
+    try {
+      await runWriteTransaction(
+        "MATCH (n {globalId: $globalId}) SET n.embedding = $embedding",
+        { globalId: node.globalId, embedding }
+      );
+      console.log(
+        `[Neo4j Sync] Synced ${embedding.length}-dim embedding for node ${node.globalId}`
+      );
+      return buildSyncSuccess("embedding", "sync");
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      console.error("[Neo4j Sync] Embedding sync error:", errorMsg);
+      return buildSyncFailure("embedding", "sync", errorMsg);
+    }
+  }
+});
+var checkNeo4jHealth = internalAction({
+  args: {},
+  returns: permissiveReturn,
+  handler: async () => {
+    const connInfo = getConnectionInfo();
+    if (!connInfo.configured) {
+      return {
+        healthy: false,
+        error: "Neo4j not configured",
+        uri: connInfo.uri
+      };
+    }
+    const health = await healthCheck();
+    return {
+      ...health,
+      uri: connInfo.uri
+    };
+  }
+});
+var resyncAllNodes = internalAction({
+  args: {
+    batchSize: v.optional(v.number()),
+    nodeType: v.optional(v.string()),
+    cursor: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const batchSize = args.batchSize ?? 50;
+    const result = await ctx.runQuery(
+      internal.neo4jSyncHelpers.getAllNodesForResync,
+      {
+        nodeType: args.nodeType,
+        limit: batchSize,
+        cursor: args.cursor
+      }
+    );
+    let synced = 0;
+    let failed = 0;
+    for (const node of result.nodes) {
+      try {
+        const syncResult = await ctx.runAction(
+          internal.neo4jSync.syncNodeToNeo4j,
+          {
+            nodeId: node._id,
+            operation: "upsert"
+          }
+        );
+        if (syncResult.success) {
+          synced++;
+        } else {
+          failed++;
+        }
+      } catch (error) {
+        console.error(`[Neo4j Resync] Failed to sync node ${node._id}:`, error);
+        failed++;
+      }
+    }
+    return {
+      synced,
+      failed,
+      total: result.nodes.length,
+      hasMore: result.hasMore,
+      nextCursor: result.nextCursor
+    };
+  }
+});
+var resyncAllEdges = internalAction({
+  args: {
+    batchSize: v.optional(v.number()),
+    cursor: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const batchSize = args.batchSize ?? 50;
+    const result = await ctx.runQuery(
+      internal.neo4jSyncHelpers.getAllEdgesForResync,
+      {
+        limit: batchSize,
+        cursor: args.cursor
+      }
+    );
+    let synced = 0;
+    let failed = 0;
+    for (const edge of result.edges) {
+      try {
+        const syncResult = await ctx.runAction(
+          internal.neo4jSync.syncEdgeToNeo4j,
+          {
+            edgeId: edge._id,
+            operation: "upsert"
+          }
+        );
+        if (syncResult.success) {
+          synced++;
+        } else {
+          failed++;
+        }
+      } catch (error) {
+        console.error(`[Neo4j Resync] Failed to sync edge ${edge._id}:`, error);
+        failed++;
+      }
+    }
+    return {
+      synced,
+      failed,
+      total: result.edges.length,
+      hasMore: result.hasMore,
+      nextCursor: result.nextCursor
+    };
+  }
+});
+
+// src/neo4jSyncHelpers.ts
+var neo4jSyncHelpers_exports = {};
+__export(neo4jSyncHelpers_exports, {
+  checkSyncHealth: () => checkSyncHealth,
+  getAllEdgesForResync: () => getAllEdgesForResync,
+  getAllNodesForResync: () => getAllNodesForResync,
+  getEdgeBatchForSync: () => getEdgeBatchForSync,
+  getEdgeForSync: () => getEdgeForSync,
+  getEmbeddingForSync: () => getEmbeddingForSync,
+  getNodeBatchForSync: () => getNodeBatchForSync,
+  getNodeForSync: () => getNodeForSync,
+  getPendingRetries: () => getPendingRetries,
+  incrementAttempts: () => incrementAttempts,
+  logSyncEvent: () => logSyncEvent,
+  queueForRetry: () => queueForRetry,
+  resolveEdgeRetryTarget: () => resolveEdgeRetryTarget,
+  updateQueueStatus: () => updateQueueStatus
+});
+function logRetryTargetFallback(context, error) {
+  const env = globalThis.process?.env;
+  if (env?.LUCERN_GRAPH_SYNC_DEBUG !== "1") {
+    return;
+  }
+  console.debug("[graph-sync][neo4jSyncHelpers]", context, error);
+}
+var logSyncEvent = internalMutation({
+  args: {
+    eventType: v.union(
+      v.literal("node_created"),
+      v.literal("node_updated"),
+      v.literal("node_deleted"),
+      v.literal("edge_created"),
+      v.literal("edge_deleted")
+    ),
+    entityId: v.string(),
+    entityType: v.string(),
+    status: v.union(
+      v.literal("pending"),
+      v.literal("success"),
+      v.literal("failed")
+    ),
+    error: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    console.log(
+      `[Neo4j Sync] ${args.eventType} ${args.entityType}:${args.entityId} - ${args.status}`,
+      args.error || ""
+    );
+  }
+});
+var getNodeForSync = internalQuery({
+  args: { nodeId: v.id("epistemicNodes") },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.nodeId);
+  }
+});
+var getEmbeddingForSync = internalQuery({
+  args: { nodeId: v.id("epistemicNodes") },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const record = await ctx.db.query("epistemicNodeEmbeddings").withIndex("by_nodeId", (q) => q.eq("nodeId", args.nodeId)).first();
+    return record?.embedding ?? null;
+  }
+});
+var getAllNodesForResync = internalQuery({
+  args: {
+    nodeType: v.optional(v.string()),
+    limit: v.optional(v.number()),
+    cursor: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 100;
+    const paginationOpts = {
+      numItems: limit,
+      cursor: args.cursor ?? null
+    };
+    if (args.nodeType) {
+      const result2 = await ctx.db.query("epistemicNodes").withIndex(
+        "by_nodeType",
+        (q) => q.eq("nodeType", args.nodeType)
+      ).paginate(paginationOpts);
+      return {
+        nodes: result2.page,
+        hasMore: !result2.isDone,
+        nextCursor: result2.continueCursor
+      };
+    }
+    const result = await ctx.db.query("epistemicNodes").order("asc").paginate(paginationOpts);
+    return {
+      nodes: result.page,
+      hasMore: !result.isDone,
+      nextCursor: result.continueCursor
+    };
+  }
+});
+var getEdgeForSync = internalQuery({
+  args: { edgeId: v.id("epistemicEdges") },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const edge = await ctx.db.get(args.edgeId);
+    if (!edge) {
+      return null;
+    }
+    const fromNode = edge.fromNodeId ? await ctx.db.get(edge.fromNodeId) : null;
+    const toNode = edge.toNodeId ? await ctx.db.get(edge.toNodeId) : null;
+    return {
+      ...edge,
+      // Cross-graph edges may not have toNodeId/fromNodeId in Convex mirror.
+      // Fall back to denormalized global IDs when node lookup is unavailable.
+      fromGlobalId: fromNode?.globalId || edge.sourceGlobalId,
+      toGlobalId: toNode?.globalId || edge.targetGlobalId
+    };
+  }
+});
+var getAllEdgesForResync = internalQuery({
+  args: {
+    limit: v.optional(v.number()),
+    cursor: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 100;
+    const paginationOpts = {
+      numItems: limit,
+      cursor: args.cursor ?? null
+    };
+    const result = await ctx.db.query("epistemicEdges").order("asc").paginate(paginationOpts);
+    return {
+      edges: result.page,
+      hasMore: !result.isDone,
+      nextCursor: result.continueCursor
+    };
+  }
+});
+var getNodeBatchForSync = internalQuery({
+  args: {
+    limit: v.number(),
+    cursor: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const paginationOpts = {
+      numItems: args.limit,
+      cursor: args.cursor ?? null
+    };
+    const result = await ctx.db.query("epistemicNodes").order("asc").paginate(paginationOpts);
+    return {
+      nodes: result.page,
+      hasMore: !result.isDone,
+      nextCursor: result.continueCursor
+    };
+  }
+});
+var getEdgeBatchForSync = internalQuery({
+  args: {
+    limit: v.number(),
+    cursor: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const paginationOpts = {
+      numItems: args.limit,
+      cursor: args.cursor ?? null
+    };
+    const result = await ctx.db.query("epistemicEdges").order("asc").paginate(paginationOpts);
+    const enrichedEdges = await Promise.all(
+      result.page.map(async (edge) => {
+        const fromNode = await ctx.db.get(edge.fromNodeId);
+        const toNode = edge.toNodeId ? await ctx.db.get(edge.toNodeId) : null;
+        return {
+          ...edge,
+          fromGlobalId: fromNode?.globalId || edge.sourceGlobalId,
+          toGlobalId: toNode?.globalId || edge.targetGlobalId
+        };
+      })
+    );
+    return {
+      edges: enrichedEdges,
+      hasMore: !result.isDone,
+      nextCursor: result.continueCursor
+    };
+  }
+});
+var resolveEdgeRetryTarget = internalQuery({
+  args: {
+    entityId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    try {
+      const byId = await ctx.db.get(args.entityId);
+      if (byId && "edgeType" in byId && "fromNodeId" in byId) {
+        return {
+          mode: "convex_id",
+          edgeId: byId._id,
+          edgeGlobalId: byId.globalId
+        };
+      }
+    } catch (error) {
+      logRetryTargetFallback(
+        `direct edge lookup fallback for entityId=${args.entityId}`,
+        error
+      );
+    }
+    const byGlobalId = await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.entityId)).first();
+    if (byGlobalId) {
+      return {
+        mode: "global_id_in_convex",
+        edgeId: byGlobalId._id,
+        edgeGlobalId: byGlobalId.globalId
+      };
+    }
+    return {
+      mode: "global_id_only",
+      edgeGlobalId: args.entityId
+    };
+  }
+});
+var queueForRetry = internalMutation({
+  args: {
+    entityType: v.union(v.literal("node"), v.literal("edge")),
+    entityId: v.string(),
+    operation: v.union(v.literal("upsert"), v.literal("delete")),
+    error: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const existing = await ctx.db.query("neo4jSyncQueue").withIndex(
+      "by_entity",
+      (q) => q.eq("entityType", args.entityType).eq("entityId", args.entityId)
+    ).first();
+    if (existing) {
+      const attempts = existing.attempts ?? 0;
+      const maxAttempts = existing.maxAttempts ?? 5;
+      await ctx.db.patch(existing._id, {
+        attempts: attempts + 1,
+        maxAttempts,
+        lastAttemptAt: now,
+        lastError: args.error,
+        status: attempts + 1 >= maxAttempts ? "failed" : "pending",
+        updatedAt: now
+      });
+      return { queued: true, updated: true, queueId: existing._id };
+    }
+    const queueId = await ctx.db.insert("neo4jSyncQueue", {
+      entityType: args.entityType,
+      entityId: args.entityId,
+      operation: args.operation,
+      attempts: 1,
+      maxAttempts: 5,
+      lastAttemptAt: now,
+      lastError: args.error,
+      status: "pending",
+      createdAt: now,
+      updatedAt: now
+    });
+    return { queued: true, updated: false, queueId };
+  }
+});
+var getPendingRetries = internalQuery({
+  args: {
+    limit: v.number()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    return await ctx.db.query("neo4jSyncQueue").withIndex("by_status", (q) => q.eq("status", "pending")).take(args.limit);
+  }
+});
+var updateQueueStatus = internalMutation({
+  args: {
+    queueId: v.id("neo4jSyncQueue"),
+    status: v.union(
+      v.literal("pending"),
+      v.literal("in_progress"),
+      v.literal("failed"),
+      v.literal("succeeded")
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.queueId, {
+      status: args.status,
+      updatedAt: Date.now()
+    });
+  }
+});
+var incrementAttempts = internalMutation({
+  args: {
+    queueId: v.id("neo4jSyncQueue"),
+    error: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const item = await ctx.db.get(args.queueId);
+    if (!item) {
+      return { failed: false };
+    }
+    const attempts = item.attempts ?? 0;
+    const maxAttempts = item.maxAttempts ?? 5;
+    const newAttempts = attempts + 1;
+    const isFailed = newAttempts >= maxAttempts;
+    await ctx.db.patch(args.queueId, {
+      attempts: newAttempts,
+      maxAttempts,
+      lastAttemptAt: Date.now(),
+      lastError: args.error,
+      status: isFailed ? "failed" : "pending",
+      updatedAt: Date.now()
+    });
+    return { failed: isFailed };
+  }
+});
+var checkSyncHealth = internalQuery({
+  args: {},
+  returns: permissiveReturn,
+  handler: async (ctx) => {
+    const now = Date.now();
+    const oneHourAgo = now - 60 * 60 * 1e3;
+    const recentNodes = await ctx.db.query("epistemicNodes").filter((q) => q.gte(q.field("updatedAt"), oneHourAgo)).collect();
+    const recentEdges = await ctx.db.query("epistemicEdges").filter((q) => q.gte(q.field("createdAt"), oneHourAgo)).collect();
+    const pendingRetries = await ctx.db.query("neo4jSyncQueue").withIndex("by_status", (q) => q.eq("status", "pending")).collect();
+    const failedRetries = await ctx.db.query("neo4jSyncQueue").withIndex("by_status", (q) => q.eq("status", "failed")).collect();
+    return {
+      recentNodesUpdated: recentNodes.length,
+      recentEdgesUpdated: recentEdges.length,
+      pendingRetries: pendingRetries.length,
+      failedRetries: failedRetries.length,
+      healthStatus: failedRetries.length > 10 ? "unhealthy" : pendingRetries.length > 50 ? "degraded" : "healthy",
+      checkedAt: now
+    };
+  }
+});
+
+export { neo4jDriver_exports as neo4jDriver, neo4jEdgeAPI_exports as neo4jEdgeAPI, neo4jQueries_exports as neo4jQueries, neo4jQueryRoute_exports as neo4jQueryRoute, neo4jSync_exports as neo4jSync, neo4jSyncHelpers_exports as neo4jSyncHelpers };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map