@rubytech/create-maxy 1.0.693 → 1.0.695

package/payload/server/server.js

@@ -7,6 +7,8 @@ import {
   TELEGRAM_ADMIN_WEBHOOK_SECRET_FILE,
   TELEGRAM_WEBHOOK_SECRET_FILE,
   USERS_FILE,
+  __commonJS,
+  __toESM,
   agentLogStream,
   backfillNullUserIdConversations,
   bindVisitorToGroup,
@@ -22,6 +24,7 @@ import {
   computeConstraints,
   createRemoteSession,
   deleteConversation,
+  embed,
   ensureAuth,
   ensureCdp,
   ensureLogDir,
@@ -74,7 +77,6 @@ import {
   resolveUserAccounts,
   safeJson,
   sanitizeClientCorrId,
-  searchKnowledgeFulltext,
   seedSessionHistory,
   serve,
   setConversationIdForSession,
@@ -95,7 +97,281 @@ import {
   vncLog,
   waitForExit,
   writeChromiumWrapper
-} from "./chunk-Q6NDXCM6.js";
+} from "./chunk-IAIGB5WN.js";
+
+// ../lib/graph-trash/dist/index.js
+var require_dist = __commonJS({
+  "../lib/graph-trash/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TRASH_METADATA_PROPS = void 0;
+    exports.trashNode = trashNode2;
+    exports.restoreNode = restoreNode2;
+    exports.emptyTrash = emptyTrash;
+    exports.notTrashed = notTrashed2;
+    exports.uniqueKeysForLabels = uniqueKeysForLabels;
+    var UNIQUE_KEYS_BY_LABEL2 = {
+      Person: ["email", "telephone"],
+      Service: ["serviceId"],
+      LocalBusiness: ["accountId"],
+      Task: ["taskId"],
+      Event: ["eventId"],
+      KnowledgeDocument: ["attachmentId"],
+      DigitalDocument: ["attachmentId"],
+      Conversation: ["conversationId", "sessionKey"],
+      Message: ["messageId"],
+      OnboardingState: ["accountId"],
+      Workflow: ["workflowId"],
+      WorkflowStep: ["stepId"],
+      WorkflowRun: ["runId"],
+      Preference: ["preferenceId"],
+      Email: ["emailId", "messageId"],
+      AdminUser: ["userId"],
+      ToolCall: ["callId"],
+      // Composite component nulls — frees the composite constraint:
+      AccessGrant: ["contactValue"],
+      // composite (contactValue, agentSlug, accountId)
+      UserProfile: ["userId"]
+      // composite (accountId, userId)
+    };
+    var TRASH_PROP_NAMES = [
+      "trashedAt",
+      "trashedBy",
+      "trashReason",
+      "_trashedKeys"
+    ];
+    async function trashNode2(params) {
+      const { session, accountId, elementId, by, reason } = params;
+      const lookup = await session.run(`MATCH (n) WHERE elementId(n) = $eid AND n.accountId = $accountId
+     RETURN labels(n) AS labels, properties(n) AS props`, { eid: elementId, accountId });
+      if (lookup.records.length === 0) {
+        throw new Error(`trashNode: node not found (elementId=${elementId} accountId=${accountId.slice(0, 8)}\u2026)`);
+      }
+      const allLabels = lookup.records[0].get("labels");
+      const props = lookup.records[0].get("props");
+      const baseLabels = allLabels.filter((l) => l !== "Trashed");
+      if (allLabels.includes("Trashed")) {
+        return {
+          trashed: false,
+          alreadyTrashed: true,
+          nodeId: elementId,
+          labels: baseLabels,
+          trashedAt: String(props.trashedAt ?? ""),
+          originalKeys: {}
+        };
+      }
+      const uniqueKeys = /* @__PURE__ */ new Set();
+      for (const label of baseLabels) {
+        for (const key of UNIQUE_KEYS_BY_LABEL2[label] ?? [])
+          uniqueKeys.add(key);
+      }
+      const originalKeys = {};
+      for (const k of uniqueKeys) {
+        if (props[k] !== void 0 && props[k] !== null)
+          originalKeys[k] = props[k];
+      }
+      const setNullClauses = Object.keys(originalKeys).map((k) => `n.\`${k}\` = null`).join(", ");
+      const setNullSuffix = setNullClauses ? `, ${setNullClauses}` : "";
+      const trashedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const isConversation = baseLabels.includes("Conversation");
+      const messageUniqueKeys = UNIQUE_KEYS_BY_LABEL2["Message"] ?? [];
+      let cascadedMessageCount = 0;
+      await session.executeWrite(async (tx) => {
+        await tx.run(`MATCH (n) WHERE elementId(n) = $eid
+       SET n:Trashed,
+           n.trashedAt = datetime($trashedAt),
+           n.trashedBy = $by,
+           n.trashReason = $reason,
+           n._trashedKeys = $trashedKeysJson${setNullSuffix}`, {
+          eid: elementId,
+          trashedAt,
+          by,
+          reason: reason ?? null,
+          trashedKeysJson: JSON.stringify(originalKeys)
+        });
+        if (isConversation) {
+          const collectKeys = messageUniqueKeys.length > 0 ? messageUniqueKeys.map((k) => `\`${k}\`: m.\`${k}\``).join(", ") : "";
+          const collectMsgProps = collectKeys ? `, {${collectKeys}}` : ", {}";
+          const collected = await tx.run(`MATCH (c) WHERE elementId(c) = $eid
+         MATCH (m:Message)-[:PART_OF]->(c)
+         WHERE NOT m:Trashed
+         RETURN elementId(m) AS meid${collectMsgProps} AS keys`, { eid: elementId });
+          for (const rec of collected.records) {
+            const meid = rec.get("meid");
+            const keys = rec.get("keys");
+            const liveKeys = {};
+            for (const k of messageUniqueKeys) {
+              if (keys[k] !== void 0 && keys[k] !== null)
+                liveKeys[k] = keys[k];
+            }
+            const msgSetNulls = Object.keys(liveKeys).length > 0 ? ", " + Object.keys(liveKeys).map((k) => `m.\`${k}\` = null`).join(", ") : "";
+            await tx.run(`MATCH (m) WHERE elementId(m) = $meid
+           SET m:Trashed,
+               m.trashedAt = datetime($trashedAt),
+               m.trashedBy = $by,
+               m.trashReason = $reason,
+               m._trashedKeys = $trashedKeysJson${msgSetNulls}`, {
+              meid,
+              trashedAt,
+              by: `${by}:cascade-from-conversation`,
+              reason: reason ?? `cascade from Conversation ${elementId}`,
+              trashedKeysJson: JSON.stringify(liveKeys)
+            });
+          }
+          cascadedMessageCount = collected.records.length;
+        }
+      });
+      process.stderr.write(`[trash:marked] accountId=${accountId} elementId=${elementId} labels=${baseLabels.join(",")} by=${by} reason=${reason ?? "null"}
+`);
+      if (isConversation) {
+        process.stderr.write(`[trash:cascaded] accountId=${accountId} conversationElementId=${elementId} messageCount=${cascadedMessageCount} by=${by}
+`);
+      }
+      return {
+        trashed: true,
+        alreadyTrashed: false,
+        nodeId: elementId,
+        labels: baseLabels,
+        trashedAt,
+        originalKeys
+      };
+    }
+    async function restoreNode2(params) {
+      const { session, accountId, elementId } = params;
+      const lookup = await session.run(`MATCH (n:Trashed) WHERE elementId(n) = $eid
+     RETURN labels(n) AS labels, n._trashedKeys AS keysJson`, { eid: elementId });
+      if (lookup.records.length === 0) {
+        throw new Error(`restoreNode: trashed node not found (elementId=${elementId})`);
+      }
+      const allLabels = lookup.records[0].get("labels");
+      const baseLabels = allLabels.filter((l) => l !== "Trashed");
+      const keysJson = lookup.records[0].get("keysJson");
+      const originalKeys = keysJson ? JSON.parse(keysJson) : {};
+      for (const label of baseLabels) {
+        const uniqueKeys = UNIQUE_KEYS_BY_LABEL2[label] ?? [];
+        for (const k of uniqueKeys) {
+          const v = originalKeys[k];
+          if (v === void 0 || v === null)
+            continue;
+          const conflict = await session.run(`MATCH (other:\`${label}\`)
+         WHERE elementId(other) <> $eid
+           AND NOT other:Trashed
+           AND other.\`${k}\` = $val
+         RETURN elementId(other) AS otherId LIMIT 1`, { eid: elementId, val: v });
+          if (conflict.records.length > 0) {
+            const otherId = conflict.records[0].get("otherId");
+            throw new Error(`restoreNode: cannot restore ${label} elementId=${elementId} \u2014 active node elementId=${otherId} already holds ${k}=${JSON.stringify(v)}`);
+          }
+        }
+      }
+      const setClauses = Object.keys(originalKeys).map((k) => `n.\`${k}\` = $val_${k}`).join(", ");
+      const setSuffix = setClauses ? `, ${setClauses}` : "";
+      const setParams = { eid: elementId };
+      for (const [k, v] of Object.entries(originalKeys))
+        setParams[`val_${k}`] = v;
+      const isConversation = baseLabels.includes("Conversation");
+      let cascadedMessageCount = 0;
+      await session.executeWrite(async (tx) => {
+        await tx.run(`MATCH (n:Trashed) WHERE elementId(n) = $eid
+       REMOVE n:Trashed, n.trashedAt, n.trashedBy, n.trashReason, n._trashedKeys
+       SET n.restoredAt = datetime()${setSuffix}`, setParams);
+        if (isConversation) {
+          const collected = await tx.run(`MATCH (c) WHERE elementId(c) = $eid
+         MATCH (m:Trashed:Message)-[:PART_OF]->(c)
+         WHERE m.trashedBy ENDS WITH ':cascade-from-conversation'
+         RETURN elementId(m) AS meid, m._trashedKeys AS keysJson`, { eid: elementId });
+          for (const rec of collected.records) {
+            const meid = rec.get("meid");
+            const keysJson2 = rec.get("keysJson");
+            const keys = keysJson2 ? JSON.parse(keysJson2) : {};
+            const setClause = Object.keys(keys).length > 0 ? ", " + Object.keys(keys).map((k) => `m.\`${k}\` = $val_${k}`).join(", ") : "";
+            const msgParams = { meid };
+            for (const [k, v] of Object.entries(keys))
+              msgParams[`val_${k}`] = v;
+            await tx.run(`MATCH (m) WHERE elementId(m) = $meid
+           REMOVE m:Trashed, m.trashedAt, m.trashedBy, m.trashReason, m._trashedKeys
+           SET m.restoredAt = datetime()${setClause}`, msgParams);
+          }
+          cascadedMessageCount = collected.records.length;
+        }
+      });
+      process.stderr.write(`[trash:restored] accountId=${accountId} elementId=${elementId} labels=${baseLabels.join(",")}
+`);
+      if (isConversation) {
+        process.stderr.write(`[trash:cascade-restored] accountId=${accountId} conversationElementId=${elementId} messageCount=${cascadedMessageCount}
+`);
+      }
+      return {
+        restored: true,
+        nodeId: elementId,
+        labels: baseLabels,
+        restoredKeys: originalKeys
+      };
+    }
+    async function emptyTrash(params) {
+      const t0 = Date.now();
+      const { session, accountId, graceDays = 30, dryRun = false, labels: labelFilter, onEmpty } = params;
+      const cutoff = new Date(Date.now() - graceDays * 24 * 60 * 60 * 1e3).toISOString();
+      const labelClause = labelFilter && labelFilter.length > 0 ? `AND ANY(l IN labels(n) WHERE l IN $labelFilter)` : "";
+      const candidatesResult = await session.run(`MATCH (n:Trashed)
+     WHERE n.trashedAt < datetime($cutoff)
+     ${labelClause}
+     RETURN elementId(n) AS eid,
+            labels(n) AS labels,
+            toString(n.trashedAt) AS trashedAt,
+            n.trashedBy AS trashedBy,
+            n._trashedKeys AS keysJson
+     ORDER BY n.trashedAt ASC`, { cutoff, ...labelFilter ? { labelFilter } : {} });
+      const candidates = candidatesResult.records.map((r) => {
+        const keysJson = r.get("keysJson");
+        return {
+          elementId: r.get("eid"),
+          labels: r.get("labels").filter((l) => l !== "Trashed"),
+          trashedAt: String(r.get("trashedAt")),
+          trashedBy: r.get("trashedBy") ?? null,
+          trashedKeys: keysJson ? JSON.parse(keysJson) : {}
+        };
+      });
+      process.stderr.write(`[trash:empty-run] accountId=${accountId} graceDays=${graceDays} dryRun=${dryRun} candidates=${candidates.length}
+`);
+      if (dryRun || candidates.length === 0) {
+        process.stderr.write(`[graph:trash:summary] accountId=${accountId} trashedNow=0 emptiedThisRun=0 graceDays=${graceDays} dryRun=${dryRun} elapsedMs=${Date.now() - t0}
+`);
+        return { graceDays, dryRun, candidates, emptied: 0 };
+      }
+      let emptied = 0;
+      for (const c of candidates) {
+        if (onEmpty) {
+          try {
+            await onEmpty(c);
+          } catch (err) {
+            process.stderr.write(`[trash:empty-run] onEmpty side-effect failed for elementId=${c.elementId}: ${err instanceof Error ? err.message : String(err)}
+`);
+          }
+        }
+        await session.run(`MATCH (n) WHERE elementId(n) = $eid DETACH DELETE n`, { eid: c.elementId });
+        const ageDays = Math.floor((Date.now() - new Date(c.trashedAt).getTime()) / (24 * 60 * 60 * 1e3));
+        process.stderr.write(`[trash:emptied] accountId=${accountId} elementId=${c.elementId} labels=${c.labels.join(",")} trashedAt=${c.trashedAt} ageDays=${ageDays}
+`);
+        emptied++;
+      }
+      process.stderr.write(`[graph:trash:summary] accountId=${accountId} trashedNow=0 emptiedThisRun=${emptied} graceDays=${graceDays} dryRun=${dryRun} elapsedMs=${Date.now() - t0}
+`);
+      return { graceDays, dryRun, candidates, emptied };
+    }
+    function notTrashed2(alias) {
+      return `(NOT \`${alias}\`:Trashed AND \`${alias}\`.deletedAt IS NULL)`;
+    }
+    function uniqueKeysForLabels(labels) {
+      const out = /* @__PURE__ */ new Set();
+      for (const l of labels)
+        for (const k of UNIQUE_KEYS_BY_LABEL2[l] ?? [])
+          out.add(k);
+      return [...out];
+    }
+    exports.TRASH_METADATA_PROPS = TRASH_PROP_NAMES;
+  }
+});
 
 // node_modules/hono/dist/utils/mime.js
 var getMimeType = (filename, mimes = baseMimes) => {
@@ -2405,12 +2681,12 @@ function createBaileysLogger(bindings = {}) {
 var credsSaveQueue = Promise.resolve();
 async function drainCredsSaveQueue(timeoutMs = 5e3) {
   console.error(`${TAG3} draining credential save queue\u2026`);
-  const timer = new Promise(
+  const timer2 = new Promise(
     (resolve22) => setTimeout(() => resolve22("timeout"), timeoutMs)
   );
   const result = await Promise.race([
     credsSaveQueue.then(() => "drained"),
-    timer
+    timer2
   ]);
   if (result === "timeout") {
     console.error(`${TAG3} credential save queue drain timed out after ${timeoutMs}ms`);
@@ -2653,16 +2929,16 @@ ${inspected}`;
 }
 function withTimeout(label, promise, timeoutMs) {
   return new Promise((resolve22, reject) => {
-    const timer = setTimeout(() => {
+    const timer2 = setTimeout(() => {
       reject(new Error(`${label} timed out after ${timeoutMs}ms`));
     }, timeoutMs);
     promise.then(
       (value) => {
-        clearTimeout(timer);
+        clearTimeout(timer2);
         resolve22(value);
       },
       (err) => {
-        clearTimeout(timer);
+        clearTimeout(timer2);
         reject(err);
       }
     );
@@ -3350,10 +3626,10 @@ function createInboundDebouncer(opts) {
         flushKey(key).catch(onError);
       }, debounceMs);
     } else {
-      const timer = setTimeout(() => {
+      const timer2 = setTimeout(() => {
         flushKey(key).catch(onError);
       }, debounceMs);
-      pending.set(key, { entries: [msg], timer });
+      pending.set(key, { entries: [msg], timer: timer2 });
     }
   }
   function registerPending(key, promise) {
@@ -3874,9 +4150,9 @@ async function connectWithReconnect(conn) {
         `${TAG11} reconnecting account=${conn.accountId} in ${delay}ms (attempt ${decision.nextAttempts}/${maxAttempts})`
       );
       await new Promise((resolve22) => {
-        const timer = setTimeout(resolve22, delay);
+        const timer2 = setTimeout(resolve22, delay);
         conn.abortController.signal.addEventListener("abort", () => {
-          clearTimeout(timer);
+          clearTimeout(timer2);
           resolve22();
         }, { once: true });
       });
@@ -5013,7 +5289,7 @@ async function processInbound(rawText, channel) {
     return result;
   }
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), GATEWAY_TIMEOUT_MS);
+  const timer2 = setTimeout(() => controller.abort(), GATEWAY_TIMEOUT_MS);
   try {
     const client = new Anthropic({ apiKey });
     const response = await client.messages.create(
@@ -5089,7 +5365,7 @@ async function processInbound(rawText, channel) {
     );
     return defaultResult(rawText.trim(), latencyMs);
   } finally {
-    clearTimeout(timer);
+    clearTimeout(timer2);
   }
 }
 
@@ -7560,7 +7836,7 @@ function startScriptStreamTailer(opts) {
   let buffer = "";
   let stopped = false;
   let pendingRead = false;
-  let timer;
+  let timer2;
   const processLine = (line) => {
     const event = parseLine(line);
     if (event) onEvent(event);
@@ -7607,15 +7883,15 @@ function startScriptStreamTailer(opts) {
     if (stopped) return;
     readDelta().catch(() => {
     }).finally(() => {
-      if (!stopped) timer = setTimeout(tick, 200);
+      if (!stopped) timer2 = setTimeout(tick, 200);
     });
   };
-  timer = setTimeout(tick, 0);
+  timer2 = setTimeout(tick, 0);
   return {
     async stop() {
       if (stopped) return;
       stopped = true;
-      if (timer) clearTimeout(timer);
+      if (timer2) clearTimeout(timer2);
       while (pendingRead) {
         await new Promise((r) => setImmediate(r));
       }
@@ -9730,6 +10006,304 @@ app23.delete("/", requireAdminSession, async (c) => {
 });
 var files_default = app23;
 
+// ../lib/graph-search/src/index.ts
+var import_dist = __toESM(require_dist());
+import { int } from "neo4j-driver";
+var VECTOR_WEIGHT = 0.7;
+var BM25_WEIGHT = 0.3;
+var FULLTEXT_INDEX_NAME = "knowledge_fulltext";
+function escapeLucene(query) {
+  return query.replace(/[+\-&|!(){}[\]^"~*?:\\/]/g, "\\$&");
+}
+function normaliseBm25Scores(scores) {
+  if (scores.length === 0) return [];
+  const min = Math.min(...scores);
+  const max = Math.max(...scores);
+  const range = max - min;
+  if (range === 0) return scores.map(() => 1);
+  return scores.map((s) => (s - min) / range);
+}
+var indexCache = null;
+async function discoverIndexes(session) {
+  if (indexCache) return indexCache;
+  const result = await session.run(
+    `SHOW INDEXES YIELD name, labelsOrTypes, type WHERE type = 'VECTOR' RETURN name, labelsOrTypes`
+  );
+  const fresh = /* @__PURE__ */ new Map();
+  for (const record of result.records) {
+    const name = record.get("name");
+    const labels = record.get("labelsOrTypes");
+    for (const label of labels) fresh.set(label, name);
+  }
+  indexCache = fresh;
+  return fresh;
+}
+function buildKeywordFilter(keywords, keywordMatch = "any") {
+  if (!keywords || keywords.length === 0) return void 0;
+  const fn = keywordMatch === "all" ? "ALL" : "ANY";
+  return {
+    clause: `AND (node.keywords IS NULL OR ${fn}(kw IN $keywords WHERE kw IN node.keywords))`,
+    params: { keywords: keywords.map((k) => k.toLowerCase().trim()) }
+  };
+}
+async function bm25Only(session, params) {
+  const { query, accountId, limit, allowedScopes, agentSlug, keywords, keywordMatch } = params;
+  const scopeClause = allowedScopes ? "AND (node.scope IS NULL OR node.scope IN $allowedScopes)" : "";
+  const agentClause = agentSlug ? "AND node.agents IS NOT NULL AND $agentSlug IN node.agents" : "";
+  const keywordFilter = buildKeywordFilter(keywords, keywordMatch);
+  const kwClause = keywordFilter?.clause ?? "";
+  const escaped = escapeLucene(query);
+  try {
+    const result = await session.run(
+      `CALL db.index.fulltext.queryNodes($indexName, $query)
+       YIELD node, score
+       WHERE node.accountId = $accountId
+       ${scopeClause}
+       ${agentClause}
+       AND ${(0, import_dist.notTrashed)("node")}
+       ${kwClause}
+       RETURN node, score, labels(node) AS nodeLabels, elementId(node) AS nodeId
+       ORDER BY score DESC
+       LIMIT $limit`,
+      {
+        indexName: FULLTEXT_INDEX_NAME,
+        query: escaped,
+        accountId,
+        limit: int(limit),
+        ...allowedScopes ? { allowedScopes } : {},
+        ...agentSlug ? { agentSlug } : {},
+        ...keywordFilter?.params ?? {}
+      }
+    );
+    return result.records.map((r) => {
+      const scoreRaw = r.get("score");
+      const score = typeof scoreRaw === "number" ? scoreRaw : Number(scoreRaw);
+      const node = r.get("node");
+      return {
+        nodeId: r.get("nodeId"),
+        labels: r.get("nodeLabels"),
+        properties: plainProperties(node.properties),
+        score
+      };
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("index") || msg.includes("fulltext") || msg.includes("not found")) {
+      return [];
+    }
+    throw err;
+  }
+}
+async function hybrid(session, embed2, params) {
+  const {
+    query,
+    labels,
+    accountId,
+    limit,
+    allowedScopes,
+    keywords,
+    keywordMatch = "any",
+    agentSlug,
+    keywordSubscriptions,
+    expandHops = 1,
+    degradeOnEmbedFailure = false
+  } = params;
+  let queryEmbedding;
+  try {
+    queryEmbedding = await embed2(query);
+  } catch (err) {
+    if (!degradeOnEmbedFailure) throw err;
+    const msg = err instanceof Error ? err.message : String(err);
+    const bm25Hits2 = await bm25Only(session, params);
+    const results2 = bm25Hits2.map((h) => ({ ...h, related: [] }));
+    return { mode: "bm25", results: results2, embedError: msg };
+  }
+  const labelToIndex = await discoverIndexes(session);
+  const keywordFilter = buildKeywordFilter(keywords, keywordMatch);
+  const keywordClause = keywordFilter?.clause ?? "";
+  const keywordParams = keywordFilter?.params ?? {};
+  const scoreMap = /* @__PURE__ */ new Map();
+  let indexesToQuery;
+  if (labels && labels.length > 0) {
+    indexesToQuery = labels.map((l) => labelToIndex.get(l)).filter((idx) => idx !== void 0);
+    if (indexesToQuery.length === 0) {
+      return { mode: "hybrid", results: [] };
+    }
+  } else {
+    indexesToQuery = [...new Set(labelToIndex.values())];
+  }
+  const scopeClause = allowedScopes ? "AND (node.scope IS NULL OR node.scope IN $allowedScopes)" : "";
+  const scopeParams = allowedScopes ? { allowedScopes } : {};
+  const agentClause = agentSlug ? "AND node.agents IS NOT NULL AND $agentSlug IN node.agents" : "";
+  const agentParams = agentSlug ? { agentSlug } : {};
+  for (const indexName of indexesToQuery) {
+    const vectorResult = await session.run(
+      `CALL db.index.vector.queryNodes($indexName, $limit, $embedding)
+       YIELD node, score
+       WHERE node.accountId = $accountId
+       ${scopeClause}
+       ${agentClause}
+       AND ${(0, import_dist.notTrashed)("node")}
+       ${keywordClause}
+       RETURN node, score, labels(node) AS nodeLabels, elementId(node) AS nodeId
+       ORDER BY score DESC
+       LIMIT $limit`,
+      {
+        indexName,
+        embedding: queryEmbedding,
+        limit: int(limit),
+        accountId,
+        ...scopeParams,
+        ...agentParams,
+        ...keywordParams
+      }
+    );
+    for (const record of vectorResult.records) {
+      const nodeId = record.get("nodeId");
+      const scoreRaw = record.get("score");
+      const score = typeof scoreRaw === "number" ? scoreRaw : Number(scoreRaw);
+      const existing = scoreMap.get(nodeId);
+      if (existing) {
+        existing.vectorScore = Math.max(existing.vectorScore, score);
+      } else {
+        const node = record.get("node");
+        scoreMap.set(nodeId, {
+          nodeId,
+          labels: record.get("nodeLabels"),
+          properties: plainProperties(node.properties),
+          vectorScore: score,
+          bm25Score: 0
+        });
+      }
+    }
+  }
+  const bm25Hits = await bm25Only(session, params);
+  if (bm25Hits.length > 0) {
+    const rawScores = bm25Hits.map((h) => h.score);
+    const normalised = normaliseBm25Scores(rawScores);
+    for (let i = 0; i < bm25Hits.length; i++) {
+      mergeBm25Hit(scoreMap, bm25Hits[i], normalised[i]);
+    }
+  }
+  if (keywordSubscriptions && keywordSubscriptions.length > 0) {
+    for (const kw of keywordSubscriptions) {
+      const kwHits = await bm25Only(session, {
+        query: kw,
+        accountId,
+        limit,
+        allowedScopes
+      });
+      if (kwHits.length === 0) continue;
+      const rawScores = kwHits.map((h) => h.score);
+      const normalised = normaliseBm25Scores(rawScores);
+      for (let i = 0; i < kwHits.length; i++) {
+        mergeBm25Hit(scoreMap, kwHits[i], normalised[i]);
+      }
+    }
+    const propScopeClause = allowedScopes ? "AND (node.scope IS NULL OR node.scope IN $allowedScopes)" : "";
+    const propResult = await session.run(
+      `MATCH (node)
+       WHERE node.accountId = $accountId
+       AND ${(0, import_dist.notTrashed)("node")}
+       AND node.keywords IS NOT NULL
+       AND ANY(kw IN $kwSubs WHERE ANY(nk IN node.keywords WHERE toLower(nk) = kw))
+       ${propScopeClause}
+       RETURN node, labels(node) AS nodeLabels, elementId(node) AS nodeId
+       LIMIT $limit`,
+      {
+        accountId,
+        kwSubs: keywordSubscriptions,
+        limit: int(limit),
+        ...allowedScopes ? { allowedScopes } : {}
+      }
+    );
+    for (const record of propResult.records) {
+      const nodeId = record.get("nodeId");
+      const existing = scoreMap.get(nodeId);
+      if (existing) {
+        existing.bm25Score = Math.max(existing.bm25Score, 1);
+      } else {
+        const node = record.get("node");
+        scoreMap.set(nodeId, {
+          nodeId,
+          labels: record.get("nodeLabels"),
+          properties: plainProperties(node.properties),
+          vectorScore: 0,
+          bm25Score: 1
+        });
+      }
+    }
+  }
+  const merged = [...scoreMap.values()].map((node) => ({
+    ...node,
+    combinedScore: VECTOR_WEIGHT * node.vectorScore + BM25_WEIGHT * node.bm25Score
+  })).sort((a, b) => b.combinedScore - a.combinedScore).slice(0, limit);
+  const results = [];
+  for (const node of merged) {
+    const result = {
+      nodeId: node.nodeId,
+      labels: node.labels,
+      properties: node.properties,
+      score: node.combinedScore,
+      related: []
+    };
+    if (expandHops > 0) {
+      const expandScopeClause = allowedScopes ? "AND (related.scope IS NULL OR related.scope IN $allowedScopes)" : "";
+      const expandAgentClause = agentSlug ? "AND (related.agents IS NULL OR $agentSlug IN related.agents)" : "";
+      const expandResult = await session.run(
+        `MATCH (n)-[r]-(related)
+         WHERE elementId(n) = $nodeId
+         AND ${(0, import_dist.notTrashed)("related")}
+         ${expandScopeClause}
+         ${expandAgentClause}
+         RETURN type(r) AS relType,
+                CASE WHEN startNode(r) = n THEN 'outgoing' ELSE 'incoming' END AS direction,
+                labels(related) AS relatedLabels,
+                related
+         LIMIT 20`,
+        { nodeId: node.nodeId, ...scopeParams, ...agentParams }
+      );
+      for (const rec of expandResult.records) {
+        const related = rec.get("related");
+        result.related.push({
+          relationship: rec.get("relType"),
+          direction: rec.get("direction"),
+          labels: rec.get("relatedLabels"),
+          properties: plainProperties(related.properties)
+        });
+      }
+    }
+    results.push(result);
+  }
+  return { mode: "hybrid", results };
+}
+function mergeBm25Hit(map, hit, normalisedScore) {
+  const existing = map.get(hit.nodeId);
+  if (existing) {
+    existing.bm25Score = Math.max(existing.bm25Score, normalisedScore);
+  } else {
+    map.set(hit.nodeId, {
+      nodeId: hit.nodeId,
+      labels: hit.labels,
+      properties: hit.properties,
+      vectorScore: 0,
+      bm25Score: normalisedScore
+    });
+  }
+}
+function plainProperties(properties) {
+  const plain = {};
+  for (const [key, value] of Object.entries(properties)) {
+    if (key === "embedding") continue;
+    if (value && typeof value === "object" && "toNumber" in value) {
+      plain[key] = value.toNumber();
+    } else {
+      plain[key] = value;
+    }
+  }
+  return plain;
+}
+
 // server/routes/admin/graph-search.ts
 var DEFAULT_LIMIT = 20;
 var MAX_LIMIT = 100;
@@ -9740,23 +10314,40 @@ app24.get("/", requireAdminSession, async (c) => {
   const rawLimit = c.req.query("limit");
   const accountId = getAccountIdForSession(sessionKey);
   if (!accountId) {
-    console.error(`[data] auth-rejected endpoint="/api/admin/graph-search" reason="no account for session"`);
+    console.error(`[graph-search] auth-rejected endpoint="/api/admin/graph-search" reason="no account for session"`);
     return c.json({ error: "Account not found for session" }, 401);
   }
   if (!q) return c.json({ error: "q (search query) required" }, 400);
   const parsedLimit = rawLimit ? parseInt(rawLimit, 10) : DEFAULT_LIMIT;
   const limit = Number.isFinite(parsedLimit) && parsedLimit > 0 ? Math.min(parsedLimit, MAX_LIMIT) : DEFAULT_LIMIT;
   const started = Date.now();
+  const session = getSession();
   try {
-    const results = await searchKnowledgeFulltext(accountId, q, limit);
+    const res = await hybrid(session, embed, {
+      query: q,
+      accountId,
+      limit,
+      degradeOnEmbedFailure: true
+    });
     const elapsed = Date.now() - started;
-    console.error(`[data] graph-search query="${q}" results=${results.length} ms=${elapsed}`);
+    if (res.embedError) {
+      console.error(`[graph-search] embed-unavailable err="${res.embedError}" \u2014 bm25-only`);
+    }
+    console.error(`[graph-search] query="${q}" mode=${res.mode} results=${res.results.length} ms=${elapsed}`);
+    const results = res.results.map((r) => ({
+      nodeId: r.nodeId,
+      labels: r.labels,
+      properties: r.properties,
+      score: r.score
+    }));
     return c.json({ results, elapsedMs: elapsed });
   } catch (err) {
     const elapsed = Date.now() - started;
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`[data] graph-search neo4j-unreachable query="${q}" ms=${elapsed} err="${message}"`);
+    console.error(`[graph-search] neo4j-unreachable query="${q}" ms=${elapsed} err="${message}"`);
     return c.json({ error: `Graph search unavailable: ${message}` }, 503);
+  } finally {
+    await session.close();
   }
 });
 var graph_search_default = app24;
@@ -10596,6 +11187,49 @@ app32.route("/file-attach", file_attach_default);
 app32.route("/adherence", adherence_default);
 var admin_default = app32;
 
+// app/lib/graph-health.ts
+var HOUR_MS = 60 * 60 * 1e3;
+var timer = null;
+async function runGraphHealthTick() {
+  const session = getSession();
+  try {
+    const totalResult = await session.run(
+      `MATCH (n) WHERE NOT (n)--() RETURN count(n) AS total`
+    );
+    const total = totalResult.records[0]?.get("total")?.toNumber?.() ?? 0;
+    const topResult = await session.run(
+      `MATCH (n) WHERE NOT (n)--()
+       WITH labels(n) AS lbls, count(*) AS c
+       ORDER BY c DESC
+       LIMIT 5
+       RETURN collect({labels: lbls, count: c}) AS top`
+    );
+    const topFromDb = topResult.records[0]?.get("top") ?? [];
+    const topStr = topFromDb.map((b) => {
+      const labels = b.labels.join("+") || "(none)";
+      const c = typeof b.count === "number" ? b.count : b.count.toNumber?.() ?? 0;
+      return `${labels}:${c}`;
+    }).join(",");
+    console.error(`[graph-health] orphans total=${total} top=${topStr || "none"}`);
+  } catch (err) {
+    console.error(
+      `[graph-health] query failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  } finally {
+    await session.close();
+  }
+}
+function startGraphHealthTimer() {
+  if (timer) return;
+  runGraphHealthTick().catch(() => {
+  });
+  timer = setInterval(() => {
+    runGraphHealthTick().catch(() => {
+    });
+  }, HOUR_MS);
+  if (typeof timer.unref === "function") timer.unref();
+}
+
 // server/index.ts
 var PLATFORM_ROOT6 = process.env.MAXY_PLATFORM_ROOT || "";
 var BRAND_JSON_PATH = PLATFORM_ROOT6 ? join9(PLATFORM_ROOT6, "config", "brand.json") : "";
@@ -11282,6 +11916,7 @@ try {
     console.error(`[review] startReviewDetector rejected: ${err instanceof Error ? err.message : String(err)}`);
   }
 })();
+startGraphHealthTimer();
 var configDirForWhatsApp = basename7(MAXY_DIR) || ".maxy";
 var bootAccount = resolveAccount();
 var bootAccountConfig = bootAccount?.config;