@lucern/graph-sync 0.3.0-alpha.9 → 1.0.1

package/dist/neo4jQueries.js

@@ -1,12 +1,11 @@
 import { v } from 'convex/values';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { componentsGeneric, actionGeneric } from 'convex/server';
+import { actionGeneric } from 'convex/server';
 
 // src/neo4jQueries.ts
-componentsGeneric();
 var action = actionGeneric;
 
-// src/neo4jQueries.ts
+// src/neo4jQueriesCore.ts
 function toInt(value, defaultValue) {
   if (value === void 0 || value === null) {
     return defaultValue;
@@ -55,6 +54,9 @@ function buildProxyEndpoint(proxyBaseUrl) {
   }
   return endpoint.toString();
 }
+function withTopicScope(args, params) {
+  return args.topicId ? { ...params, topicId: args.topicId } : params;
+}
 async function callNeo4jQuery(queryName, params, apiBaseUrl) {
   const proxyUrl = resolveProxyBaseUrl(apiBaseUrl);
   if (!proxyUrl) {
@@ -128,101 +130,95 @@ async function callNeo4jQuery(queryName, params, apiBaseUrl) {
     );
   }
 }
-function withTopicScope(args, params) {
-  return args.topicId ? { ...params, topicId: args.topicId } : params;
-}
-var getNodeLineageGraph = action({
+var getHighPriorityQuestions = action({
   args: {
-    globalId: 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(
-      "nodeLineage",
+      "highPriorityQuestions",
       withTopicScope(args, {
-        globalId: args.globalId
+        limit: toInt(args.limit, 50)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      console.error("[Neo4j] Lineage query failed:", result.error);
-      return { lineage: [], error: result.error };
+      return { questions: [], error: result.error };
     }
-    const lineage = result.data?.[0]?.lineage || [];
-    return { lineage };
+    return { questions: result.data || [] };
   }
 });
-var getConnectedNodesGraph = action({
+var getEvidenceByMethodology = action({
   args: {
-    globalId: v.string(),
-    maxHops: v.optional(v.number()),
+    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 maxHops = Math.min(toInt(args.maxHops, 2), 5);
-    const limit = toInt(args.limit, 50);
     const result = await callNeo4jQuery(
-      "connectedNodes",
+      "evidenceByMethodology",
       withTopicScope(args, {
-        globalId: args.globalId,
-        maxHops,
-        limit
+        methodology: args.methodology,
+        limit: toInt(args.limit, 50)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      console.error("[Neo4j] Connected nodes query failed:", result.error);
-      return { nodes: [], error: result.error };
+      return { evidence: [], error: result.error };
     }
-    return { nodes: result.data || [] };
+    return { evidence: result.data || [] };
   }
 });
-var getThemeBeliefsGraph = action({
+var getProprietaryEvidence = action({
   args: {
-    themeGlobalId: 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("themeBeliefs", {
-      themeGlobalId: args.themeGlobalId
-    });
+    const result = await callNeo4jQuery(
+      "proprietaryEvidence",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
     if (!result.success) {
-      return { beliefs: [], error: result.error };
+      return { evidence: [], error: result.error };
     }
-    return {
-      beliefs: result.data?.map((r) => r.belief) || []
-    };
+    return { evidence: result.data || [] };
   }
 });
-var getBeliefEvidenceGraph = action({
+var getBeliefsByEpistemicStatus = action({
   args: {
-    beliefGlobalId: v.string(),
+    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(
-      "beliefEvidence",
+      "beliefsByEpistemicStatus",
       withTopicScope(args, {
-        beliefGlobalId: args.beliefGlobalId
+        epistemicStatus: args.epistemicStatus,
+        limit: toInt(args.limit, 50)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { evidence: [], error: result.error };
+      return { beliefs: [], error: result.error };
     }
-    return {
-      evidence: result.data?.map((r) => r.evidence) || []
-    };
+    return { beliefs: result.data || [] };
   }
 });
-var getCrossThemeBeliefs = action({
+var getChallengedBeliefs = action({
   args: {
     limit: v.optional(v.number()),
     apiBaseUrl: v.optional(v.string()),
@@ -231,21 +227,19 @@ var getCrossThemeBeliefs = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "crossThemeBeliefs",
+      "challengedBeliefs",
       withTopicScope(args, {
-        limit: toInt(args.limit, 20)
+        limit: toInt(args.limit, 30)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
       return { beliefs: [], error: result.error };
     }
-    return {
-      beliefs: result.data?.map((r) => r.belief) || []
-    };
+    return { beliefs: result.data || [] };
   }
 });
-var findPotentialContradictions = action({
+var getPredictions = action({
   args: {
     limit: v.optional(v.number()),
     apiBaseUrl: v.optional(v.string()),
@@ -254,94 +248,82 @@ var findPotentialContradictions = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "potentialContradictions",
+      "predictions",
       withTopicScope(args, {
-        limit: toInt(args.limit, 10)
+        limit: toInt(args.limit, 50)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { contradictions: [], error: result.error };
+      return { predictions: [], error: result.error };
     }
-    return {
-      contradictions: result.data?.map(
-        (r) => r.contradiction
-      ) || []
-    };
+    return { predictions: result.data || [] };
   }
 });
-var getThemeSubgraph = action({
+var getCausalChains = action({
   args: {
-    themeGlobalId: 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(
-      "themeSubgraph",
+      "causalChains",
       withTopicScope(args, {
-        themeGlobalId: args.themeGlobalId
+        limit: toInt(args.limit, 50)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { subgraph: null, error: result.error };
+      return { chains: [], error: result.error };
     }
-    return {
-      subgraph: result.data?.[0]?.subgraph || null
-    };
+    return { chains: result.data || [] };
   }
 });
-var getEvidenceToBeliefPath = action({
+var getNecessaryEvidence = action({
   args: {
-    evidenceGlobalId: v.string(),
-    beliefGlobalId: 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(
-      "evidenceToBeliefPath",
+      "necessaryEvidence",
       withTopicScope(args, {
-        evidenceGlobalId: args.evidenceGlobalId,
-        beliefGlobalId: args.beliefGlobalId
+        limit: toInt(args.limit, 50)
       }),
       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 { results: [], error: result.error };
     }
-    return {
-      path: {
-        nodes: pathResult.pathResult.nodes || [],
-        relationships: pathResult.pathResult.relationships || [],
-        length: pathResult.pathResult.length || 0
-      }
-    };
+    return { results: result.data || [] };
   }
 });
-var getThemeStats = action({
+var getFalsificationQuestions = action({
   args: {
-    themeGlobalId: 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("themeStats", {
-      themeGlobalId: args.themeGlobalId
-    });
+    const result = await callNeo4jQuery(
+      "falsificationQuestions",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
     if (!result.success) {
-      return { stats: null, error: result.error };
+      return { questions: [], error: result.error };
     }
-    return { stats: result.data?.[0]?.stats || null };
+    return { questions: result.data || [] };
   }
 });
-var getThemeValueChainCandidates = action({
+var getConfirmationBiasScore = action({
   args: {
     limit: v.optional(v.number()),
     apiBaseUrl: v.optional(v.string()),
@@ -350,307 +332,196 @@ var getThemeValueChainCandidates = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "themeValueChainCandidates",
-      withTopicScope(args, {
-        limit: toInt(args.limit, 100)
-      }),
+      "confirmationBiasScore",
+      {
+        ...args.topicId ? { topicId: args.topicId } : {},
+        limit: toInt(args.limit, 30)
+      },
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { candidates: [], error: result.error };
+      return { results: [], error: result.error };
     }
-    return {
-      candidates: result.data?.map((r) => r.candidate) || []
-    };
+    return { results: result.data || [] };
   }
 });
-var getThemesImpactingCompany = action({
+var getAnchoringBiasDetection = action({
   args: {
-    companyName: v.string(),
-    limit: 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("themesImpactingCompany", {
-      companyName: args.companyName,
-      limit: toInt(args.limit, 20)
-    });
+    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 getCompaniesByTheme = action({
+var getSourceConcentrationRisk = action({
   args: {
-    themeName: v.string(),
-    limit: 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("companiesByTheme", {
-      themeName: args.themeName,
-      limit: toInt(args.limit, 50)
-    });
+    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 getQuestionsByValueChain = action({
+var getMinimumFalsificationSet = action({
   args: {
-    valueChainName: 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("questionsByValueChain", {
-      valueChainName: args.valueChainName,
-      limit: toInt(args.limit, 50)
-    });
+    const result = await callNeo4jQuery(
+      "minimumFalsificationSet",
+      withTopicScope(args, {}),
+      args.apiBaseUrl
+    );
     if (!result.success) {
-      return { results: [], error: result.error };
+      return { result: null, error: result.error };
     }
-    return { results: result.data || [] };
+    const data = result.data;
+    return { result: Array.isArray(data) && data.length > 0 ? data[0] : null };
   }
 });
-var getQuestionsByTheme = action({
+var getContradictionTensionMap = action({
   args: {
-    themeName: v.string(),
-    limit: 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("questionsByTheme", {
-      themeName: args.themeName,
-      limit: toInt(args.limit, 50)
-    });
+    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 getPeopleByTheme = action({
+var getReasoningDepthScore = 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())
+    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("beliefsByCompany", {
-      companyName: args.companyName,
-      limit: toInt(args.limit, 30)
-    });
+    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 getEvidenceByCompany = action({
+var getKnowledgeFrontier = action({
   args: {
-    companyName: v.string(),
-    limit: 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("evidenceByCompany", {
-      companyName: args.companyName,
-      limit: toInt(args.limit, 50)
-    });
+    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 searchAllNodes = action({
+var getBeliefHalfLife = action({
   args: {
-    searchText: 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("searchAllNodes", {
-      searchText: args.searchText,
-      limit: toInt(args.limit, 50)
-    });
+    const result = await callNeo4jQuery(
+      "beliefHalfLife",
+      withTopicScope(args, {}),
+      args.apiBaseUrl
+    );
     if (!result.success) {
-      return { results: [], error: result.error };
+      return { result: null, error: result.error };
     }
-    return { results: result.data || [] };
+    const data = result.data;
+    return { result: Array.isArray(data) && data.length > 0 ? data[0] : null };
   }
 });
-var getNodeRelationships = action({
+var getMeetingPrepBrief = action({
   args: {
-    globalId: v.optional(v.string()),
-    searchText: v.optional(v.string()),
-    limit: v.optional(v.number())
+    personGlobalId: v.string(),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
   },
   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", {});
+    const result = await callNeo4jQuery(
+      "meetingPrepBrief",
+      withTopicScope(args, {
+        personGlobalId: args.personGlobalId
+      }),
+      args.apiBaseUrl
+    );
     if (!result.success) {
-      return { stats: [], error: result.error };
+      return { brief: null, error: result.error };
     }
-    return { stats: result.data || [] };
+    const data = result.data;
+    return { brief: Array.isArray(data) && data.length > 0 ? data[0] : null };
   }
 });
-var queryGraph = action({
+var getProprietarySignals = 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())
-    }),
+    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,
+      "proprietarySignals",
       withTopicScope(args, {
-        ...args.params,
-        limit
+        limit: toInt(args.limit, 30)
       }),
       args.apiBaseUrl
     );
@@ -660,7 +531,7 @@ var queryGraph = action({
     return { results: result.data || [] };
   }
 });
-var getHighPriorityQuestions = action({
+var getPortfolioConviction = action({
   args: {
     limit: v.optional(v.number()),
     apiBaseUrl: v.optional(v.string()),
@@ -669,21 +540,20 @@ var getHighPriorityQuestions = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "highPriorityQuestions",
+      "portfolioConviction",
       withTopicScope(args, {
         limit: toInt(args.limit, 50)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { questions: [], error: result.error };
+      return { portfolio: [], error: result.error };
     }
-    return { questions: result.data || [] };
+    return { portfolio: result.data || [] };
   }
 });
-var getEvidenceByMethodology = action({
+var getStaleThemes = action({
   args: {
-    methodology: v.string(),
     limit: v.optional(v.number()),
     apiBaseUrl: v.optional(v.string()),
     topicId: v.optional(v.string())
@@ -691,20 +561,19 @@ var getEvidenceByMethodology = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "evidenceByMethodology",
+      "staleThemes",
       withTopicScope(args, {
-        methodology: args.methodology,
-        limit: toInt(args.limit, 50)
+        limit: toInt(args.limit, 30)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { evidence: [], error: result.error };
+      return { themes: [], error: result.error };
     }
-    return { evidence: result.data || [] };
+    return { themes: result.data || [] };
   }
 });
-var getProprietaryEvidence = action({
+var getMissingQuestionDetection = action({
   args: {
     limit: v.optional(v.number()),
     apiBaseUrl: v.optional(v.string()),
@@ -713,21 +582,20 @@ var getProprietaryEvidence = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "proprietaryEvidence",
+      "missingQuestionDetection",
       withTopicScope(args, {
-        limit: toInt(args.limit, 50)
+        limit: toInt(args.limit, 30)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { evidence: [], error: result.error };
+      return { results: [], error: result.error };
     }
-    return { evidence: result.data || [] };
+    return { results: result.data || [] };
   }
 });
-var getBeliefsByEpistemicStatus = action({
+var getSurpriseDetection = action({
   args: {
-    epistemicStatus: v.string(),
     limit: v.optional(v.number()),
     apiBaseUrl: v.optional(v.string()),
     topicId: v.optional(v.string())
@@ -735,20 +603,19 @@ var getBeliefsByEpistemicStatus = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "beliefsByEpistemicStatus",
+      "surpriseDetection",
       withTopicScope(args, {
-        epistemicStatus: args.epistemicStatus,
-        limit: toInt(args.limit, 50)
+        limit: toInt(args.limit, 30)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { beliefs: [], error: result.error };
+      return { results: [], error: result.error };
     }
-    return { beliefs: result.data || [] };
+    return { results: result.data || [] };
   }
 });
-var getChallengedBeliefs = action({
+var getNonConsensusBeliefs = action({
   args: {
     limit: v.optional(v.number()),
     apiBaseUrl: v.optional(v.string()),
@@ -757,41 +624,70 @@ var getChallengedBeliefs = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "challengedBeliefs",
+      "nonConsensusBeliefs",
       withTopicScope(args, {
         limit: toInt(args.limit, 30)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { beliefs: [], error: result.error };
+      return { results: [], error: result.error };
     }
-    return { beliefs: result.data || [] };
+    return { results: result.data || [] };
   }
 });
-var getPredictions = action({
+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: {
-    limit: v.optional(v.number()),
+    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(
-      "predictions",
-      withTopicScope(args, {
-        limit: toInt(args.limit, 50)
-      }),
+      "semanticSearch",
+      {
+        embedding: args.embedding,
+        indexName,
+        topK: toInt(args.topK, 10),
+        minScore: clamp(args.minScore ?? 0.5, 0, 1)
+      },
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { predictions: [], error: result.error };
+      return { results: [], error: result.error };
     }
-    return { predictions: result.data || [] };
+    return { results: result.data || [] };
   }
 });
-var getCausalChains = action({
+var getSemanticOrphans = action({
   args: {
+    threshold: v.optional(v.number()),
     limit: v.optional(v.number()),
     apiBaseUrl: v.optional(v.string()),
     topicId: v.optional(v.string())
@@ -799,20 +695,22 @@ var getCausalChains = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "causalChains",
+      "semanticOrphans",
       withTopicScope(args, {
-        limit: toInt(args.limit, 50)
+        threshold: clamp(args.threshold ?? 0.4, 0, 1),
+        limit: toInt(args.limit, 20)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { chains: [], error: result.error };
+      return { results: [], error: result.error };
     }
-    return { chains: result.data || [] };
+    return { results: result.data || [] };
   }
 });
-var getNecessaryEvidence = action({
+var getSoftContradictions = action({
   args: {
+    similarityThreshold: v.optional(v.number()),
     limit: v.optional(v.number()),
     apiBaseUrl: v.optional(v.string()),
     topicId: v.optional(v.string())
@@ -820,9 +718,10 @@ var getNecessaryEvidence = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "necessaryEvidence",
+      "softContradictions",
       withTopicScope(args, {
-        limit: toInt(args.limit, 50)
+        similarityThreshold: clamp(args.similarityThreshold ?? 0.7, 0, 1),
+        limit: toInt(args.limit, 20)
       }),
       args.apiBaseUrl
     );
@@ -832,8 +731,9 @@ var getNecessaryEvidence = action({
     return { results: result.data || [] };
   }
 });
-var getFalsificationQuestions = action({
+var getSemanticBridges = action({
   args: {
+    similarityThreshold: v.optional(v.number()),
     limit: v.optional(v.number()),
     apiBaseUrl: v.optional(v.string()),
     topicId: v.optional(v.string())
@@ -841,32 +741,48 @@ var getFalsificationQuestions = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "falsificationQuestions",
+      "semanticBridges",
       withTopicScope(args, {
-        limit: toInt(args.limit, 50)
+        similarityThreshold: clamp(args.similarityThreshold ?? 0.7, 0, 1),
+        limit: toInt(args.limit, 20)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { questions: [], error: result.error };
+      return { results: [], error: result.error };
     }
-    return { questions: result.data || [] };
+    return { results: result.data || [] };
   }
 });
-var getConfirmationBiasScore = action({
+var graphAwareSearch = action({
   args: {
-    limit: v.optional(v.number()),
+    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(
-      "confirmationBiasScore",
-      {
-        ...args.topicId ? { topicId: args.topicId } : {},
-        limit: toInt(args.limit, 30)
-      },
+      "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) {
@@ -875,89 +791,100 @@ var getConfirmationBiasScore = action({
     return { results: result.data || [] };
   }
 });
-var getAnchoringBiasDetection = action({
+
+// src/neo4jQueries.ts
+var getNodeLineageGraph = action({
   args: {
-    limit: v.optional(v.number()),
+    globalId: v.string(),
     apiBaseUrl: v.optional(v.string()),
     topicId: v.optional(v.string())
   },
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "anchoringBiasDetection",
+      "nodeLineage",
       withTopicScope(args, {
-        limit: toInt(args.limit, 30)
+        globalId: args.globalId
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { results: [], error: result.error };
+      console.error("[Neo4j] Lineage query failed:", result.error);
+      return { lineage: [], error: result.error };
     }
-    return { results: result.data || [] };
+    const lineage = result.data?.[0]?.lineage || [];
+    return { lineage };
   }
 });
-var getSourceConcentrationRisk = action({
+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(
-      "sourceConcentrationRisk",
+      "connectedNodes",
       withTopicScope(args, {
-        limit: toInt(args.limit, 30)
+        globalId: args.globalId,
+        maxHops,
+        limit
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { results: [], error: result.error };
+      console.error("[Neo4j] Connected nodes query failed:", result.error);
+      return { nodes: [], error: result.error };
     }
-    return { results: result.data || [] };
+    return { nodes: result.data || [] };
   }
 });
-var getMinimumFalsificationSet = action({
+var getThemeBeliefsGraph = action({
   args: {
-    apiBaseUrl: v.optional(v.string()),
-    topicId: v.optional(v.string())
+    themeGlobalId: v.string()
   },
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
-    const result = await callNeo4jQuery(
-      "minimumFalsificationSet",
-      withTopicScope(args, {}),
-      args.apiBaseUrl
-    );
+    const result = await callNeo4jQuery("themeBeliefs", {
+      themeGlobalId: args.themeGlobalId
+    });
     if (!result.success) {
-      return { result: null, error: result.error };
+      return { beliefs: [], error: result.error };
     }
-    const data = result.data;
-    return { result: Array.isArray(data) && data.length > 0 ? data[0] : null };
+    return {
+      beliefs: result.data?.map((r) => r.belief) || []
+    };
   }
 });
-var getContradictionTensionMap = action({
+var getBeliefEvidenceGraph = action({
   args: {
-    limit: v.optional(v.number()),
+    beliefGlobalId: v.string(),
     apiBaseUrl: v.optional(v.string()),
     topicId: v.optional(v.string())
   },
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "contradictionTensionMap",
+      "beliefEvidence",
       withTopicScope(args, {
-        limit: toInt(args.limit, 30)
+        beliefGlobalId: args.beliefGlobalId
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { results: [], error: result.error };
+      return { evidence: [], error: result.error };
     }
-    return { results: result.data || [] };
+    return {
+      evidence: result.data?.map((r) => r.evidence) || []
+    };
   }
 });
-var getReasoningDepthScore = action({
+var getCrossThemeBeliefs = action({
   args: {
     limit: v.optional(v.number()),
     apiBaseUrl: v.optional(v.string()),
@@ -966,19 +893,21 @@ var getReasoningDepthScore = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "reasoningDepthScore",
+      "crossThemeBeliefs",
       withTopicScope(args, {
-        limit: toInt(args.limit, 50)
+        limit: toInt(args.limit, 20)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { results: [], error: result.error };
+      return { beliefs: [], error: result.error };
     }
-    return { results: result.data || [] };
+    return {
+      beliefs: result.data?.map((r) => r.belief) || []
+    };
   }
 });
-var getKnowledgeFrontier = action({
+var findPotentialContradictions = action({
   args: {
     limit: v.optional(v.number()),
     apiBaseUrl: v.optional(v.string()),
@@ -987,60 +916,94 @@ var getKnowledgeFrontier = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "knowledgeFrontier",
+      "potentialContradictions",
       withTopicScope(args, {
-        limit: toInt(args.limit, 30)
+        limit: toInt(args.limit, 10)
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { results: [], error: result.error };
+      return { contradictions: [], error: result.error };
     }
-    return { results: result.data || [] };
+    return {
+      contradictions: result.data?.map(
+        (r) => r.contradiction
+      ) || []
+    };
   }
 });
-var getBeliefHalfLife = action({
+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(
-      "beliefHalfLife",
-      withTopicScope(args, {}),
+      "themeSubgraph",
+      withTopicScope(args, {
+        themeGlobalId: args.themeGlobalId
+      }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { result: null, error: result.error };
+      return { subgraph: null, error: result.error };
     }
-    const data = result.data;
-    return { result: Array.isArray(data) && data.length > 0 ? data[0] : null };
+    return {
+      subgraph: result.data?.[0]?.subgraph || null
+    };
   }
 });
-var getMeetingPrepBrief = action({
+var getEvidenceToBeliefPath = action({
   args: {
-    personGlobalId: v.string(),
+    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(
-      "meetingPrepBrief",
+      "evidenceToBeliefPath",
       withTopicScope(args, {
-        personGlobalId: args.personGlobalId
+        evidenceGlobalId: args.evidenceGlobalId,
+        beliefGlobalId: args.beliefGlobalId
       }),
       args.apiBaseUrl
     );
     if (!result.success) {
-      return { brief: null, error: result.error };
+      return { path: null, error: result.error };
     }
-    const data = result.data;
-    return { brief: Array.isArray(data) && data.length > 0 ? data[0] : null };
+    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 getProprietarySignals = action({
+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()),
@@ -1049,269 +1012,307 @@ var getProprietarySignals = action({
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
     const result = await callNeo4jQuery(
-      "proprietarySignals",
+      "themeValueChainCandidates",
       withTopicScope(args, {
-        limit: toInt(args.limit, 30)
+        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 getPortfolioConviction = action({
+var getCompaniesByTheme = action({
   args: {
-    limit: v.optional(v.number()),
-    apiBaseUrl: v.optional(v.string()),
-    topicId: v.optional(v.string())
+    themeName: v.string(),
+    limit: v.optional(v.number())
   },
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
-    const result = await callNeo4jQuery(
-      "portfolioConviction",
-      withTopicScope(args, {
-        limit: toInt(args.limit, 50)
-      }),
-      args.apiBaseUrl
-    );
+    const result = await callNeo4jQuery("companiesByTheme", {
+      themeName: args.themeName,
+      limit: toInt(args.limit, 50)
+    });
     if (!result.success) {
-      return { portfolio: [], error: result.error };
+      return { results: [], error: result.error };
     }
-    return { portfolio: result.data || [] };
+    return { results: result.data || [] };
   }
 });
-var getStaleThemes = action({
+var getQuestionsByValueChain = action({
   args: {
-    limit: v.optional(v.number()),
-    apiBaseUrl: v.optional(v.string()),
-    topicId: v.optional(v.string())
+    valueChainName: v.string(),
+    limit: v.optional(v.number())
   },
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
-    const result = await callNeo4jQuery(
-      "staleThemes",
-      withTopicScope(args, {
-        limit: toInt(args.limit, 30)
-      }),
-      args.apiBaseUrl
-    );
+    const result = await callNeo4jQuery("questionsByValueChain", {
+      valueChainName: args.valueChainName,
+      limit: toInt(args.limit, 50)
+    });
     if (!result.success) {
-      return { themes: [], error: result.error };
+      return { results: [], error: result.error };
     }
-    return { themes: result.data || [] };
+    return { results: result.data || [] };
   }
 });
-var getMissingQuestionDetection = action({
+var getQuestionsByTheme = action({
   args: {
-    limit: v.optional(v.number()),
-    apiBaseUrl: v.optional(v.string()),
-    topicId: v.optional(v.string())
+    themeName: v.string(),
+    limit: v.optional(v.number())
   },
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
-    const result = await callNeo4jQuery(
-      "missingQuestionDetection",
-      withTopicScope(args, {
-        limit: toInt(args.limit, 30)
-      }),
-      args.apiBaseUrl
-    );
+    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 getSurpriseDetection = action({
+var getPeopleByTheme = action({
   args: {
-    limit: v.optional(v.number()),
-    apiBaseUrl: v.optional(v.string()),
-    topicId: v.optional(v.string())
+    themeName: v.string(),
+    limit: v.optional(v.number())
   },
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
-    const result = await callNeo4jQuery(
-      "surpriseDetection",
-      withTopicScope(args, {
-        limit: toInt(args.limit, 30)
-      }),
-      args.apiBaseUrl
-    );
+    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 getNonConsensusBeliefs = action({
+var getPeopleByCompany = action({
   args: {
-    limit: v.optional(v.number()),
-    apiBaseUrl: v.optional(v.string()),
-    topicId: v.optional(v.string())
+    companyName: v.string(),
+    limit: v.optional(v.number())
   },
   returns: permissiveReturn,
   handler: async (_ctx, args) => {
-    const result = await callNeo4jQuery(
-      "nonConsensusBeliefs",
-      withTopicScope(args, {
-        limit: toInt(args.limit, 30)
-      }),
-      args.apiBaseUrl
-    );
+    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 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({
+var getValueChainsByTheme = 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())
+    themeName: v.string(),
+    limit: v.optional(v.number())
   },
   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 result = await callNeo4jQuery("valueChainsByTheme", {
+      themeName: args.themeName,
+      limit: toInt(args.limit, 20)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
     }
-    const indexName = args.indexName || "belief_embedding_index";
-    if (!VALID_INDEX_NAMES.has(indexName)) {
-      return { results: [], error: `Invalid index name: ${indexName}` };
+    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 };
     }
-    const result = await callNeo4jQuery(
-      "semanticSearch",
-      {
-        embedding: args.embedding,
-        indexName,
-        topK: toInt(args.topK, 10),
-        minScore: clamp(args.minScore ?? 0.5, 0, 1)
-      },
-      args.apiBaseUrl
-    );
+    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 getSemanticOrphans = action({
+var getEvidenceByCompany = action({
   args: {
-    threshold: v.optional(v.number()),
-    limit: v.optional(v.number()),
-    apiBaseUrl: v.optional(v.string()),
-    topicId: v.optional(v.string())
+    companyName: v.string(),
+    limit: v.optional(v.number())
   },
   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
-    );
+    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 getSoftContradictions = action({
+var searchAllNodes = action({
   args: {
-    similarityThreshold: v.optional(v.number()),
-    limit: v.optional(v.number()),
-    apiBaseUrl: v.optional(v.string()),
-    topicId: v.optional(v.string())
+    searchText: v.string(),
+    limit: v.optional(v.number())
   },
   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
-    );
+    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 getSemanticBridges = action({
+var getNodeRelationships = action({
   args: {
-    similarityThreshold: v.optional(v.number()),
-    limit: v.optional(v.number()),
-    apiBaseUrl: v.optional(v.string()),
-    topicId: v.optional(v.string())
+    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(
-      "semanticBridges",
-      withTopicScope(args, {
-        similarityThreshold: clamp(args.similarityThreshold ?? 0.7, 0, 1),
-        limit: toInt(args.limit, 20)
-      }),
-      args.apiBaseUrl
-    );
+    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 graphAwareSearch = action({
+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: {
-    embedding: v.array(v.float64()),
-    indexName: v.optional(v.string()),
-    topK: v.optional(v.number()),
-    minScore: v.optional(v.number()),
+    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) => {
-    if (args.embedding.length !== EMBEDDING_DIMENSIONS) {
+    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: `Embedding must be ${EMBEDDING_DIMENSIONS} dimensions, got ${args.embedding.length}`
+        error: `Query type '${args.queryType}' requires 'themeName' parameter`
       };
     }
-    const indexName = args.indexName || "belief_embedding_index";
-    if (!VALID_INDEX_NAMES.has(indexName)) {
-      return { results: [], error: `Invalid index name: ${indexName}` };
+    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(
-      "graphAwareSearch",
+      args.queryType,
       withTopicScope(args, {
-        embedding: args.embedding,
-        indexName,
-        topK: toInt(args.topK, 10),
-        minScore: clamp(args.minScore ?? 0.5, 0, 1)
+        ...args.params,
+        limit
       }),
       args.apiBaseUrl
     );